@akms/mcp-ssh 0.0.3 → 0.1.1

package/lib/cli.cjs

@@ -2,10 +2,12 @@
 'use strict';
 
 var stdio_js = require('@modelcontextprotocol/sdk/server/stdio.js');
-var os = require('os');
-var path2 = require('path');
+var fs6 = require('fs');
+var os5 = require('os');
+var path = require('path');
+var child_process = require('child_process');
 var crypto = require('crypto');
-var fs = require('fs');
+var stream = require('stream');
 var string_decoder = require('string_decoder');
 var ssh2 = require('ssh2');
 var timers = require('timers');
@@ -14,9 +16,9 @@ var zod = require('zod');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var os__default = /*#__PURE__*/_interopDefault(os);
-var path2__default = /*#__PURE__*/_interopDefault(path2);
-var fs__default = /*#__PURE__*/_interopDefault(fs);
+var fs6__default = /*#__PURE__*/_interopDefault(fs6);
+var os5__default = /*#__PURE__*/_interopDefault(os5);
+var path__default = /*#__PURE__*/_interopDefault(path);
 var ssh2__default = /*#__PURE__*/_interopDefault(ssh2);
 
 // src/_defs/defaults.ts
@@ -32,7 +34,8 @@ 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 PACKAGE_NAME = "@akms/mcp-ssh";
+var SERVER_VERSION = "0.1.1";
 
 // src/_defs/command-rules.ts
 var CRITICAL_PATH_PATTERN = new RegExp(
@@ -454,6 +457,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. */
@@ -580,20 +599,38 @@ function formatBytes(bytes) {
   const megabytes = bytes / (1024 * 1024);
   return `${megabytes.toFixed(1)} MB`;
 }
+function findExecutable(name) {
+  const searchPath = process.env.PATH ?? "";
+  const directories = searchPath.split(path__default.default.delimiter).filter((directory) => directory !== "");
+  let suffixes = [""];
+  if (process.platform === "win32") {
+    const pathExt = process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD";
+    suffixes = pathExt.split(";").filter((suffix) => suffix !== "");
+  }
+  for (const directory of directories) {
+    for (const suffix of suffixes) {
+      const candidate = path__default.default.join(directory, `${name}${suffix}`);
+      if (fs6__default.default.existsSync(candidate) == true && fs6__default.default.statSync(candidate).isFile() == true) {
+        return candidate;
+      }
+    }
+  }
+  return null;
+}
 function expandHomePath(inputPath) {
   let expanded = inputPath;
   if (inputPath === "~") {
-    expanded = os__default.default.homedir();
+    expanded = os5__default.default.homedir();
   } else if (inputPath.startsWith("~/") == true || inputPath.startsWith("~\\") == true) {
-    expanded = path2__default.default.join(os__default.default.homedir(), inputPath.slice(2));
+    expanded = path__default.default.join(os5__default.default.homedir(), inputPath.slice(2));
   }
-  return path2__default.default.resolve(expanded);
+  return path__default.default.resolve(expanded);
 }
 function isAbsoluteRemotePath(remotePath) {
   return remotePath.startsWith("/");
 }
 function normalizeRemotePath(remotePath) {
-  return path2__default.default.posix.normalize(remotePath);
+  return path__default.default.posix.normalize(remotePath);
 }
 function isRemotePathWithin(candidate, allowedPrefix) {
   const normalizedCandidate = normalizeRemotePath(candidate);
@@ -606,6 +643,195 @@ function isRemotePathWithin(candidate, allowedPrefix) {
   }
   return normalizedCandidate.startsWith(`${normalizedPrefix}/`);
 }
+function readEnv(env, name) {
+  const value = env[name];
+  if (value == null) {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (trimmed === "") {
+    return void 0;
+  }
+  return trimmed;
+}
+function readBooleanEnv(env, name) {
+  const value = readEnv(env, name);
+  if (value == null) {
+    return void 0;
+  }
+  const normalized = value.toLowerCase();
+  if (TRUTHY_ENV_VALUES.includes(normalized) == true) {
+    return true;
+  }
+  if (FALSY_ENV_VALUES.includes(normalized) == false) {
+    throw new Error(`${name} must be one of ${[...TRUTHY_ENV_VALUES, ...FALSY_ENV_VALUES].join(", ")} (got "${value}")`);
+  }
+  return false;
+}
+function readIntegerEnv(env, name) {
+  const value = readEnv(env, name);
+  if (value == null) {
+    return void 0;
+  }
+  const parsed = Number(value);
+  if (Number.isInteger(parsed) == false || parsed <= 0) {
+    throw new Error(`${name} must be a positive integer (got "${value}")`);
+  }
+  return parsed;
+}
+function readListEnv(env, name) {
+  const value = readEnv(env, name);
+  if (value == null) {
+    return void 0;
+  }
+  const items = value.split(",").map((item) => item.trim()).filter((item) => item !== "");
+  if (items.length === 0) {
+    return void 0;
+  }
+  return items;
+}
+function compileDenyPatterns(sources) {
+  return sources.map((source) => {
+    try {
+      return new RegExp(source, "i");
+    } catch (ex) {
+      const _logger = $logger.child({ context: "compileDenyPatterns" });
+      _logger.error(ex, "denyPatterns entry is not a valid regular expression");
+      let detail = String(ex);
+      if (ex instanceof Error) {
+        detail = ex.message;
+      }
+      throw new Error(`${SINGLE_HOST_ENV.DENY_PATTERNS} has an invalid entry /${source}/: ${detail}`);
+    }
+  });
+}
+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", {
+      env_vars: [SINGLE_HOST_ENV.HOST, SINGLE_HOST_ENV.USER]
+    });
+    return null;
+  }
+  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(env, SINGLE_HOST_ENV.NAME) ?? host;
+  const _logger = $logger.child({ context: "loadHostProfile", profile: name });
+  const allowCommands = readListEnv(env, SINGLE_HOST_ENV.ALLOW_COMMANDS) ?? [];
+  if (allowCommands.length > 0 && allowCommands.includes("pwd") == false) {
+    allowCommands.push("pwd");
+  }
+  const policy = {
+    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(env, SINGLE_HOST_ENV.DENY_PATTERNS) ?? []),
+    allowedPaths: readListEnv(env, SINGLE_HOST_ENV.ALLOWED_PATHS) ?? []
+  };
+  const profile = {
+    name,
+    host,
+    port: readIntegerEnv(env, SINGLE_HOST_ENV.PORT) ?? DEFAULT_SSH_PORT,
+    username,
+    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(env, SINGLE_HOST_ENV.KEY);
+  if (keyPath != null) {
+    const expandedKeyPath = expandHomePath(keyPath);
+    profile.privateKeyPath = expandedKeyPath;
+    if (fs6__default.default.existsSync(expandedKeyPath) == false) {
+      _logger.warn(`${SINGLE_HOST_ENV.KEY} does not exist; connections will fail`, {
+        private_key_path: expandedKeyPath
+      });
+    }
+  }
+  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 (fs6__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,
+    jump_host: profile.jump?.host,
+    via_proxy_command: profile.proxyCommand != null
+  });
+  return profile;
+}
+function toHostSummary(profile) {
+  let authMethod = "agent";
+  if (profile.privateKeyPath != null) {
+    authMethod = "privateKey";
+  } else if (profile.password != null) {
+    authMethod = "password";
+  }
+  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
 var WRAPPER_BINARY_SET = new Set(COMMAND_WRAPPER_BINARIES);
@@ -1043,20 +1269,20 @@ function inspectRemotePath(remotePath, policy, access) {
 function toRealPath(inputPath) {
   const _logger = $logger.child({ context: "toRealPath" });
   try {
-    return fs__default.default.realpathSync.native(inputPath);
+    return fs6__default.default.realpathSync.native(inputPath);
   } catch (ex) {
     _logger.debug("path does not resolve, falling back to its parent directory", {
       reason: ex instanceof Error ? ex.name : "unknown"
     });
   }
   try {
-    const parentRealPath = fs__default.default.realpathSync.native(path2__default.default.dirname(inputPath));
-    return path2__default.default.join(parentRealPath, path2__default.default.basename(inputPath));
+    const parentRealPath = fs6__default.default.realpathSync.native(path__default.default.dirname(inputPath));
+    return path__default.default.join(parentRealPath, path__default.default.basename(inputPath));
   } catch (ex) {
     _logger.debug("parent directory does not resolve either, comparing lexically", {
       reason: ex instanceof Error ? ex.name : "unknown"
     });
-    return path2__default.default.resolve(inputPath);
+    return path__default.default.resolve(inputPath);
   }
 }
 function toComparablePath(inputPath) {
@@ -1136,42 +1362,56 @@ 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;
   }
   try {
-    const contents = fs__default.default.readFileSync(keyPath);
+    const contents = fs6__default.default.readFileSync(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;
@@ -1184,21 +1424,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 = [];
@@ -1240,6 +1611,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;
@@ -1248,6 +1620,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;
@@ -1255,8 +1631,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) {
@@ -1279,43 +1658,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");
@@ -1917,7 +2319,7 @@ async function writeRemoteFile(connection, args) {
 }
 async function uploadFile(connection, localPath, remotePath) {
   requirePermittedPath(connection, remotePath, "write");
-  const localStats = fs__default.default.statSync(localPath);
+  const localStats = fs6__default.default.statSync(localPath);
   if (localStats.isFile() == false) {
     throw new Error(`local path is not a file: ${localPath}`);
   }
@@ -1954,7 +2356,7 @@ async function downloadFile(connection, remotePath, localPath) {
       });
     });
   });
-  const localStats = fs__default.default.statSync(localPath);
+  const localStats = fs6__default.default.statSync(localPath);
   const _logger = $logger.child({
     context: "downloadFile",
     profile: connection.profile.name,
@@ -1964,147 +2366,2123 @@ async function downloadFile(connection, remotePath, localPath) {
   _logger.info("file downloaded", { bytes: localStats.size });
   return localStats.size;
 }
-function readEnv(name) {
-  const value = process.env[name];
-  if (value == null) {
-    return void 0;
+
+// src/modules/manage/connection-check.ts
+function describeAuth(profile) {
+  if (profile.privateKeyPath != null) {
+    return `key ${profile.privateKeyPath}`;
   }
-  const trimmed = value.trim();
-  if (trimmed === "") {
-    return void 0;
+  if (profile.password != null) {
+    return "password";
   }
-  return trimmed;
+  return "ssh agent";
 }
-function readBooleanEnv(name) {
-  const value = readEnv(name);
-  if (value == null) {
-    return void 0;
-  }
-  const normalized = value.toLowerCase();
-  if (TRUTHY_ENV_VALUES.includes(normalized) == true) {
-    return true;
+async function runConnectionCheck(profile, output) {
+  const endpoint = `${profile.username}@${profile.host}:${profile.port}`;
+  const auth = describeAuth(profile);
+  output.write(`Checking ${profile.name}  \u2192  ${endpoint}
+`);
+  if (profile.proxyCommand != null) {
+    output.write(`  via proxy command: ${profile.proxyCommand}
+`);
   }
-  if (FALSY_ENV_VALUES.includes(normalized) == false) {
-    throw new Error(`${name} must be one of ${[...TRUTHY_ENV_VALUES, ...FALSY_ENV_VALUES].join(", ")} (got "${value}")`);
+  if (profile.jump != null) {
+    output.write(`  via jump host: ${profile.jump.username}@${profile.jump.host}:${profile.jump.port}
+`);
   }
-  return false;
+  output.write("\n");
+  const connection = new SshConnection(profile);
+  const startedAt = Date.now();
+  let connected = false;
+  let detail = "";
+  try {
+    await connection.connect();
+    connected = true;
+  } catch (ex) {
+    detail = String(ex);
+    if (ex instanceof Error) {
+      detail = ex.message;
+    }
+  } finally {
+    connection.disconnect();
+  }
+  const durationMs = Date.now() - startedAt;
+  if (connected == true) {
+    output.write(`  OK      ${endpoint}  (${auth}, ${durationMs}ms)
+`);
+  } else {
+    output.write(`  FAILED  ${endpoint}  (${auth})
+`);
+    output.write(`          ${detail}
+`);
+  }
+  if (connection.hostKeyFingerprint != null) {
+    let pinNote = `not pinned \u2014 set ${SINGLE_HOST_ENV.HOST_KEY} to it to detect a changed key`;
+    if (profile.hostKeyFingerprint != null) {
+      pinNote = "pinned";
+    }
+    output.write(`          host key ${connection.hostKeyFingerprint}  (${pinNote})
+`);
+  }
+  if (connection.jumpHostKeyFingerprint != null) {
+    let pinNote = `not pinned \u2014 set ${SINGLE_HOST_ENV.JUMP_HOST_KEY} to it to detect a changed key`;
+    if (profile.jump?.hostKeyFingerprint != null) {
+      pinNote = "pinned";
+    }
+    output.write(`          jump host key ${connection.jumpHostKeyFingerprint}  (${pinNote})
+`);
+  }
+  return {
+    connected,
+    hostKeyFingerprint: connection.hostKeyFingerprint,
+    jumpHostKeyFingerprint: connection.jumpHostKeyFingerprint
+  };
+}
+
+// src/modules/manage/entry.ts
+var MANAGED_ENV_NAMES = [
+  SINGLE_HOST_ENV.HOST,
+  SINGLE_HOST_ENV.PORT,
+  SINGLE_HOST_ENV.USER,
+  SINGLE_HOST_ENV.KEY,
+  SINGLE_HOST_ENV.PASSPHRASE,
+  SINGLE_HOST_ENV.PASSWORD,
+  SINGLE_HOST_ENV.DESCRIPTION,
+  SINGLE_HOST_ENV.JUMP_HOST,
+  SINGLE_HOST_ENV.JUMP_PORT,
+  SINGLE_HOST_ENV.JUMP_USER,
+  SINGLE_HOST_ENV.PROXY_COMMAND,
+  SINGLE_HOST_ENV.READONLY,
+  SINGLE_HOST_ENV.ALLOWED_PATHS,
+  SINGLE_HOST_ENV.HOST_KEY,
+  SINGLE_HOST_ENV.JUMP_HOST_KEY
+];
+var JUMP_ENV_PREFIX = "SSH_JUMP_";
+var SERVER_NAME_PATTERN = /^[A-Za-z0-9_-]{1,48}$/;
+function isOurEntry(entry) {
+  if (entry.args.includes(PACKAGE_NAME) == true) {
+    return true;
+  }
+  const commandBase = entry.command.replace(/\\/g, "/").split("/").pop() ?? "";
+  return commandBase === SERVER_NAME || commandBase.startsWith(`${SERVER_NAME}.`) == true;
+}
+function launchCommand() {
+  if (process.platform === "win32") {
+    return { command: "cmd", args: ["/c", "npx", "-y", PACKAGE_NAME] };
+  }
+  return { command: "npx", args: ["-y", PACKAGE_NAME] };
+}
+function answersToEntry(answers) {
+  const env = {};
+  env[SINGLE_HOST_ENV.HOST] = answers.host;
+  if (answers.port !== DEFAULT_SSH_PORT) {
+    env[SINGLE_HOST_ENV.PORT] = String(answers.port);
+  }
+  env[SINGLE_HOST_ENV.USER] = answers.username;
+  if (answers.auth === "key" && answers.keyPath != null) {
+    env[SINGLE_HOST_ENV.KEY] = answers.keyPath;
+    if (answers.passphrase != null && answers.passphrase !== "") {
+      env[SINGLE_HOST_ENV.PASSPHRASE] = answers.passphrase;
+    }
+  }
+  if (answers.auth === "password" && answers.password != null) {
+    env[SINGLE_HOST_ENV.PASSWORD] = answers.password;
+  }
+  if (answers.hostKeyFingerprint != null) {
+    env[SINGLE_HOST_ENV.HOST_KEY] = answers.hostKeyFingerprint;
+  }
+  if (answers.description != null && answers.description !== "") {
+    env[SINGLE_HOST_ENV.DESCRIPTION] = answers.description;
+  }
+  if (answers.jumpHost != null) {
+    env[SINGLE_HOST_ENV.JUMP_HOST] = answers.jumpHost;
+    if (answers.jumpPort != null && answers.jumpPort !== DEFAULT_SSH_PORT) {
+      env[SINGLE_HOST_ENV.JUMP_PORT] = String(answers.jumpPort);
+    }
+    if (answers.jumpUser != null && answers.jumpUser !== answers.username) {
+      env[SINGLE_HOST_ENV.JUMP_USER] = answers.jumpUser;
+    }
+    if (answers.jumpHostKeyFingerprint != null) {
+      env[SINGLE_HOST_ENV.JUMP_HOST_KEY] = answers.jumpHostKeyFingerprint;
+    }
+  }
+  if (answers.proxyCommand != null && answers.proxyCommand !== "") {
+    env[SINGLE_HOST_ENV.PROXY_COMMAND] = answers.proxyCommand;
+  }
+  if (answers.readonly == true) {
+    env[SINGLE_HOST_ENV.READONLY] = "true";
+  }
+  if (answers.allowedPaths.length > 0) {
+    env[SINGLE_HOST_ENV.ALLOWED_PATHS] = answers.allowedPaths.join(",");
+  }
+  for (const [name, value] of Object.entries(answers.extraEnv)) {
+    if (MANAGED_ENV_NAMES.includes(name) == true) {
+      continue;
+    }
+    if (answers.jumpHost == null && name.startsWith(JUMP_ENV_PREFIX) == true) {
+      continue;
+    }
+    env[name] = value;
+  }
+  const launch = launchCommand();
+  return {
+    command: launch.command,
+    args: launch.args,
+    env
+  };
+}
+function readPort(value) {
+  if (value == null) {
+    return DEFAULT_SSH_PORT;
+  }
+  const parsed = Number(value);
+  if (Number.isInteger(parsed) == false || parsed <= 0) {
+    return DEFAULT_SSH_PORT;
+  }
+  return parsed;
+}
+function isTruthy(value) {
+  if (value == null) {
+    return false;
+  }
+  return TRUTHY_ENV_VALUES.includes(value.trim().toLowerCase());
+}
+function entryToAnswers(name, entry) {
+  const env = entry.env;
+  const host = env[SINGLE_HOST_ENV.HOST] ?? "";
+  const username = env[SINGLE_HOST_ENV.USER] ?? "";
+  let auth = "agent";
+  if (env[SINGLE_HOST_ENV.KEY] != null) {
+    auth = "key";
+  } else if (env[SINGLE_HOST_ENV.PASSWORD] != null) {
+    auth = "password";
+  }
+  let allowedPaths = [];
+  const allowedPathsValue = env[SINGLE_HOST_ENV.ALLOWED_PATHS];
+  if (allowedPathsValue != null) {
+    allowedPaths = allowedPathsValue.split(",").map((item) => item.trim()).filter((item) => item !== "");
+  }
+  const extraEnv = {};
+  for (const [variable, value] of Object.entries(env)) {
+    if (MANAGED_ENV_NAMES.includes(variable) == false) {
+      extraEnv[variable] = value;
+    }
+  }
+  const answers = {
+    name,
+    host,
+    port: readPort(env[SINGLE_HOST_ENV.PORT]),
+    username,
+    auth,
+    keyPath: env[SINGLE_HOST_ENV.KEY],
+    passphrase: env[SINGLE_HOST_ENV.PASSPHRASE],
+    password: env[SINGLE_HOST_ENV.PASSWORD],
+    description: env[SINGLE_HOST_ENV.DESCRIPTION],
+    proxyCommand: env[SINGLE_HOST_ENV.PROXY_COMMAND],
+    readonly: isTruthy(env[SINGLE_HOST_ENV.READONLY]),
+    allowedPaths,
+    hostKeyFingerprint: env[SINGLE_HOST_ENV.HOST_KEY],
+    extraEnv
+  };
+  const jumpHost = env[SINGLE_HOST_ENV.JUMP_HOST];
+  if (jumpHost != null) {
+    answers.jumpHost = jumpHost;
+    answers.jumpPort = readPort(env[SINGLE_HOST_ENV.JUMP_PORT]);
+    answers.jumpUser = env[SINGLE_HOST_ENV.JUMP_USER] ?? username;
+    answers.jumpHostKeyFingerprint = env[SINGLE_HOST_ENV.JUMP_HOST_KEY];
+  }
+  return answers;
+}
+function summarizeEntry(entry) {
+  const env = entry.env;
+  const host = env[SINGLE_HOST_ENV.HOST] ?? "?";
+  const port = env[SINGLE_HOST_ENV.PORT] ?? String(DEFAULT_SSH_PORT);
+  const username = env[SINGLE_HOST_ENV.USER] ?? "?";
+  let auth = "agent";
+  if (env[SINGLE_HOST_ENV.KEY] != null) {
+    auth = "key";
+  } else if (env[SINGLE_HOST_ENV.PASSWORD] != null) {
+    auth = "password";
+  }
+  const notes = [];
+  if (env[SINGLE_HOST_ENV.JUMP_HOST] != null) {
+    notes.push(`jump ${env[SINGLE_HOST_ENV.JUMP_HOST]}`);
+  }
+  if (env[SINGLE_HOST_ENV.PROXY_COMMAND] != null) {
+    notes.push("proxy");
+  }
+  if (isTruthy(env[SINGLE_HOST_ENV.READONLY]) == true) {
+    notes.push("readonly");
+  }
+  if (env[SINGLE_HOST_ENV.ALLOWED_PATHS] != null) {
+    notes.push(`paths ${env[SINGLE_HOST_ENV.ALLOWED_PATHS]}`);
+  }
+  if (env[SINGLE_HOST_ENV.HOST_KEY] != null) {
+    notes.push("pinned");
+  }
+  return {
+    endpoint: `${username}@${host}:${port}`,
+    auth,
+    notes: notes.join(", ")
+  };
+}
+
+// src/modules/manage/prompter.ts
+var PromptClosedError = class extends Error {
+  constructor() {
+    super("input closed before the prompt was answered");
+    this.name = "PromptClosedError";
+  }
+};
+var ESC = "\x1B";
+var KEY_UP = [`${ESC}[A`, `${ESC}OA`, "k"];
+var KEY_DOWN = [`${ESC}[B`, `${ESC}OB`, "j"];
+var KEY_HOME = [`${ESC}[H`, `${ESC}OH`, `${ESC}[1~`];
+var KEY_END = [`${ESC}[F`, `${ESC}OF`, `${ESC}[4~`];
+var KEY_ENTER = ["\r", "\n"];
+var KEY_BACKSPACE = ["\x7F", "\b"];
+var KEY_CTRL_C = "";
+var KEY_CTRL_D = "";
+function splitKeys(chunk) {
+  const keys = [];
+  let index = 0;
+  while (index < chunk.length) {
+    const isSequence = chunk[index] === ESC && (chunk[index + 1] === "[" || chunk[index + 1] === "O");
+    if (isSequence == true) {
+      let end = index + 2;
+      while (end < chunk.length && /[0-9;]/.test(chunk[end]) == true) {
+        end += 1;
+      }
+      keys.push(chunk.slice(index, end + 1));
+      index = end + 1;
+      continue;
+    }
+    const codePoint = chunk.codePointAt(index) ?? 0;
+    const character = String.fromCodePoint(codePoint);
+    keys.push(character);
+    index += character.length;
+  }
+  return keys;
+}
+function charWidth(codePoint) {
+  if (codePoint < 4352) {
+    return 1;
+  }
+  const isWide = codePoint <= 4447 || codePoint === 9001 || codePoint === 9002 || codePoint >= 11904 && codePoint <= 42191 && codePoint !== 12351 || codePoint >= 44032 && codePoint <= 55203 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65072 && codePoint <= 65103 || codePoint >= 65280 && codePoint <= 65376 || codePoint >= 65504 && codePoint <= 65510 || codePoint >= 127744 && codePoint <= 128591 || codePoint >= 129280 && codePoint <= 129535 || codePoint >= 131072 && codePoint <= 262141;
+  if (isWide == true) {
+    return 2;
+  }
+  return 1;
+}
+function displayWidth(text) {
+  let width = 0;
+  for (const character of text) {
+    width += charWidth(character.codePointAt(0) ?? 0);
+  }
+  return width;
+}
+function padToWidth(text, width) {
+  const missing = width - displayWidth(text);
+  if (missing <= 0) {
+    return text;
+  }
+  return `${text}${" ".repeat(missing)}`;
+}
+function groupLabelWidths(items) {
+  const widths = items.map(() => 0);
+  let groupStart = 0;
+  for (let index = 0; index <= items.length; index += 1) {
+    const atBoundary = index === items.length || "value" in items[index] == false;
+    if (atBoundary == false) {
+      continue;
+    }
+    let groupWidth = 0;
+    for (let member = groupStart; member < index; member += 1) {
+      const item = items[member];
+      groupWidth = Math.max(groupWidth, displayWidth(item.label));
+    }
+    for (let member = groupStart; member < index; member += 1) {
+      widths[member] = groupWidth;
+    }
+    groupStart = index + 1;
+  }
+  return widths;
+}
+function supportsUnicode() {
+  if (process.platform !== "win32") {
+    return true;
+  }
+  return process.env.WT_SESSION != null || process.env.TERM_PROGRAM === "vscode" || process.env.TERMINAL_EMULATOR === "JetBrains-JediTerm" || process.env.ConEmuTask != null;
+}
+function createStyle(enabled) {
+  const paint = (open, close) => {
+    return (text) => {
+      if (enabled == false || text === "") {
+        return text;
+      }
+      return `${ESC}[${open}m${text}${ESC}[${close}m`;
+    };
+  };
+  return {
+    accent: paint(36, 39),
+    success: paint(32, 39),
+    dim: paint(2, 22),
+    bold: paint(1, 22)
+  };
+}
+var Prompter = class {
+  constructor(input, output) {
+    this.input = input;
+    this.output = output;
+    this.lineBuffer = "";
+    this.pendingLines = [];
+    this.lineWaiter = null;
+    this.inputEnded = false;
+    /** Set while a key-driven prompt (select, secret) owns the input. */
+    this.keyHandler = null;
+    const ttyInput = input;
+    const ttyOutput = output;
+    this.interactive = ttyInput.isTTY == true && ttyInput.setRawMode != null && ttyOutput.isTTY == true;
+    this.style = createStyle(this.interactive == true && process.env.NO_COLOR == null);
+    if (supportsUnicode() == true) {
+      this.symbols = { question: "?", pointer: "\u276F", tick: "\u2714", rule: "\u2500" };
+    } else {
+      this.symbols = { question: "?", pointer: ">", tick: "\u221A", rule: "-" };
+    }
+    input.setEncoding("utf8");
+    input.on("data", (chunk) => {
+      this.onData(chunk);
+    });
+    input.on("end", () => {
+      this.inputEnded = true;
+      if (this.lineWaiter != null) {
+        const waiter = this.lineWaiter;
+        this.lineWaiter = null;
+        waiter(null);
+      }
+      if (this.keyHandler != null) {
+        this.keyHandler(KEY_CTRL_D);
+      }
+    });
+  }
+  /** Stops reading so the process can exit once the command is done. */
+  close() {
+    if (this.interactive == true) {
+      this.input.setRawMode?.(false);
+      this.output.write(`${ESC}[?25h`);
+    }
+    this.input.pause();
+  }
+  write(text) {
+    this.output.write(text);
+  }
+  /** Styling for callers that print around the prompts; plain text off a TTY. */
+  get paint() {
+    return this.style;
+  }
+  /**
+   * Free-text prompt. Enter accepts `defaultValue` when one is shown.
+   *
+   * @throws {PromptClosedError} If the input closes before a line arrives.
+   */
+  async ask(question, defaultValue) {
+    let suffix = "";
+    if (defaultValue != null && defaultValue !== "") {
+      suffix = ` ${this.style.dim(`(${defaultValue})`)}`;
+    }
+    const prompt = `${this.style.accent(this.symbols.question)} ${this.style.bold(question)}${suffix} `;
+    this.output.write(prompt);
+    const line = await this.readLine();
+    if (line == null) {
+      throw new PromptClosedError();
+    }
+    let answer = line.trim();
+    if (answer === "" && defaultValue != null) {
+      answer = defaultValue;
+    }
+    this.collapseAnswered(prompt, line, question, answer);
+    return answer;
+  }
+  /** Like `ask`, re-asking until something non-empty is entered. */
+  async askRequired(question, defaultValue) {
+    for (; ; ) {
+      const answer = await this.ask(question, defaultValue);
+      if (answer !== "") {
+        return answer;
+      }
+      this.output.write(`  ${this.style.dim("A value is required.")}
+`);
+    }
+  }
+  async askYesNo(question, defaultValue) {
+    let hint = "y/N";
+    if (defaultValue == true) {
+      hint = "Y/n";
+    }
+    for (; ; ) {
+      const prompt = `${this.style.accent(this.symbols.question)} ${this.style.bold(question)} ${this.style.dim(`(${hint})`)} `;
+      this.output.write(prompt);
+      const line = await this.readLine();
+      if (line == null) {
+        throw new PromptClosedError();
+      }
+      const normalized = line.trim().toLowerCase();
+      let answer = null;
+      if (normalized === "") {
+        answer = defaultValue;
+      } else if (normalized === "y" || normalized === "yes") {
+        answer = true;
+      } else if (normalized === "n" || normalized === "no") {
+        answer = false;
+      }
+      if (answer != null) {
+        let shown = "no";
+        if (answer == true) {
+          shown = "yes";
+        }
+        this.collapseAnswered(prompt, line, question, shown);
+        return answer;
+      }
+      this.output.write(`  ${this.style.dim("Answer y or n.")}
+`);
+    }
+  }
+  /**
+   * Picks one of `items`. On a TTY: ↑/↓ (or k/j) move, 1–9 jump, Enter picks, Esc returns
+   * `cancelValue`. Off a TTY: a numbered list, answered by number, key or label.
+   *
+   * @throws {PromptClosedError} On Ctrl+C or when the input closes.
+   */
+  async select(question, items, options) {
+    const choices = items.filter((item) => "value" in item);
+    if (choices.length === 0) {
+      throw new Error("select needs at least one choice");
+    }
+    let startIndex = items.findIndex((item) => "value" in item && item.value === options?.defaultValue);
+    if (startIndex < 0) {
+      startIndex = items.findIndex((item) => "value" in item);
+    }
+    if (this.interactive == true) {
+      const picked2 = await this.selectWithKeys(question, items, startIndex, options?.cancelValue);
+      return picked2;
+    }
+    const picked = await this.selectWithLines(question, items, startIndex);
+    return picked;
+  }
+  /**
+   * Reads a value without echoing it on a TTY. Empty means "none", or "keep" when the
+   * caller says a value already exists.
+   *
+   * @throws {PromptClosedError} On Ctrl+C or when the input closes.
+   */
+  async askSecret(question) {
+    if (this.interactive == false) {
+      const answer = await this.ask(question);
+      return answer;
+    }
+    const prompt = `${this.style.accent(this.symbols.question)} ${this.style.bold(question)} `;
+    this.output.write(prompt);
+    const ttyInput = this.input;
+    return new Promise((resolve, reject) => {
+      let buffer = "";
+      const finish = () => {
+        this.keyHandler = null;
+        ttyInput.setRawMode?.(false);
+        this.output.write(`\r${ESC}[2K`);
+      };
+      this.keyHandler = (key) => {
+        if (key === KEY_CTRL_C || key === KEY_CTRL_D) {
+          finish();
+          reject(new PromptClosedError());
+          return;
+        }
+        if (KEY_ENTER.includes(key) == true) {
+          finish();
+          let shown = this.style.dim("(empty)");
+          if (buffer !== "") {
+            shown = "\u2022".repeat(Math.min(buffer.length, 8));
+          }
+          this.writeAnswered(question, shown);
+          resolve(buffer);
+          return;
+        }
+        if (KEY_BACKSPACE.includes(key) == true) {
+          buffer = Array.from(buffer).slice(0, -1).join("");
+          return;
+        }
+        if (key.startsWith(ESC) == true) {
+          return;
+        }
+        buffer += key;
+      };
+      ttyInput.setRawMode?.(true);
+    });
+  }
+  // ── line mode ──────────────────────────────────────────────────────────
+  readLine() {
+    const queued = this.pendingLines.shift();
+    if (queued != null) {
+      return Promise.resolve(queued);
+    }
+    if (this.inputEnded == true) {
+      return Promise.resolve(null);
+    }
+    return new Promise((resolve) => {
+      this.lineWaiter = resolve;
+    });
+  }
+  onData(chunk) {
+    if (this.keyHandler != null) {
+      for (const key of splitKeys(chunk)) {
+        if (this.keyHandler == null) {
+          break;
+        }
+        this.keyHandler(key);
+      }
+      return;
+    }
+    this.lineBuffer += chunk;
+    let newlineIndex = this.lineBuffer.indexOf("\n");
+    while (newlineIndex >= 0) {
+      const line = this.lineBuffer.slice(0, newlineIndex).replace(/\r$/, "");
+      this.lineBuffer = this.lineBuffer.slice(newlineIndex + 1);
+      if (this.lineWaiter != null) {
+        const waiter = this.lineWaiter;
+        this.lineWaiter = null;
+        waiter(line);
+      } else {
+        this.pendingLines.push(line);
+      }
+      newlineIndex = this.lineBuffer.indexOf("\n");
+    }
+  }
+  async selectWithLines(question, items, startIndex) {
+    const choices = items.filter((item) => "value" in item);
+    const labelWidths = groupLabelWidths(items);
+    this.output.write(`${this.symbols.question} ${question}
+`);
+    let number = 0;
+    for (let index = 0; index < items.length; index += 1) {
+      const item = items[index];
+      if ("value" in item == false) {
+        this.output.write("\n");
+        continue;
+      }
+      number += 1;
+      let line = `  ${String(number).padStart(2)}) ${padToWidth(item.label, labelWidths[index])}`;
+      if (item.hint != null && item.hint !== "") {
+        line += `  ${item.hint}`;
+      }
+      this.output.write(`${line.trimEnd()}
+`);
+    }
+    const defaultChoice = items[startIndex];
+    const defaultNumber = choices.indexOf(defaultChoice) + 1;
+    for (; ; ) {
+      this.output.write(`Choice (${defaultNumber}): `);
+      const line = await this.readLine();
+      if (line == null) {
+        throw new PromptClosedError();
+      }
+      const answer = line.trim();
+      if (answer === "") {
+        return defaultChoice.value;
+      }
+      const index = Number(answer);
+      if (Number.isInteger(index) == true && index >= 1 && index <= choices.length) {
+        return choices[index - 1].value;
+      }
+      const lowered = answer.toLowerCase();
+      const matched = choices.find((choice) => {
+        const key = choice.key ?? choice.value;
+        return key.toLowerCase() === lowered || choice.label.toLowerCase() === lowered;
+      });
+      if (matched != null) {
+        return matched.value;
+      }
+      this.output.write(`  Pick a number from 1 to ${choices.length}.
+`);
+    }
+  }
+  // ── TTY rendering ──────────────────────────────────────────────────────
+  columns() {
+    const columns = this.output.columns;
+    if (columns == null || columns < 20) {
+      return 80;
+    }
+    return columns;
+  }
+  /** Joins styled parts, cutting the text (not the styles) once `width` columns are used. */
+  fitLine(parts, width) {
+    let used = 0;
+    let line = "";
+    for (const part of parts) {
+      let text = "";
+      for (const character of part.text) {
+        const characterWidth = charWidth(character.codePointAt(0) ?? 0);
+        if (used + characterWidth > width) {
+          break;
+        }
+        used += characterWidth;
+        text += character;
+      }
+      if (part.paint != null) {
+        line += part.paint(text);
+      } else {
+        line += text;
+      }
+      if (used >= width) {
+        break;
+      }
+    }
+    return line;
+  }
+  /** The one-line record an answered prompt leaves behind on a TTY. */
+  writeAnswered(question, answer) {
+    this.output.write(`${this.style.success(this.symbols.tick)} ${question} ${this.style.dim("\xB7")} ${this.style.accent(answer)}
+`);
+  }
+  /**
+   * Replaces a cooked-mode prompt and its echoed answer with the one-line record. The
+   * rows are worked out from the widths, since a long answer wraps.
+   */
+  collapseAnswered(prompt, typed, question, answer) {
+    if (this.interactive == false) {
+      return;
+    }
+    const plainPrompt = prompt.replace(/\u001b\[[0-9;]*m/g, "");
+    const used = displayWidth(plainPrompt) + displayWidth(typed);
+    const rows = Math.max(1, Math.ceil(used / this.columns()));
+    this.output.write(`${ESC}[${rows}A\r${ESC}[J`);
+    let shown = answer;
+    if (shown === "") {
+      shown = this.style.dim("(empty)");
+    }
+    this.writeAnswered(question, shown);
+  }
+  selectWithKeys(question, items, startIndex, cancelValue) {
+    const ttyInput = this.input;
+    const selectableIndexes = items.flatMap((item, index) => {
+      if ("value" in item) {
+        return [index];
+      }
+      return [];
+    });
+    const labelWidths = groupLabelWidths(items);
+    const ruleWidth = Math.min(Math.max(...labelWidths), 24);
+    let active = startIndex;
+    let renderedLines = 0;
+    const draw = (lines) => {
+      let text = "";
+      if (renderedLines > 1) {
+        text += `${ESC}[${renderedLines - 1}A`;
+      }
+      text += `\r${ESC}[J${lines.join("\n")}`;
+      this.output.write(text);
+      renderedLines = lines.length;
+    };
+    const buildLines = () => {
+      const width = this.columns() - 1;
+      const lines = [
+        this.fitLine([
+          { text: this.symbols.question, paint: this.style.accent },
+          { text: " " },
+          { text: question, paint: this.style.bold }
+        ], width)
+      ];
+      for (let index = 0; index < items.length; index += 1) {
+        const item = items[index];
+        if ("value" in item == false) {
+          lines.push(this.fitLine([{ text: `  ${this.symbols.rule.repeat(ruleWidth)}`, paint: this.style.dim }], width));
+          continue;
+        }
+        const isActive = index === active;
+        const parts = [];
+        if (isActive == true) {
+          parts.push({ text: `${this.symbols.pointer} `, paint: this.style.accent });
+          parts.push({ text: padToWidth(item.label, labelWidths[index]), paint: this.style.accent });
+        } else {
+          parts.push({ text: "  " });
+          parts.push({ text: padToWidth(item.label, labelWidths[index]) });
+        }
+        if (item.hint != null && item.hint !== "") {
+          parts.push({ text: `  ${item.hint}`, paint: this.style.dim });
+        }
+        lines.push(this.fitLine(parts, width));
+      }
+      let footer = "\u2191\u2193 move \xB7 enter select";
+      if (cancelValue != null) {
+        footer += " \xB7 esc back";
+      }
+      lines.push(this.fitLine([{ text: footer, paint: this.style.dim }], width));
+      return lines;
+    };
+    const move = (step) => {
+      const position = selectableIndexes.indexOf(active);
+      const next = (position + step + selectableIndexes.length) % selectableIndexes.length;
+      active = selectableIndexes[next];
+    };
+    return new Promise((resolve, reject) => {
+      const finish = () => {
+        this.keyHandler = null;
+        ttyInput.setRawMode?.(false);
+        draw([]);
+        this.output.write(`${ESC}[?25h`);
+      };
+      this.keyHandler = (key) => {
+        if (key === KEY_CTRL_C || key === KEY_CTRL_D) {
+          finish();
+          reject(new PromptClosedError());
+          return;
+        }
+        if (KEY_ENTER.includes(key) == true) {
+          const picked = items[active];
+          finish();
+          this.writeAnswered(question, picked.label);
+          resolve(picked.value);
+          return;
+        }
+        if (key === ESC) {
+          if (cancelValue == null) {
+            return;
+          }
+          finish();
+          resolve(cancelValue);
+          return;
+        }
+        if (KEY_UP.includes(key) == true) {
+          move(-1);
+        } else if (KEY_DOWN.includes(key) == true) {
+          move(1);
+        } else if (KEY_HOME.includes(key) == true) {
+          active = selectableIndexes[0];
+        } else if (KEY_END.includes(key) == true) {
+          active = selectableIndexes[selectableIndexes.length - 1];
+        } else if (/^[1-9]$/.test(key) == true && Number(key) <= selectableIndexes.length) {
+          active = selectableIndexes[Number(key) - 1];
+        } else {
+          return;
+        }
+        draw(buildLines());
+      };
+      ttyInput.setRawMode?.(true);
+      this.output.write(`${ESC}[?25l`);
+      draw(buildLines());
+    });
+  }
+};
+var PREFERRED_KEY_NAMES = ["id_ed25519", "id_ecdsa", "id_rsa"];
+var NON_KEY_FILE_NAMES = ["config", "known_hosts", "known_hosts.old", "authorized_keys", "environment"];
+var MAX_KEY_FILE_BYTES = 64 * 1024;
+var CLEAR_ANSWER = "-";
+var OTHER_KEY_PATH = "\0other";
+function findPrivateKeys() {
+  const sshDirectory = path__default.default.join(os5__default.default.homedir(), ".ssh");
+  let names = [];
+  try {
+    names = fs6__default.default.readdirSync(sshDirectory);
+  } catch {
+    return [];
+  }
+  const keys = [];
+  for (const name of names) {
+    if (name.endsWith(".pub") == true || NON_KEY_FILE_NAMES.includes(name) == true) {
+      continue;
+    }
+    const fullPath = path__default.default.join(sshDirectory, name);
+    let head = "";
+    try {
+      const stat = fs6__default.default.statSync(fullPath);
+      if (stat.isFile() == false || stat.size > MAX_KEY_FILE_BYTES) {
+        continue;
+      }
+      const descriptor = fs6__default.default.openSync(fullPath, "r");
+      const buffer = Buffer.alloc(64);
+      const bytesRead = fs6__default.default.readSync(descriptor, buffer, 0, buffer.length, 0);
+      fs6__default.default.closeSync(descriptor);
+      head = buffer.subarray(0, bytesRead).toString("utf8");
+    } catch {
+      continue;
+    }
+    const isPemKey = head.startsWith("-----BEGIN") == true && head.includes("PRIVATE KEY") == true;
+    const isPuttyKey = head.startsWith("PuTTY-User-Key-File") == true;
+    if (isPemKey == false && isPuttyKey == false) {
+      continue;
+    }
+    let hint = "";
+    try {
+      const publicKey = fs6__default.default.readFileSync(`${fullPath}.pub`, "utf8").trim().split(/\s+/);
+      hint = publicKey[0].replace(/^ssh-/, "");
+      if (publicKey.length > 2) {
+        hint += ` \xB7 ${publicKey.slice(2).join(" ")}`;
+      }
+    } catch {
+    }
+    keys.push({ path: `~/.ssh/${name}`, hint });
+  }
+  const rank = (key) => {
+    const index = PREFERRED_KEY_NAMES.indexOf(path__default.default.basename(key.path));
+    if (index < 0) {
+      return PREFERRED_KEY_NAMES.length;
+    }
+    return index;
+  };
+  return keys.sort((left, right) => rank(left) - rank(right) || left.path.localeCompare(right.path));
+}
+async function askPort(prompter, question, current) {
+  for (; ; ) {
+    const answer = await prompter.ask(question, String(current));
+    const parsed = Number(answer);
+    if (Number.isInteger(parsed) == true && parsed > 0 && parsed <= 65535) {
+      return parsed;
+    }
+    prompter.write("  Enter a port number between 1 and 65535.\n");
+  }
+}
+async function askOptional(prompter, question, current) {
+  const answer = await prompter.ask(question, current);
+  if (answer === "" || answer === CLEAR_ANSWER) {
+    return void 0;
+  }
+  return answer;
+}
+async function askOptionalSecret(prompter, question, current) {
+  let suffix = "(empty for none)";
+  if (current != null) {
+    suffix = `(enter keeps current, ${CLEAR_ANSWER} clears)`;
+  }
+  const answer = await prompter.askSecret(`${question} ${prompter.paint.dim(suffix)}`);
+  if (answer === CLEAR_ANSWER) {
+    return void 0;
+  }
+  if (answer === "") {
+    return current;
+  }
+  return answer;
+}
+async function askKeyPath(prompter, current) {
+  const found = findPrivateKeys();
+  let picked = OTHER_KEY_PATH;
+  if (found.length > 0 || current != null) {
+    const items = [];
+    if (current != null && found.some((key) => key.path === current) == false) {
+      items.push({ value: current, label: current, hint: "current" });
+    }
+    for (const key of found) {
+      items.push({ value: key.path, label: key.path, hint: key.hint });
+    }
+    items.push({ separator: true });
+    items.push({ value: OTHER_KEY_PATH, key: "other", label: "Another path\u2026" });
+    picked = await prompter.select("Private key", items, { defaultValue: current ?? found[0]?.path });
+  }
+  if (picked !== OTHER_KEY_PATH) {
+    return picked;
+  }
+  for (; ; ) {
+    const typed = await prompter.askRequired("Private key path");
+    if (fs6__default.default.existsSync(expandHomePath(typed)) == true) {
+      return typed;
+    }
+    prompter.write(`  ${expandHomePath(typed)} does not exist.
+`);
+    const useAnyway = await prompter.askYesNo("Use this path anyway?", false);
+    if (useAnyway == true) {
+      return typed;
+    }
+  }
+}
+async function askHostQuestions(prompter, existing) {
+  if (existing != null) {
+    prompter.write(prompter.paint.dim(`  Enter keeps the value in brackets; ${CLEAR_ANSWER} clears an optional one.
+
+`));
+  }
+  const host = await prompter.askRequired("Host (hostname or IP)", existing?.host);
+  const port = await askPort(prompter, "Port", existing?.port ?? DEFAULT_SSH_PORT);
+  const username = await prompter.askRequired("Login user", existing?.username);
+  let name = "";
+  const defaultName = existing?.name ?? `ssh-${host}`.replace(/[^A-Za-z0-9_-]+/g, "-").slice(0, 48);
+  for (; ; ) {
+    name = await prompter.askRequired("Server name the agent sees", defaultName);
+    if (SERVER_NAME_PATTERN.test(name) == true) {
+      break;
+    }
+    prompter.write("  Use letters, digits, '-' and '_' only (max 48) \u2014 the name becomes part of every tool name.\n");
+  }
+  const auth = await prompter.select(
+    "Authentication",
+    [
+      { value: "key", label: "Private key file", hint: "only the path is stored \u2014 recommended" },
+      { value: "password", label: "Password", hint: "stored in the config file as plain text" },
+      { value: "agent", label: "SSH agent", hint: "keys already loaded in ssh-agent" }
+    ],
+    { defaultValue: existing?.auth ?? "key" }
+  );
+  let keyPath;
+  let passphrase;
+  let password;
+  if (auth === "key") {
+    keyPath = await askKeyPath(prompter, existing?.keyPath);
+    passphrase = await askOptionalSecret(prompter, "Key passphrase", existing?.passphrase);
+  }
+  if (auth === "password") {
+    password = await askOptionalSecret(prompter, "Password", existing?.password);
+    if (password == null) {
+      prompter.write("  No password given \u2014 falling back to the ssh agent.\n");
+    }
+  }
+  let currentRoute = "direct";
+  if (existing?.jumpHost != null && existing.proxyCommand != null) {
+    currentRoute = "jump-proxy";
+  } else if (existing?.jumpHost != null) {
+    currentRoute = "jump";
+  } else if (existing?.proxyCommand != null) {
+    currentRoute = "proxy";
+  }
+  const route = await prompter.select(
+    "How is it reached?",
+    [
+      { value: "direct", label: "Directly" },
+      { value: "jump", label: "Through a jump host", hint: "ssh -J" },
+      { value: "proxy", label: "Through a proxy command", hint: "e.g. cloudflared access ssh" },
+      { value: "jump-proxy", label: "Proxy command, then a jump host", hint: "cloudflared to the bastion, then on to the host" }
+    ],
+    { defaultValue: currentRoute }
+  );
+  let jumpHost;
+  let jumpPort;
+  let jumpUser;
+  let proxyCommand;
+  if (route === "jump" || route === "jump-proxy") {
+    jumpHost = await prompter.askRequired("Jump host", existing?.jumpHost);
+    jumpPort = await askPort(prompter, "Jump host port", existing?.jumpPort ?? DEFAULT_SSH_PORT);
+    jumpUser = await prompter.askRequired("Jump host user", existing?.jumpUser ?? username);
+  }
+  if (route === "proxy" || route === "jump-proxy") {
+    prompter.write(prompter.paint.dim("  %h / %p / %r expand to the first hop's host, port and user.\n"));
+    proxyCommand = await prompter.askRequired("Proxy command", existing?.proxyCommand ?? "cloudflared access ssh --hostname %h");
+  }
+  const description = await askOptional(prompter, "Description shown to the agent", existing?.description);
+  const readonly = await prompter.askYesNo("Read-only? (rejects writes, redirections, uploads)", existing?.readonly ?? false);
+  let currentAllowedPaths;
+  if (existing != null && existing.allowedPaths.length > 0) {
+    currentAllowedPaths = existing.allowedPaths.join(",");
+  }
+  let allowedPaths = [];
+  const allowedPathsAnswer = await askOptional(
+    prompter,
+    "Limit file tools to path prefixes (comma-separated, empty = anywhere)",
+    currentAllowedPaths
+  );
+  if (allowedPathsAnswer != null) {
+    allowedPaths = allowedPathsAnswer.split(",").map((item) => item.trim()).filter((item) => item !== "");
+  }
+  let resolvedAuth = auth;
+  if (auth === "password" && password == null) {
+    resolvedAuth = "agent";
+  }
+  const answers = {
+    name,
+    host,
+    port,
+    username,
+    auth: resolvedAuth,
+    keyPath,
+    passphrase,
+    password,
+    description,
+    jumpHost,
+    jumpPort,
+    jumpUser,
+    proxyCommand,
+    readonly,
+    allowedPaths,
+    extraEnv: existing?.extraEnv ?? {}
+  };
+  if (existing != null && existing.host === host && existing.port === port) {
+    answers.hostKeyFingerprint = existing.hostKeyFingerprint;
+  }
+  if (existing != null && existing.jumpHost === jumpHost && existing.jumpPort === jumpPort) {
+    answers.jumpHostKeyFingerprint = existing.jumpHostKeyFingerprint;
+  }
+  return answers;
+}
+function toMcpServerEntry(value) {
+  if (typeof value !== "object" || value == null) {
+    return null;
+  }
+  const record = value;
+  if (typeof record.command !== "string") {
+    return null;
+  }
+  let args = [];
+  if (Array.isArray(record.args) == true) {
+    args = record.args.filter((item) => typeof item === "string");
+  }
+  const env = {};
+  if (typeof record.env === "object" && record.env != null) {
+    for (const [key, item] of Object.entries(record.env)) {
+      if (typeof item === "string") {
+        env[key] = item;
+      }
+    }
+  }
+  return { command: record.command, args, env };
+}
+function readMcpServersJson(document) {
+  if (typeof document !== "object" || document == null || Array.isArray(document) == true) {
+    throw new Error("the config file is not a JSON object");
+  }
+  const entries = {};
+  const servers = document.mcpServers;
+  if (typeof servers !== "object" || servers == null) {
+    return entries;
+  }
+  for (const [name, value] of Object.entries(servers)) {
+    const entry = toMcpServerEntry(value);
+    if (entry != null) {
+      entries[name] = entry;
+    }
+  }
+  return entries;
+}
+function readDocument(filePath) {
+  if (fs6__default.default.existsSync(filePath) == false) {
+    return {};
+  }
+  const text = fs6__default.default.readFileSync(filePath, "utf8");
+  if (text.trim() === "") {
+    return {};
+  }
+  let document;
+  try {
+    document = JSON.parse(text);
+  } catch (ex) {
+    let detail = String(ex);
+    if (ex instanceof Error) {
+      detail = ex.message;
+    }
+    throw new Error(`${filePath} is not valid JSON: ${detail}`);
+  }
+  if (typeof document !== "object" || document == null || Array.isArray(document) == true) {
+    throw new Error(`${filePath} is not a JSON object`);
+  }
+  return document;
+}
+function createJsonFileTarget(options) {
+  const { id, label, filePath } = options;
+  function writeDocument(document) {
+    fs6__default.default.mkdirSync(path__default.default.dirname(filePath), { recursive: true });
+    fs6__default.default.writeFileSync(filePath, `${JSON.stringify(document, null, 4)}
+`, "utf8");
+  }
+  return {
+    id,
+    label,
+    location: filePath,
+    detected: fs6__default.default.existsSync(filePath),
+    readEntries() {
+      const document = readDocument(filePath);
+      return readMcpServersJson(document);
+    },
+    writeEntry(name, entry) {
+      const document = readDocument(filePath);
+      let servers = document.mcpServers;
+      if (typeof servers !== "object" || servers == null || Array.isArray(servers) == true) {
+        servers = {};
+      }
+      servers[name] = entry;
+      document.mcpServers = servers;
+      writeDocument(document);
+      return { status: "written", detail: filePath };
+    },
+    removeEntry(name) {
+      const document = readDocument(filePath);
+      const servers = document.mcpServers;
+      if (typeof servers !== "object" || servers == null || Array.isArray(servers) == true) {
+        return { status: "written", detail: filePath };
+      }
+      delete servers[name];
+      writeDocument(document);
+      return { status: "written", detail: filePath };
+    }
+  };
+}
+
+// src/modules/manage/targets/claude-code.ts
+var CLAUDE_CODE_CONFIG_PATH = path__default.default.join(os5__default.default.homedir(), ".claude.json");
+var CMD_META_CHARACTER_PATTERN = /([()\][%!^"`<>&|;, *?])/g;
+function toClaudeAddJsonPayload(entry) {
+  return JSON.stringify({ type: "stdio", command: entry.command, args: entry.args, env: entry.env });
+}
+function formatClaudeAddCommand(name, entry) {
+  const payload = toClaudeAddJsonPayload(entry);
+  return `claude mcp add-json ${name} '${payload}' -s user`;
+}
+function escapeCmdArgument(argument) {
+  let escaped = argument.replace(/(\\*)"/g, '$1$1\\"');
+  escaped = escaped.replace(/(\\*)$/, "$1$1");
+  escaped = `"${escaped}"`;
+  escaped = escaped.replace(CMD_META_CHARACTER_PATTERN, "^$1");
+  escaped = escaped.replace(CMD_META_CHARACTER_PATTERN, "^$1");
+  return escaped;
+}
+function runCliCommand(executable, args) {
+  const isBatchShim = /\.(cmd|bat)$/i.test(executable) == true;
+  if (process.platform !== "win32" || isBatchShim == false) {
+    const result2 = child_process.spawnSync(executable, args, { encoding: "utf8", windowsHide: true });
+    return result2;
+  }
+  const commandLine = [executable.replace(CMD_META_CHARACTER_PATTERN, "^$1"), ...args.map(escapeCmdArgument)].join(" ");
+  const result = child_process.spawnSync(process.env.ComSpec ?? "cmd.exe", ["/d", "/s", "/c", `"${commandLine}"`], {
+    encoding: "utf8",
+    windowsHide: true,
+    windowsVerbatimArguments: true
+  });
+  return result;
+}
+function runClaude(executable, args) {
+  const result = runCliCommand(executable, args);
+  if (result.error != null) {
+    return { status: "unavailable", detail: `could not run claude: ${result.error.message}` };
+  }
+  if (result.status !== 0) {
+    let output = (result.stderr ?? "").trim();
+    if (output === "") {
+      output = (result.stdout ?? "").trim();
+    }
+    return { status: "unavailable", detail: `claude exited with ${result.status}: ${output}` };
+  }
+  return { status: "written", detail: CLAUDE_CODE_CONFIG_PATH };
+}
+function readClaudeEntries() {
+  if (fs6__default.default.existsSync(CLAUDE_CODE_CONFIG_PATH) == false) {
+    return {};
+  }
+  const text = fs6__default.default.readFileSync(CLAUDE_CODE_CONFIG_PATH, "utf8");
+  let document;
+  try {
+    document = JSON.parse(text);
+  } catch (ex) {
+    let detail = String(ex);
+    if (ex instanceof Error) {
+      detail = ex.message;
+    }
+    throw new Error(`${CLAUDE_CODE_CONFIG_PATH} is not valid JSON: ${detail}`);
+  }
+  return readMcpServersJson(document);
+}
+function createClaudeCodeTarget() {
+  const executable = findExecutable("claude");
+  return {
+    id: "claude-code",
+    label: "Claude Code (user scope)",
+    location: CLAUDE_CODE_CONFIG_PATH,
+    detected: executable != null || fs6__default.default.existsSync(CLAUDE_CODE_CONFIG_PATH) == true,
+    readEntries: readClaudeEntries,
+    writeEntry(name, entry) {
+      if (executable == null) {
+        return {
+          status: "unavailable",
+          detail: `the claude CLI is not on PATH \u2014 run this yourself:
+  ${formatClaudeAddCommand(name, entry)}`
+        };
+      }
+      const previous = readClaudeEntries()[name];
+      if (previous != null) {
+        const removed = runClaude(executable, ["mcp", "remove", name, "-s", "user"]);
+        if (removed.status === "unavailable") {
+          return removed;
+        }
+      }
+      const added = runClaude(executable, ["mcp", "add-json", name, toClaudeAddJsonPayload(entry), "-s", "user"]);
+      if (added.status === "unavailable" && previous != null) {
+        runClaude(executable, ["mcp", "add-json", name, toClaudeAddJsonPayload(previous), "-s", "user"]);
+        return { status: "unavailable", detail: `${added.detail}
+  the previous entry was restored` };
+      }
+      return added;
+    },
+    removeEntry(name) {
+      if (executable == null) {
+        return {
+          status: "unavailable",
+          detail: `the claude CLI is not on PATH \u2014 run this yourself:
+  claude mcp remove ${name} -s user`
+        };
+      }
+      return runClaude(executable, ["mcp", "remove", name, "-s", "user"]);
+    }
+  };
+}
+
+// src/modules/manage/targets/toml-subset.ts
+var BARE_KEY_PATTERN = /^[A-Za-z0-9_-]+$/;
+var ANY_HEADER_PATTERN = /^\s*\[/;
+var SERVER_HEADER_PATTERN = /^\s*\[\s*mcp_servers\s*\.\s*([A-Za-z0-9_-]+|"(?:[^"\\]|\\.)*")\s*((?:\.[^\]]*)?)\]\s*(?:#.*)?$/;
+var KEY_VALUE_PATTERN = /^\s*([A-Za-z0-9_-]+|"(?:[^"\\]|\\.)*")\s*=\s*(.*)$/;
+var OWNED_TABLE_KEYS = ["command", "args", "env"];
+var TomlValueParser = class {
+  constructor(text) {
+    this.text = text;
+    this.position = 0;
+  }
+  parse() {
+    const value = this.parseValue();
+    return value;
+  }
+  skipWhitespace() {
+    while (this.position < this.text.length && /\s/.test(this.text[this.position]) == true) {
+      this.position += 1;
+    }
+  }
+  parseValue() {
+    this.skipWhitespace();
+    const current = this.text[this.position];
+    if (current === '"') {
+      return this.parseBasicString();
+    }
+    if (current === "'") {
+      return this.parseLiteralString();
+    }
+    if (current === "[") {
+      return this.parseArray();
+    }
+    if (current === "{") {
+      return this.parseInlineTable();
+    }
+    throw new Error(`unsupported toml value at offset ${this.position}`);
+  }
+  parseBasicString() {
+    this.position += 1;
+    let result = "";
+    while (this.position < this.text.length) {
+      const current = this.text[this.position];
+      if (current === '"') {
+        this.position += 1;
+        return result;
+      }
+      if (current !== "\\") {
+        result += current;
+        this.position += 1;
+        continue;
+      }
+      const escaped = this.text[this.position + 1];
+      this.position += 2;
+      if (escaped === "n") {
+        result += "\n";
+      } else if (escaped === "t") {
+        result += "	";
+      } else if (escaped === "r") {
+        result += "\r";
+      } else if (escaped === "u" || escaped === "U") {
+        let length = 4;
+        if (escaped === "U") {
+          length = 8;
+        }
+        const hex = this.text.slice(this.position, this.position + length);
+        result += String.fromCodePoint(Number.parseInt(hex, 16));
+        this.position += length;
+      } else {
+        result += escaped;
+      }
+    }
+    throw new Error("unterminated toml string");
+  }
+  parseLiteralString() {
+    const end = this.text.indexOf("'", this.position + 1);
+    if (end < 0) {
+      throw new Error("unterminated toml literal string");
+    }
+    const result = this.text.slice(this.position + 1, end);
+    this.position = end + 1;
+    return result;
+  }
+  parseArray() {
+    this.position += 1;
+    const items = [];
+    for (; ; ) {
+      this.skipWhitespace();
+      if (this.position >= this.text.length) {
+        throw new Error("unterminated toml array");
+      }
+      if (this.text[this.position] === "]") {
+        this.position += 1;
+        return items;
+      }
+      items.push(this.parseValue());
+      this.skipWhitespace();
+      if (this.text[this.position] === ",") {
+        this.position += 1;
+      }
+    }
+  }
+  parseInlineTable() {
+    this.position += 1;
+    const table = {};
+    for (; ; ) {
+      this.skipWhitespace();
+      if (this.position >= this.text.length) {
+        throw new Error("unterminated toml inline table");
+      }
+      if (this.text[this.position] === "}") {
+        this.position += 1;
+        return table;
+      }
+      let key;
+      if (this.text[this.position] === '"') {
+        key = this.parseBasicString();
+      } else {
+        const match = /^[A-Za-z0-9_-]+/.exec(this.text.slice(this.position));
+        if (match == null) {
+          throw new Error(`invalid inline table key at offset ${this.position}`);
+        }
+        key = match[0];
+        this.position += key.length;
+      }
+      this.skipWhitespace();
+      if (this.text[this.position] !== "=") {
+        throw new Error(`expected '=' at offset ${this.position}`);
+      }
+      this.position += 1;
+      table[key] = this.parseValue();
+      this.skipWhitespace();
+      if (this.text[this.position] === ",") {
+        this.position += 1;
+      }
+    }
+  }
+};
+function unquoteKey(rawKey) {
+  if (rawKey.startsWith('"') == false) {
+    return rawKey;
+  }
+  const parsed = new TomlValueParser(rawKey).parse();
+  return parsed;
+}
+function bracketBalance(text) {
+  let balance = 0;
+  let quote = null;
+  for (let index = 0; index < text.length; index += 1) {
+    const current = text[index];
+    if (quote != null) {
+      if (current === "\\" && quote === '"') {
+        index += 1;
+      } else if (current === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (current === '"' || current === "'") {
+      quote = current;
+    } else if (current === "#") {
+      break;
+    } else if (current === "[" || current === "{") {
+      balance += 1;
+    } else if (current === "]" || current === "}") {
+      balance -= 1;
+    }
+  }
+  return balance;
+}
+function stripComment(text) {
+  let quote = null;
+  for (let index = 0; index < text.length; index += 1) {
+    const current = text[index];
+    if (quote != null) {
+      if (current === "\\" && quote === '"') {
+        index += 1;
+      } else if (current === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (current === '"' || current === "'") {
+      quote = current;
+    } else if (current === "#") {
+      return text.slice(0, index);
+    }
+  }
+  return text;
+}
+function readStatements(body) {
+  const statements = [];
+  let index = 0;
+  while (index < body.length) {
+    const match = KEY_VALUE_PATTERN.exec(body[index]);
+    if (match == null) {
+      index += 1;
+      continue;
+    }
+    const start = index;
+    let rawValue = stripComment(match[2]);
+    let balance = bracketBalance(rawValue);
+    index += 1;
+    while (balance > 0 && index < body.length) {
+      const continuation = stripComment(body[index]);
+      rawValue += `
+${continuation}`;
+      balance += bracketBalance(continuation);
+      index += 1;
+    }
+    statements.push({ key: unquoteKey(match[1]), rawValue, start, end: index });
+  }
+  return statements;
+}
+function splitSections(lines) {
+  const sections = [{ header: null, serverName: null, subPath: "", body: [] }];
+  let balance = 0;
+  for (const line of lines) {
+    const current = sections[sections.length - 1];
+    if (balance > 0) {
+      current.body.push(line);
+      balance += bracketBalance(stripComment(line));
+      continue;
+    }
+    if (ANY_HEADER_PATTERN.test(line) == true) {
+      const serverMatch = SERVER_HEADER_PATTERN.exec(line);
+      let serverName = null;
+      let subPath = "";
+      if (serverMatch != null) {
+        serverName = unquoteKey(serverMatch[1]);
+        subPath = serverMatch[2].replace(/^\./, "").replace(/\s+/g, "");
+      }
+      sections.push({ header: line, serverName, subPath, body: [] });
+      continue;
+    }
+    current.body.push(line);
+    const keyValueMatch = KEY_VALUE_PATTERN.exec(line);
+    if (keyValueMatch != null) {
+      balance = bracketBalance(stripComment(keyValueMatch[2]));
+    }
+  }
+  return sections;
+}
+function parseStatementValue(statement) {
+  try {
+    const value = new TomlValueParser(statement.rawValue).parse();
+    return value;
+  } catch {
+    return null;
+  }
+}
+function parseMcpServersToml(text) {
+  const sections = splitSections(text.split(/\r?\n/));
+  const entries = {};
+  const envTables = {};
+  for (const section of sections) {
+    if (section.serverName == null) {
+      continue;
+    }
+    if (section.subPath === "env") {
+      const envTable = {};
+      for (const statement of readStatements(section.body)) {
+        const value = parseStatementValue(statement);
+        if (typeof value === "string") {
+          envTable[statement.key] = value;
+        }
+      }
+      envTables[section.serverName] = envTable;
+      continue;
+    }
+    if (section.subPath !== "") {
+      continue;
+    }
+    let command = null;
+    let args = [];
+    const env = {};
+    for (const statement of readStatements(section.body)) {
+      const value = parseStatementValue(statement);
+      if (statement.key === "command" && typeof value === "string") {
+        command = value;
+      } else if (statement.key === "args" && Array.isArray(value) == true) {
+        args = value.filter((item) => typeof item === "string");
+      } else if (statement.key === "env" && value != null && typeof value === "object" && Array.isArray(value) == false) {
+        for (const [key, item] of Object.entries(value)) {
+          if (typeof item === "string") {
+            env[key] = item;
+          }
+        }
+      }
+    }
+    if (command != null) {
+      entries[section.serverName] = { command, args, env };
+    }
+  }
+  for (const [name, envTable] of Object.entries(envTables)) {
+    if (entries[name] != null) {
+      Object.assign(entries[name].env, envTable);
+    }
+  }
+  return entries;
+}
+function quoteTomlString(value) {
+  const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+  return `"${escaped}"`;
+}
+function formatTomlKey(key) {
+  if (BARE_KEY_PATTERN.test(key) == true) {
+    return key;
+  }
+  return quoteTomlString(key);
+}
+function renderOwnedLines(entry) {
+  return [
+    `command = ${quoteTomlString(entry.command)}`,
+    `args = [${entry.args.map((argument) => quoteTomlString(argument)).join(", ")}]`
+  ];
+}
+function renderEnvLines(entry) {
+  return Object.entries(entry.env).map(([key, value]) => `${formatTomlKey(key)} = ${quoteTomlString(value)}`);
+}
+function renderMcpServerTable(name, entry) {
+  const tableKey = formatTomlKey(name);
+  const lines = [`[mcp_servers.${tableKey}]`, ...renderOwnedLines(entry)];
+  const envLines = renderEnvLines(entry);
+  if (envLines.length > 0) {
+    lines.push("");
+    lines.push(`[mcp_servers.${tableKey}.env]`);
+    lines.push(...envLines);
+  }
+  return `${lines.join("\n")}
+`;
+}
+function isBlank(line) {
+  return line.trim() === "";
+}
+function joinSections(sections, eol) {
+  const lines = [];
+  for (const section of sections) {
+    if (section.header != null) {
+      lines.push(section.header);
+    }
+    lines.push(...section.body);
+  }
+  return lines.join(eol);
+}
+function writeMcpServerToml(text, name, entry) {
+  let eol = "\n";
+  if (text.includes("\r\n") == true) {
+    eol = "\r\n";
+  }
+  const sections = splitSections(text.split(/\r?\n/));
+  const isOwn = (section) => section.serverName === name;
+  if (entry == null) {
+    const kept = sections.filter((section) => isOwn(section) == false);
+    const removedText = joinSections(kept, eol);
+    return removedText;
+  }
+  const tableKey = formatTomlKey(name);
+  const envLines = renderEnvLines(entry);
+  const tableIndex = sections.findIndex((section) => isOwn(section) == true && section.subPath === "");
+  if (tableIndex < 0) {
+    const withoutStrayEnv = sections.filter((section) => (isOwn(section) == true && section.subPath === "env") == false);
+    let prefix = joinSections(withoutStrayEnv, eol);
+    if (prefix.trim() === "") {
+      prefix = "";
+    } else {
+      prefix = prefix.replace(/(\r?\n)*$/, "");
+      prefix = `${prefix}${eol}${eol}`;
+    }
+    const block = renderMcpServerTable(name, entry).replace(/\n/g, eol);
+    return `${prefix}${block}`;
+  }
+  const table = sections[tableIndex];
+  const ownedLineIndexes = /* @__PURE__ */ new Set();
+  for (const statement of readStatements(table.body)) {
+    if (OWNED_TABLE_KEYS.includes(statement.key) == true) {
+      for (let index = statement.start; index < statement.end; index += 1) {
+        ownedLineIndexes.add(index);
+      }
+    }
+  }
+  const userLines = table.body.filter((_line, index) => ownedLineIndexes.has(index) == false);
+  let trailingBlankCount = 0;
+  while (trailingBlankCount < userLines.length && isBlank(userLines[userLines.length - 1 - trailingBlankCount]) == true) {
+    trailingBlankCount += 1;
+  }
+  const trailingBlanks = userLines.slice(userLines.length - trailingBlankCount);
+  const userContent = userLines.slice(0, userLines.length - trailingBlankCount);
+  const rebuilt = [];
+  for (let index = 0; index < sections.length; index += 1) {
+    const section = sections[index];
+    if (isOwn(section) == true && section.subPath === "env") {
+      continue;
+    }
+    if (index !== tableIndex) {
+      rebuilt.push(section);
+      continue;
+    }
+    if (envLines.length === 0) {
+      rebuilt.push({ ...section, body: [...renderOwnedLines(entry), ...userContent, ...trailingBlanks] });
+      continue;
+    }
+    rebuilt.push({ ...section, body: [...renderOwnedLines(entry), ...userContent, ""] });
+    rebuilt.push({
+      header: `[mcp_servers.${tableKey}.env]`,
+      serverName: name,
+      subPath: "env",
+      body: [...envLines, ...trailingBlanks]
+    });
+  }
+  const rebuiltText = joinSections(rebuilt, eol);
+  return rebuiltText;
+}
+
+// src/modules/manage/targets/codex.ts
+var CODEX_CONFIG_PATH = path__default.default.join(os5__default.default.homedir(), ".codex", "config.toml");
+function createCodexTarget() {
+  function readText() {
+    if (fs6__default.default.existsSync(CODEX_CONFIG_PATH) == false) {
+      return "";
+    }
+    return fs6__default.default.readFileSync(CODEX_CONFIG_PATH, "utf8");
+  }
+  function writeText(text) {
+    fs6__default.default.mkdirSync(path__default.default.dirname(CODEX_CONFIG_PATH), { recursive: true });
+    fs6__default.default.writeFileSync(CODEX_CONFIG_PATH, text, "utf8");
+    return { status: "written", detail: CODEX_CONFIG_PATH };
+  }
+  return {
+    id: "codex",
+    label: "Codex CLI",
+    location: CODEX_CONFIG_PATH,
+    detected: findExecutable("codex") != null || fs6__default.default.existsSync(CODEX_CONFIG_PATH) == true,
+    readEntries() {
+      const text = readText();
+      return parseMcpServersToml(text);
+    },
+    writeEntry(name, entry) {
+      const text = readText();
+      const updated = writeMcpServerToml(text, name, entry);
+      return writeText(updated);
+    },
+    removeEntry(name) {
+      const text = readText();
+      const updated = writeMcpServerToml(text, name, null);
+      return writeText(updated);
+    }
+  };
 }
-function readIntegerEnv(name) {
-  const value = readEnv(name);
-  if (value == null) {
-    return void 0;
+
+// src/modules/manage/targets/index.ts
+function claudeDesktopConfigPath() {
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA ?? path__default.default.join(os5__default.default.homedir(), "AppData", "Roaming");
+    return path__default.default.join(appData, "Claude", "claude_desktop_config.json");
   }
-  const parsed = Number(value);
-  if (Number.isInteger(parsed) == false || parsed <= 0) {
-    throw new Error(`${name} must be a positive integer (got "${value}")`);
+  if (process.platform === "darwin") {
+    return path__default.default.join(os5__default.default.homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
   }
-  return parsed;
+  return path__default.default.join(os5__default.default.homedir(), ".config", "Claude", "claude_desktop_config.json");
 }
-function readListEnv(name) {
-  const value = readEnv(name);
-  if (value == null) {
-    return void 0;
+function listConfigTargets() {
+  const targets = [
+    createClaudeCodeTarget(),
+    createCodexTarget(),
+    createJsonFileTarget({ id: "claude-desktop", label: "Claude Desktop", filePath: claudeDesktopConfigPath() }),
+    createJsonFileTarget({ id: "cursor", label: "Cursor", filePath: path__default.default.join(os5__default.default.homedir(), ".cursor", "mcp.json") })
+  ];
+  const detected = targets.filter((target) => target.detected == true);
+  const others = targets.filter((target) => target.detected == false);
+  return [...detected, ...others];
+}
+
+// src/modules/manage/index.ts
+var SECRET_ENV_NAMES = [
+  SINGLE_HOST_ENV.PASSWORD,
+  SINGLE_HOST_ENV.PASSPHRASE,
+  SINGLE_HOST_ENV.JUMP_PASSWORD,
+  SINGLE_HOST_ENV.JUMP_PASSPHRASE
+];
+var HOST_VALUE_PREFIX = "host:";
+function errorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
   }
-  const items = value.split(",").map((item) => item.trim()).filter((item) => item !== "");
-  if (items.length === 0) {
-    return void 0;
+  return String(error);
+}
+function maskSecrets(entry) {
+  const env = {};
+  for (const [name, value] of Object.entries(entry.env)) {
+    if (SECRET_ENV_NAMES.includes(name) == true) {
+      env[name] = "********";
+      continue;
+    }
+    env[name] = value;
   }
-  return items;
+  return { ...entry, env };
 }
-function compileDenyPatterns(sources) {
-  return sources.map((source) => {
-    try {
-      return new RegExp(source, "i");
-    } catch (ex) {
-      const _logger = $logger.child({ context: "compileDenyPatterns" });
-      _logger.error(ex, "denyPatterns entry is not a valid regular expression");
-      let detail = String(ex);
-      if (ex instanceof Error) {
-        detail = ex.message;
+function formatForTarget(target, name, entry) {
+  if (target.id === "codex") {
+    return renderMcpServerTable(name, entry);
+  }
+  return `"${name}": ${JSON.stringify(entry, null, 4)}
+`;
+}
+function indent(text) {
+  return text.replace(/\n$/, "").split("\n").map((line) => `    ${line}`).join("\n");
+}
+function reportWrite(prompter, result, action) {
+  if (result.status === "written") {
+    prompter.write(`  ${prompter.paint.success(action)} ${prompter.paint.dim(result.detail)}
+`);
+    prompter.write(prompter.paint.dim("  Restart the client (or reconnect it from its MCP menu) to pick up the change.\n\n"));
+    return;
+  }
+  prompter.write(`  Not ${action.toLowerCase()}: ${result.detail}
+
+`);
+}
+function profileFromEntry(output, entry) {
+  try {
+    const profile = loadHostProfile(entry.env);
+    if (profile == null) {
+      output.write("  The entry has no host.\n");
+    }
+    return profile;
+  } catch (ex) {
+    output.write(`  The server would refuse to start with this entry: ${errorMessage(ex)}
+`);
+    return null;
+  }
+}
+async function verifyAnswers(prompter, output, initial) {
+  let answers = initial;
+  for (; ; ) {
+    const testNow = await prompter.askYesNo("Test the connection now?", true);
+    if (testNow == false) {
+      return answers;
+    }
+    output.write("\n");
+    const profile = profileFromEntry(output, answersToEntry(answers));
+    if (profile != null) {
+      const result = await runConnectionCheck(profile, output);
+      output.write("\n");
+      if (result.connected == true) {
+        if (result.hostKeyFingerprint != null && answers.hostKeyFingerprint == null) {
+          const pin = await prompter.askYesNo("Pin this host key? (a changed key then aborts the connection)", true);
+          if (pin == true) {
+            answers = { ...answers, hostKeyFingerprint: result.hostKeyFingerprint };
+          }
+        }
+        if (result.jumpHostKeyFingerprint != null && answers.jumpHost != null && answers.jumpHostKeyFingerprint == null) {
+          const pin = await prompter.askYesNo("Pin the jump host key too?", true);
+          if (pin == true) {
+            answers = { ...answers, jumpHostKeyFingerprint: result.jumpHostKeyFingerprint };
+          }
+        }
+        return answers;
+      }
+      const hostKeyChanged = result.hostKeyFingerprint != null && answers.hostKeyFingerprint != null && result.hostKeyFingerprint !== answers.hostKeyFingerprint;
+      if (hostKeyChanged == true) {
+        output.write("  The host presented a different key than the pinned one. Re-pin only if you know it was rebuilt.\n");
+        const repin = await prompter.askYesNo(`Pin ${result.hostKeyFingerprint} instead?`, false);
+        if (repin == true) {
+          answers = { ...answers, hostKeyFingerprint: result.hostKeyFingerprint ?? void 0 };
+          continue;
+        }
+      }
+      const jumpKeyChanged = result.jumpHostKeyFingerprint != null && answers.jumpHostKeyFingerprint != null && result.jumpHostKeyFingerprint !== answers.jumpHostKeyFingerprint;
+      if (jumpKeyChanged == true) {
+        output.write("  The jump host presented a different key than the pinned one. Re-pin only if you know it was rebuilt.\n");
+        const repin = await prompter.askYesNo(`Pin ${result.jumpHostKeyFingerprint} instead?`, false);
+        if (repin == true) {
+          answers = { ...answers, jumpHostKeyFingerprint: result.jumpHostKeyFingerprint ?? void 0 };
+          continue;
+        }
       }
-      throw new Error(`${SINGLE_HOST_ENV.DENY_PATTERNS} has an invalid entry /${source}/: ${detail}`);
     }
-  });
+    const next = await prompter.select(
+      "The check failed. What now?",
+      [
+        { value: "edit", key: "e", label: "Change the answers" },
+        { value: "retry", key: "r", label: "Try again", hint: "e.g. after starting a tunnel" },
+        { value: "write", key: "w", label: "Write it anyway", hint: "the host may be unreachable from here" },
+        { value: "cancel", key: "c", label: "Cancel", hint: "nothing is written" }
+      ],
+      { defaultValue: "edit", cancelValue: "cancel" }
+    );
+    if (next === "cancel") {
+      return null;
+    }
+    if (next === "write") {
+      return answers;
+    }
+    if (next === "edit") {
+      output.write("\n");
+      answers = await askHostQuestions(prompter, answers);
+    }
+  }
 }
-function loadHostProfile() {
-  const host = readEnv(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", {
-      env_vars: [SINGLE_HOST_ENV.HOST, SINGLE_HOST_ENV.USER]
-    });
-    return null;
+async function addOrEditHost(prompter, output, target, entries, existingName) {
+  let existing;
+  if (existingName != null) {
+    existing = entryToAnswers(existingName, entries[existingName]);
+    output.write(`
+${prompter.paint.bold(`Editing ${existingName}`)}
+`);
+  } else {
+    output.write(`
+${prompter.paint.bold("Adding a host")}
+`);
   }
-  const username = readEnv(SINGLE_HOST_ENV.USER);
-  if (username == null) {
-    throw new Error(`${SINGLE_HOST_ENV.HOST} is set, so ${SINGLE_HOST_ENV.USER} is required`);
+  const asked = await askHostQuestions(prompter, existing);
+  output.write("\n");
+  const answers = await verifyAnswers(prompter, output, asked);
+  if (answers == null) {
+    output.write("  Cancelled \u2014 nothing was written.\n\n");
+    return;
   }
-  const name = readEnv(SINGLE_HOST_ENV.NAME) ?? host;
-  const _logger = $logger.child({ context: "loadHostProfile", profile: name });
-  const allowCommands = readListEnv(SINGLE_HOST_ENV.ALLOW_COMMANDS) ?? [];
-  if (allowCommands.length > 0 && allowCommands.includes("pwd") == false) {
-    allowCommands.push("pwd");
+  if (answers.name !== existingName && entries[answers.name] != null) {
+    const replace = await prompter.askYesNo(`"${answers.name}" already exists in this file. Replace it?`, false);
+    if (replace == false) {
+      output.write("  Cancelled \u2014 nothing was written.\n\n");
+      return;
+    }
   }
-  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,
-    allowCommands,
-    denyPatterns: compileDenyPatterns(readListEnv(SINGLE_HOST_ENV.DENY_PATTERNS) ?? []),
-    allowedPaths: readListEnv(SINGLE_HOST_ENV.ALLOWED_PATHS) ?? []
-  };
-  const profile = {
-    name,
-    host,
-    port: readIntegerEnv(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),
-    policy
-  };
-  const keyPath = readEnv(SINGLE_HOST_ENV.KEY);
-  if (keyPath != null) {
-    const expandedKeyPath = expandHomePath(keyPath);
-    profile.privateKeyPath = expandedKeyPath;
-    if (fs__default.default.existsSync(expandedKeyPath) == false) {
-      _logger.warn(`${SINGLE_HOST_ENV.KEY} does not exist; connections will fail`, {
-        private_key_path: expandedKeyPath
-      });
+  const entry = answersToEntry(answers);
+  output.write(`
+  ${prompter.paint.dim(`This goes into ${target.location}:`)}
+
+`);
+  output.write(`${indent(formatForTarget(target, answers.name, maskSecrets(entry)))}
+
+`);
+  const confirmed = await prompter.askYesNo("Write it?", true);
+  if (confirmed == false) {
+    output.write("  Not written. Pick the host and choose Print to get the entry ready to paste.\n\n");
+    return;
+  }
+  const written = target.writeEntry(answers.name, entry);
+  reportWrite(prompter, written, "Written");
+  if (written.status === "written" && existingName != null && existingName !== answers.name) {
+    const removed = target.removeEntry(existingName);
+    if (removed.status === "unavailable") {
+      output.write(`  The old name ${existingName} is still there: ${removed.detail}
+
+`);
     }
   }
-  _logger.info("host profile loaded", {
-    host,
-    port: profile.port,
-    username,
-    readonly: policy.readonly
+}
+async function checkHost(prompter, output, target, name, entry) {
+  output.write("\n");
+  const profile = profileFromEntry(output, entry);
+  if (profile == null) {
+    output.write("\n");
+    return;
+  }
+  const result = await runConnectionCheck(profile, output);
+  output.write("\n");
+  if (result.connected == false) {
+    return;
+  }
+  const env = { ...entry.env };
+  let changed = false;
+  if (result.hostKeyFingerprint != null && env[SINGLE_HOST_ENV.HOST_KEY] == null) {
+    const pin = await prompter.askYesNo("Pin this host key?", true);
+    if (pin == true) {
+      env[SINGLE_HOST_ENV.HOST_KEY] = result.hostKeyFingerprint;
+      changed = true;
+    }
+  }
+  if (result.jumpHostKeyFingerprint != null && env[SINGLE_HOST_ENV.JUMP_HOST_KEY] == null) {
+    const pin = await prompter.askYesNo("Pin the jump host key too?", true);
+    if (pin == true) {
+      env[SINGLE_HOST_ENV.JUMP_HOST_KEY] = result.jumpHostKeyFingerprint;
+      changed = true;
+    }
+  }
+  if (changed == true) {
+    const written = target.writeEntry(name, { ...entry, env });
+    reportWrite(prompter, written, "Pinned");
+  }
+}
+function printHost(prompter, name, entry) {
+  prompter.write(`
+  ${prompter.paint.dim('JSON \u2014 Claude Desktop, Cursor, .mcp.json (inside "mcpServers"):')}
+
+`);
+  prompter.write(`${indent(`"${name}": ${JSON.stringify(entry, null, 4)}`)}
+
+`);
+  prompter.write(`  ${prompter.paint.dim("TOML \u2014 Codex (~/.codex/config.toml):")}
+
+`);
+  prompter.write(`${indent(renderMcpServerTable(name, entry))}
+
+`);
+  prompter.write(`  ${prompter.paint.dim("Claude Code CLI (bash / zsh / Git Bash):")}
+
+`);
+  prompter.write(`${indent(formatClaudeAddCommand(name, entry))}
+
+`);
+}
+function buildHostItems(names, entries) {
+  const nameWidth = Math.max(...names.map((name) => displayWidth(name)));
+  const summaries = names.map((name) => summarizeEntry(entries[name]));
+  const endpointWidth = Math.max(...summaries.map((summary) => displayWidth(summary.endpoint)));
+  return names.map((name, index) => {
+    const summary = summaries[index];
+    const hintParts = [summary.auth];
+    if (summary.notes !== "") {
+      hintParts.push(summary.notes);
+    }
+    return {
+      value: `${HOST_VALUE_PREFIX}${name}`,
+      key: name,
+      label: `${name.padEnd(nameWidth)}  ${summary.endpoint.padEnd(endpointWidth)}`,
+      hint: hintParts.join(" \xB7 ")
+    };
   });
-  return profile;
 }
-function toHostSummary(profile) {
-  let authMethod = "agent";
-  if (profile.privateKeyPath != null) {
-    authMethod = "privateKey";
-  } else if (profile.password != null) {
-    authMethod = "password";
+async function manageHost(prompter, output, target, entries, name) {
+  const action = await prompter.select(
+    name,
+    [
+      { value: "edit", key: "e", label: "Edit", hint: "change the answers, re-check, re-write" },
+      { value: "check", key: "c", label: "Check the connection", hint: "connect now and offer to pin the host key" },
+      { value: "print", key: "p", label: "Print the entry", hint: "JSON, Codex TOML and a claude command, ready to paste" },
+      { value: "remove", key: "r", label: "Remove", hint: `from ${target.label}` },
+      { separator: true },
+      { value: "back", key: "b", label: "Back" }
+    ],
+    { defaultValue: "edit", cancelValue: "back" }
+  );
+  if (action === "edit") {
+    await addOrEditHost(prompter, output, target, entries, name);
+    return;
+  }
+  if (action === "check") {
+    await checkHost(prompter, output, target, name, entries[name]);
+    return;
+  }
+  if (action === "print") {
+    printHost(prompter, name, entries[name]);
+    return;
+  }
+  if (action === "remove") {
+    const remove = await prompter.askYesNo(`Remove ${name} from ${target.location}?`, false);
+    if (remove == true) {
+      reportWrite(prompter, target.removeEntry(name), "Removed");
+    }
+  }
+}
+async function runConfigCommand(options) {
+  const { input, output } = options;
+  const targets = options.targets ?? listConfigTargets();
+  let target = targets[0];
+  if (options.targetId != null) {
+    const requested = targets.find((candidate) => candidate.id === options.targetId);
+    if (requested == null) {
+      output.write(`Unknown client "${options.targetId}". One of: ${targets.map((candidate) => candidate.id).join(", ")}
+`);
+      return 1;
+    }
+    target = requested;
+  }
+  const prompter = new Prompter(input, output);
+  const paint = prompter.paint;
+  try {
+    for (; ; ) {
+      let entries = {};
+      let names = [];
+      let readError = null;
+      try {
+        entries = target.readEntries();
+        names = Object.keys(entries).filter((name) => isOurEntry(entries[name]) == true);
+      } catch (ex) {
+        readError = errorMessage(ex);
+      }
+      output.write(`
+${paint.bold(target.label)}  ${paint.dim(target.location)}
+`);
+      if (readError != null) {
+        output.write(`  Cannot read it: ${readError}
+  Fix the file by hand, or switch to another client.
+`);
+      } else {
+        const otherCount = Object.keys(entries).length - names.length;
+        if (otherCount > 0) {
+          output.write(paint.dim(`  ${otherCount} other MCP server(s) in this file are not managed here.
+`));
+        }
+      }
+      output.write("\n");
+      const items = [];
+      if (names.length > 0) {
+        items.push(...buildHostItems(names, entries));
+        items.push({ separator: true });
+      }
+      if (readError == null) {
+        items.push({ value: "add", key: "a", label: "Add a host" });
+      }
+      const otherTargets = targets.filter((candidate) => candidate.id !== target.id);
+      if (otherTargets.length > 0) {
+        const detectedOthers = otherTargets.filter((candidate) => candidate.detected == true).map((candidate) => candidate.label);
+        let switchHint = "";
+        if (detectedOthers.length > 0) {
+          switchHint = `also found: ${detectedOthers.join(", ")}`;
+        }
+        items.push({ value: "switch", key: "t", label: "Switch client", hint: switchHint });
+      }
+      items.push({ value: "quit", key: "q", label: "Quit" });
+      let question = "No SSH hosts here yet";
+      if (names.length === 1) {
+        question = "1 SSH host \u2014 pick it to manage it";
+      } else if (names.length > 1) {
+        question = `${names.length} SSH hosts \u2014 pick one to manage it`;
+      }
+      let defaultValue = "add";
+      if (names.length > 0) {
+        defaultValue = `${HOST_VALUE_PREFIX}${names[0]}`;
+      }
+      const picked = await prompter.select(question, items, { defaultValue, cancelValue: "quit" });
+      if (picked === "quit") {
+        return 0;
+      }
+      if (picked === "switch") {
+        const switched = await prompter.select(
+          "Which client?",
+          targets.map((candidate) => {
+            let hint = candidate.location;
+            if (candidate.detected == false) {
+              hint += " \xB7 not found on this machine";
+            }
+            return { value: candidate.id, label: candidate.label, hint };
+          }),
+          { defaultValue: target.id, cancelValue: target.id }
+        );
+        target = targets.find((candidate) => candidate.id === switched) ?? target;
+        continue;
+      }
+      try {
+        if (picked === "add") {
+          await addOrEditHost(prompter, output, target, entries);
+          continue;
+        }
+        if (picked.startsWith(HOST_VALUE_PREFIX) == true) {
+          await manageHost(prompter, output, target, entries, picked.slice(HOST_VALUE_PREFIX.length));
+        }
+      } catch (ex) {
+        if (ex instanceof PromptClosedError) {
+          throw ex;
+        }
+        output.write(`  Failed: ${errorMessage(ex)}
+
+`);
+      }
+    }
+  } catch (ex) {
+    if (ex instanceof PromptClosedError) {
+      output.write("\n");
+      return 0;
+    }
+    throw ex;
+  } finally {
+    prompter.close();
   }
-  return {
-    name: profile.name,
-    host: profile.host,
-    port: profile.port,
-    username: profile.username,
-    description: profile.description,
-    authMethod,
-    readonly: profile.policy.readonly,
-    allowSudo: profile.policy.allowSudo,
-    allowedPaths: profile.policy.allowedPaths,
-    allowCommands: profile.policy.allowCommands
-  };
 }
 
 // src/modules/tools/format.ts
@@ -2145,6 +4523,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)`);
   }
@@ -2525,7 +4913,7 @@ ${file.content}`);
         const { profile, session: openSession } = resolveProfile(context, { session });
         const resolvedLocalPath = expandHomePath(localPath);
         requirePermittedLocalPath(resolvedLocalPath, "read");
-        if (fs__default.default.existsSync(resolvedLocalPath) == false) {
+        if (fs6__default.default.existsSync(resolvedLocalPath) == false) {
           return textResult(`local file not found: ${resolvedLocalPath}`);
         }
         const transferredBytes = await withHostConnection(profile, openSession, async (connection) => {
@@ -2565,7 +4953,7 @@ ${file.content}`);
         const { profile, session: openSession } = resolveProfile(context, { session });
         const resolvedLocalPath = expandHomePath(localPath);
         requirePermittedLocalPath(resolvedLocalPath, "write");
-        fs__default.default.mkdirSync(path2__default.default.dirname(resolvedLocalPath), { recursive: true });
+        fs6__default.default.mkdirSync(path__default.default.dirname(resolvedLocalPath), { recursive: true });
         const transferredBytes = await withHostConnection(profile, openSession, async (connection) => {
           return await downloadFile(connection, remotePath, resolvedLocalPath);
         });
@@ -2789,8 +5177,23 @@ function createSshMcpServer() {
 
 // src/cli.ts
 function parseArguments(argv) {
-  const parsed = { showHelp: false, showVersion: false, checkOnly: false };
-  for (const argument of argv) {
+  const parsed = { showHelp: false, showVersion: false, checkOnly: false, configMode: false };
+  let rest = argv;
+  if (argv[0] === "config") {
+    parsed.configMode = true;
+    rest = argv.slice(1);
+  }
+  for (let index = 0; index < rest.length; index += 1) {
+    const argument = rest[index];
+    if (argument === "--target") {
+      parsed.targetId = rest[index + 1];
+      index += 1;
+      continue;
+    }
+    if (argument.startsWith("--target=") == true) {
+      parsed.targetId = argument.slice("--target=".length);
+      continue;
+    }
     if (argument === "--help" || argument === "-h") {
       parsed.showHelp = true;
       continue;
@@ -2811,10 +5214,18 @@ var HELP_TEXT = [
   "",
   "Usage:",
   "  akms-mcp-ssh [--check]",
+  "  akms-mcp-ssh config [--target <client>]",
+  "",
+  "Commands:",
+  "  config               Manage the SSH hosts registered in an MCP client's config \u2014",
+  "                       list, add, edit, remove, check, print. Asks plain questions,",
+  "                       so the SSH_* names below never have to be typed.",
   "",
   "Options:",
   "      --check          Connect to the configured host, report the result, and exit.",
   "                       Prints the host key fingerprint so it can be pinned.",
+  "      --target <id>    config: claude-code | codex | claude-desktop | cursor",
+  "                       (default: the first one installed)",
   "  -v, --version        Print the version and exit",
   "  -h, --help           Print this help and exit",
   "",
@@ -2829,6 +5240,11 @@ var HELP_TEXT = [
   `  ${SINGLE_HOST_ENV.NAME}          Alias shown to the model; defaults to the hostname`,
   `  ${SINGLE_HOST_ENV.DESCRIPTION}   Shown to the model \u2014 say what the host is for`,
   `  ${SINGLE_HOST_ENV.CWD}           Directory new sessions start in`,
+  `  ${SINGLE_HOST_ENV.PROXY_COMMAND} Command carrying the SSH stream on its stdin/stdout (OpenSSH ProxyCommand);`,
+  "                     %h / %p / %r expand to the first hop's host, port and user",
+  `  ${SINGLE_HOST_ENV.JUMP_HOST}     Jump host the target is reached through (OpenSSH ProxyJump / -J)`,
+  `  ${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}`,
+  `                     Jump host connection; user and key default to ${SINGLE_HOST_ENV.USER} / ${SINGLE_HOST_ENV.KEY}`,
   `  ${SINGLE_HOST_ENV.READONLY}      Reject write commands, redirections, uploads  (default false)`,
   `  ${SINGLE_HOST_ENV.ALLOW_SUDO}    Allow sudo / su / doas  (default true)`,
   `  ${SINGLE_HOST_ENV.ALLOW_COMMANDS}  Comma-separated allow-list of binaries`,
@@ -2840,60 +5256,14 @@ var HELP_TEXT = [
   "",
   "The server speaks MCP over stdio; run it from an MCP client, not interactively."
 ].join("\n");
-function describeAuth(profile) {
-  if (profile.privateKeyPath != null) {
-    return `key ${profile.privateKeyPath}`;
-  }
-  if (profile.password != null) {
-    return "password";
-  }
-  return "ssh agent";
-}
-async function runConnectionCheck(profile) {
+async function runCheckCommand(profile) {
   if (profile == null) {
-    process.stdout.write(`No SSH host is registered \u2014 set ${SINGLE_HOST_ENV.HOST} and ${SINGLE_HOST_ENV.USER}.
+    process.stdout.write(`No SSH host is registered \u2014 set ${SINGLE_HOST_ENV.HOST} and ${SINGLE_HOST_ENV.USER}, or run: akms-mcp-ssh config
 `);
     return 1;
   }
-  const endpoint = `${profile.username}@${profile.host}:${profile.port}`;
-  const auth = describeAuth(profile);
-  process.stdout.write(`Checking ${profile.name}  \u2192  ${endpoint}
-
-`);
-  const connection = new SshConnection(profile);
-  const startedAt = Date.now();
-  let connected = false;
-  let detail = "";
-  try {
-    await connection.connect();
-    connected = true;
-  } catch (ex) {
-    detail = String(ex);
-    if (ex instanceof Error) {
-      detail = ex.message;
-    }
-  } finally {
-    connection.disconnect();
-  }
-  const durationMs = Date.now() - startedAt;
-  if (connected == true) {
-    process.stdout.write(`  OK      ${endpoint}  (${auth}, ${durationMs}ms)
-`);
-  } else {
-    process.stdout.write(`  FAILED  ${endpoint}  (${auth})
-`);
-    process.stdout.write(`          ${detail}
-`);
-  }
-  if (connection.hostKeyFingerprint != null) {
-    let pinNote = `not pinned \u2014 set ${SINGLE_HOST_ENV.HOST_KEY} to it to detect a changed key`;
-    if (profile.hostKeyFingerprint != null) {
-      pinNote = "pinned";
-    }
-    process.stdout.write(`          host key ${connection.hostKeyFingerprint}  (${pinNote})
-`);
-  }
-  if (connected == true) {
+  const result = await runConnectionCheck(profile, process.stdout);
+  if (result.connected == true) {
     return 0;
   }
   return 1;
@@ -2911,12 +5281,23 @@ async function main() {
 `);
     return;
   }
+  if (cliArguments.configMode == true) {
+    if (process.env[LOG_LEVEL_ENV] == null) {
+      process.env[LOG_LEVEL_ENV] = "warn";
+    }
+    const exitCode = await runConfigCommand({
+      input: process.stdin,
+      output: process.stdout,
+      targetId: cliArguments.targetId
+    });
+    process.exit(exitCode);
+  }
   if (cliArguments.checkOnly == true && process.env[LOG_LEVEL_ENV] == null) {
-    process.env[LOG_LEVEL_ENV] = "silent";
+    process.env[LOG_LEVEL_ENV] = "warn";
   }
   const instance = createSshMcpServer();
   if (cliArguments.checkOnly == true) {
-    const exitCode = await runConnectionCheck(instance.profile);
+    const exitCode = await runCheckCommand(instance.profile);
     instance.shutdown();
     process.exit(exitCode);
   }