@yawlabs/ssh-mcp 0.7.0 → 0.9.0

package/dist/index.js

@@ -3,15 +3,14 @@
 // src/index.ts
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
-// src/ssh.ts
-import { readFileSync as readFileSync2 } from "fs";
+// src/env.ts
+import { appendFileSync, existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, statSync } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join2 } from "path";
-import { Client } from "ssh2";
 
 // src/diagnose.ts
 import { execFileSync } from "child_process";
-import { existsSync, readFileSync, readdirSync } from "fs";
+import { existsSync, readdirSync, readFileSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
 function isValidHostname(host) {
@@ -19,7 +18,7 @@ function isValidHostname(host) {
   if (host.startsWith("[")) {
     return /^\[[0-9a-fA-F:]+\]$/.test(host);
   }
-  return /^[a-zA-Z0-9._\-]+$/.test(host);
+  return /^[a-zA-Z0-9._-]+$/.test(host);
 }
 function runArgs(cmd, args) {
   try {
@@ -260,714 +259,831 @@ function diagnose(host, port = 22) {
   return { overall, checks, suggestions };
 }
 
-// src/ssh.ts
-function resolveFromSshConfig(host) {
+// src/env.ts
+function probeAgent(socket, agentLabel) {
+  const { stdout, ok } = runArgs("ssh-add", ["-l"]);
+  const noIdentities = stdout.includes("no identities") || stdout.includes("The agent has no identities");
+  if (!ok && !noIdentities) return null;
+  const keys = ok && !noIdentities ? stdout.split("\n").filter(Boolean) : [];
+  return {
+    running: true,
+    reachable: true,
+    socket,
+    keys,
+    started: false,
+    message: keys.length > 0 ? `${agentLabel} running with ${keys.length} key(s) loaded` : `${agentLabel} running but no keys loaded. Use ssh_key_load to add one.`
+  };
+}
+var startedAgentPid = null;
+function killStartedAgent() {
+  if (startedAgentPid === null) return;
   try {
-    const { stdout, ok } = runArgs("ssh", ["-G", host]);
-    if (!ok) return null;
-    const config = {};
-    const identityFiles = [];
-    for (const line of stdout.split("\n")) {
-      const spaceIdx = line.indexOf(" ");
-      if (spaceIdx > 0) {
-        const key = line.substring(0, spaceIdx);
-        const value = line.substring(spaceIdx + 1);
-        if (key === "identityfile") {
-          identityFiles.push(value);
-        } else {
-          config[key] = value;
-        }
+    process.kill(startedAgentPid);
+  } catch {
+  }
+  startedAgentPid = null;
+}
+function ensureAgent() {
+  const sock = process.env.SSH_AUTH_SOCK;
+  if (sock) {
+    const result = probeAgent(sock, "ssh-agent");
+    if (result) return result;
+  }
+  if (!sock && process.platform === "win32") {
+    const result = probeAgent("\\\\.\\pipe\\openssh-ssh-agent", "Windows OpenSSH agent");
+    if (result) return result;
+  }
+  const { stdout, ok } = runArgs("ssh-agent", ["-s"]);
+  if (ok) {
+    const sockMatch = stdout.match(/SSH_AUTH_SOCK=([^;]+)/);
+    const pidMatch = stdout.match(/SSH_AGENT_PID=([^;]+)/);
+    if (sockMatch) {
+      process.env.SSH_AUTH_SOCK = sockMatch[1];
+      if (pidMatch) {
+        process.env.SSH_AGENT_PID = pidMatch[1];
+        startedAgentPid = Number.parseInt(pidMatch[1], 10);
       }
+      return {
+        running: true,
+        reachable: true,
+        socket: sockMatch[1],
+        keys: [],
+        started: true,
+        env: { SSH_AUTH_SOCK: sockMatch[1], SSH_AGENT_PID: pidMatch?.[1] },
+        message: "Started new ssh-agent scoped to the ssh-mcp server process. Your shell's environment is NOT modified \u2014 this agent is only visible to this MCP server and will terminate when the server exits. No keys loaded yet \u2014 use ssh_key_load to add one."
+      };
     }
-    return {
-      hostname: config.hostname || host,
-      user: config.user || "",
-      port: config.port || "22",
-      identityFiles,
-      proxyJump: config.proxyjump && config.proxyjump !== "none" ? config.proxyjump : void 0
-    };
+  }
+  return {
+    running: false,
+    reachable: false,
+    keys: [],
+    started: false,
+    message: process.platform === "win32" ? "Windows OpenSSH agent not running. Start it: Get-Service ssh-agent | Set-Service -StartupType Automatic; Start-Service ssh-agent" : 'Could not start ssh-agent. Run manually: eval "$(ssh-agent -s)"'
+  };
+}
+function detectKeyType(filePath, fileName) {
+  const pubPath = `${filePath}.pub`;
+  if (existsSync2(pubPath)) {
+    try {
+      const pub = readFileSync2(pubPath, "utf8");
+      if (pub.includes("ssh-ed25519")) return "ed25519";
+      if (pub.includes("ssh-rsa")) return "rsa";
+      if (pub.includes("ecdsa")) return "ecdsa";
+      if (pub.includes("ssh-dss")) return "dsa";
+    } catch {
+    }
+  }
+  if (fileName.includes("ed25519")) return "ed25519";
+  if (fileName.includes("rsa")) return "rsa";
+  if (fileName.includes("ecdsa")) return "ecdsa";
+  if (fileName.includes("dsa")) return "dsa";
+  try {
+    const content = readFileSync2(filePath, "utf8");
+    if (content.includes("RSA PRIVATE KEY")) return "rsa";
+    if (content.includes("EC PRIVATE KEY")) return "ecdsa";
+    if (content.includes("DSA PRIVATE KEY")) return "dsa";
   } catch {
-    return null;
   }
+  return "unknown";
 }
-function readKnownHostsKeys(host, port) {
-  if (!isValidHostname(host)) return [];
-  const targets = port && port !== 22 ? [`[${host}]:${port}`, host] : [host];
+function listSshKeys() {
+  const sshDir = join2(homedir2(), ".ssh");
+  if (!existsSync2(sshDir)) return [];
+  const loadedFingerprints = /* @__PURE__ */ new Set();
+  const { stdout: agentOut, ok: agentOk } = runArgs("ssh-add", ["-l"]);
+  if (agentOk && !agentOut.includes("no identities")) {
+    for (const line of agentOut.split("\n").filter(Boolean)) {
+      const match = line.match(/(\S+:\S+)/);
+      if (match) loadedFingerprints.add(match[1]);
+    }
+  }
+  const skipFiles = /* @__PURE__ */ new Set(["known_hosts", "known_hosts.old", "config", "authorized_keys", "environment"]);
   const keys = [];
-  for (const target of targets) {
-    const { stdout, ok } = runArgs("ssh-keygen", ["-F", target]);
-    if (!ok || !stdout.trim()) continue;
-    for (const line of stdout.split("\n")) {
-      const trimmed = line.trim();
-      if (!trimmed || trimmed.startsWith("#")) continue;
-      const parts = trimmed.split(/\s+/);
-      if (parts.length < 3) continue;
-      try {
-        keys.push(Buffer.from(parts[2], "base64"));
-      } catch {
+  let files;
+  try {
+    files = readdirSync2(sshDir);
+  } catch {
+    return [];
+  }
+  for (const file of files) {
+    if (file.endsWith(".pub") || file.startsWith(".") || skipFiles.has(file)) continue;
+    const filePath = join2(sshDir, file);
+    try {
+      const stat = statSync(filePath);
+      if (!stat.isFile()) continue;
+      const content = readFileSync2(filePath, "utf8");
+      if (!content.includes("PRIVATE KEY")) continue;
+      const type = detectKeyType(filePath, file);
+      let fingerprint;
+      const { stdout: fpOut, ok: fpOk } = runArgs("ssh-keygen", ["-lf", filePath]);
+      if (fpOk) {
+        const match = fpOut.match(/(\S+:\S+)/);
+        fingerprint = match?.[1];
       }
+      const loadedInAgent = fingerprint ? loadedFingerprints.has(fingerprint) : false;
+      keys.push({ name: file, path: filePath, type, fingerprint, loadedInAgent });
+    } catch {
     }
   }
   return keys;
 }
-function buildHostVerifier(hosts, port) {
-  const strict = process.env.SSH_MCP_STRICT_HOST_KEY === "1";
-  return (key) => {
-    const known = hosts.flatMap((h) => readKnownHostsKeys(h, port));
-    if (known.length === 0) {
-      return !strict;
-    }
-    return known.some((k) => k.equals(key));
-  };
-}
-function resolveConfig(config) {
-  const sshConfig = resolveFromSshConfig(config.host);
-  const port = config.port || (sshConfig ? Number.parseInt(sshConfig.port, 10) : 22);
-  const verifierHosts = [config.host];
-  if (sshConfig?.hostname && sshConfig.hostname !== config.host) {
-    verifierHosts.push(sshConfig.hostname);
+function loadKey(keyPath) {
+  const agent = ensureAgent();
+  if (!agent.reachable) {
+    return { status: "error", message: agent.message };
   }
-  const connectConfig = {
-    host: sshConfig?.hostname || config.host,
-    port,
-    username: config.username || sshConfig?.user || process.env.USER || process.env.USERNAME || "root",
-    keepaliveInterval: 15e3,
-    keepaliveCountMax: 3,
-    hostVerifier: buildHostVerifier(verifierHosts, port)
-  };
-  const agentSock = config.agent || process.env.SSH_AUTH_SOCK || (process.platform === "win32" ? "\\\\.\\pipe\\openssh-ssh-agent" : void 0);
-  if (agentSock) {
-    connectConfig.agent = agentSock;
+  const resolved = keyPath.startsWith("~") ? join2(homedir2(), keyPath.slice(1)) : keyPath;
+  if (!existsSync2(resolved)) {
+    return { status: "error", message: `Key not found: ${resolved}` };
   }
-  if (config.password) {
-    connectConfig.password = config.password;
+  const { stdout, ok } = runArgs("ssh-add", [resolved]);
+  if (ok) {
+    return { status: "ok", message: `Key loaded: ${resolved}` };
   }
-  if (config.privateKeyPath) {
-    connectConfig.privateKey = readFileSync2(config.privateKeyPath);
-  } else if (!agentSock) {
-    const home = homedir2();
-    const keyPaths = sshConfig && sshConfig.identityFiles.length > 0 ? sshConfig.identityFiles.map((p) => p.startsWith("~") ? join2(home, p.slice(1)) : p) : [join2(home, ".ssh", "id_ed25519"), join2(home, ".ssh", "id_rsa"), join2(home, ".ssh", "id_ecdsa")];
-    for (const keyPath of keyPaths) {
-      try {
-        connectConfig.privateKey = readFileSync2(keyPath);
-        break;
-      } catch {
-      }
+  if (stdout.includes("passphrase") || stdout.includes("incorrect") || stdout.includes("bad permissions")) {
+    if (stdout.includes("UNPROTECTED PRIVATE KEY")) {
+      return { status: "error", message: `Key ${resolved} has too-open permissions. Fix: chmod 600 ${resolved}` };
     }
+    return { status: "error", message: `Key ${resolved} requires a passphrase. Add it manually: ssh-add ${resolved}` };
   }
-  return { connectConfig, proxyJump: sshConfig?.proxyJump };
+  return { status: "error", message: `Failed to load key: ${stdout}` };
 }
-function formatDiagnostics(host) {
-  try {
-    const checks = [
-      { name: "SSH Agent", ...checkSshAgent() },
-      { name: "SSH Keys", ...checkSshKeys() },
-      { name: "SSH Config", ...checkSshConfig(host) },
-      { name: "Known Hosts", ...checkKnownHosts(host) }
-    ];
-    const parts = [];
-    const suggestions = [];
-    for (const check of checks) {
-      if (check.status !== "ok") {
-        parts.push(`[${check.status.toUpperCase()}] ${check.name}: ${check.message}`);
+function configLookup(host) {
+  if (!isValidHostname(host)) {
+    return { error: `Invalid hostname: "${host}"` };
+  }
+  const { stdout, ok } = runArgs("ssh", ["-G", host]);
+  if (!ok) {
+    return { error: `Failed to resolve SSH config for ${host}: ${stdout}` };
+  }
+  const all = {};
+  const identityFiles = [];
+  for (const line of stdout.split("\n")) {
+    const spaceIdx = line.indexOf(" ");
+    if (spaceIdx > 0) {
+      const key = line.substring(0, spaceIdx);
+      const value = line.substring(spaceIdx + 1);
+      if (key === "identityfile") {
+        identityFiles.push(value);
+      } else {
+        all[key] = value;
       }
     }
-    const agent = checks[0];
-    if (agent.status === "error") suggestions.push('Start ssh-agent: eval "$(ssh-agent -s)"');
-    if (agent.status === "warning") suggestions.push("Load a key: ssh-add ~/.ssh/id_ed25519");
-    const keys = checks[1];
-    if (keys.status === "error") suggestions.push('Generate a key: ssh-keygen -t ed25519 -C "your@email.com"');
-    const known = checks[3];
-    if (known.status === "warning") suggestions.push(`Add host key: ssh-keyscan -H "${host}" >> ~/.ssh/known_hosts`);
-    if (suggestions.length > 0) {
-      parts.push(`Suggested fixes: ${suggestions.join(" | ")}`);
-    }
-    return parts.length > 0 ? parts.join("\n") : "";
-  } catch {
-    return "";
   }
+  return {
+    hostname: all.hostname || host,
+    user: all.user || "",
+    port: all.port || "22",
+    identityFile: identityFiles,
+    proxyJump: all.proxyjump && all.proxyjump !== "none" ? all.proxyjump : void 0,
+    proxyCommand: all.proxycommand && all.proxycommand !== "none" ? all.proxycommand : void 0,
+    all,
+    raw: stdout
+  };
 }
-function connectRaw(connectConfig) {
-  return new Promise((resolve, reject) => {
-    const client = new Client();
-    client.on("ready", () => resolve(client)).on("error", (err) => reject(err)).connect(connectConfig);
-  });
-}
-async function connectWithProxy(resolved) {
-  if (!resolved.proxyJump) {
-    return connectRaw(resolved.connectConfig);
+function fixKnownHosts(host, port = 22) {
+  if (!isValidHostname(host)) {
+    return { status: "error", message: `Invalid hostname: "${host}"`, actions: [] };
   }
-  const jumpResolved = resolveConfig({ host: resolved.proxyJump });
-  const jumpClient = await connectWithProxy(jumpResolved);
-  const targetHost = resolved.connectConfig.host;
-  const targetPort = resolved.connectConfig.port;
-  const stream = await new Promise((resolve, reject) => {
-    jumpClient.forwardOut("127.0.0.1", 0, targetHost, targetPort, (err, stream2) => {
-      if (err) {
-        jumpClient.end();
-        return reject(err);
-      }
-      resolve(stream2);
-    });
-  });
-  return new Promise((resolve, reject) => {
-    const client = new Client();
-    client.on("ready", () => resolve(client)).on("error", (err) => {
-      jumpClient.end();
-      reject(err);
-    }).on("close", () => {
-      jumpClient.end();
-    }).connect({ ...resolved.connectConfig, sock: stream });
-  });
-}
-function exec(client, command, timeoutMs = 3e4) {
-  return new Promise((resolve, reject) => {
-    let settled = false;
-    const settle = (fn) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      fn();
-    };
-    const timer = setTimeout(() => {
-      settle(() => reject(new Error(`Command timed out after ${timeoutMs}ms`)));
-    }, timeoutMs);
-    client.exec(command, (err, stream) => {
-      if (err) {
-        settle(() => reject(err));
-        return;
-      }
-      let stdout = "";
-      let stderr = "";
-      stream.on("close", (code) => {
-        settle(() => resolve({ stdout, stderr, code: code ?? 0 }));
-      }).on("data", (data) => {
-        stdout += data.toString();
-      }).on("error", (err2) => {
-        settle(() => reject(err2));
-      });
-      stream.stderr.on("data", (data) => {
-        stderr += data.toString();
-      }).on("error", (err2) => {
-        settle(() => reject(err2));
-      });
-    });
-  });
-}
-function getSftp(client) {
-  return new Promise((resolve, reject) => {
-    client.sftp((err, sftp) => {
-      if (err) return reject(err);
-      resolve(sftp);
-    });
-  });
-}
-var DEFAULT_MAX_READ_BYTES = 10 * 1024 * 1024;
-async function readFile(client, remotePath, maxBytes = DEFAULT_MAX_READ_BYTES) {
-  const sftp = await getSftp(client);
-  try {
-    const stats = await new Promise((resolve, reject) => {
-      sftp.stat(remotePath, (err, stats2) => {
-        if (err) return reject(err);
-        resolve(stats2);
-      });
-    });
-    if (stats.size > maxBytes) {
-      throw new Error(
-        `File is ${(stats.size / 1024 / 1024).toFixed(1)} MB, exceeds ${(maxBytes / 1024 / 1024).toFixed(0)} MB limit. Use ssh_exec with head/tail to read a portion.`
-      );
+  const actions = [];
+  const { ok: removeOk } = runArgs("ssh-keygen", ["-R", host]);
+  if (removeOk) {
+    actions.push(`Removed old host key for ${host}`);
+  }
+  if (port !== 22) {
+    const { ok } = runArgs("ssh-keygen", ["-R", `[${host}]:${port}`]);
+    if (ok) actions.push(`Removed old host key for [${host}]:${port}`);
+  }
+  const scanArgs = port !== 22 ? ["-H", "-p", String(port), host] : ["-H", host];
+  const { stdout: scanOut, ok: scanOk } = runArgs("ssh-keyscan", scanArgs);
+  if (scanOk && scanOut.trim()) {
+    try {
+      const knownHostsPath = join2(homedir2(), ".ssh", "known_hosts");
+      appendFileSync(knownHostsPath, `
+${scanOut.trim()}
+`);
+      actions.push(`Added new host key for ${host}`);
+      return { status: "ok", message: `Host key refreshed for ${host}`, actions };
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      return { status: "error", message: `Scanned key but failed to write known_hosts: ${msg}`, actions };
     }
-    return await new Promise((resolve, reject) => {
-      sftp.readFile(remotePath, (err, data) => {
-        if (err) return reject(err);
-        resolve(data.toString("utf8"));
-      });
-    });
-  } finally {
-    sftp.end();
   }
+  return { status: "error", message: `Could not scan host key for ${host}. Host may be unreachable.`, actions };
 }
-async function writeFile(client, remotePath, content) {
-  const sftp = await getSftp(client);
-  try {
-    await new Promise((resolve, reject) => {
-      sftp.writeFile(remotePath, content, (err) => {
-        if (err) return reject(err);
-        resolve();
-      });
-    });
-  } finally {
-    sftp.end();
+function checkGitSsh(host = "github.com", user = "git") {
+  if (!isValidHostname(host)) {
+    return { status: "error", message: `Invalid hostname: "${host}"` };
   }
-}
-async function uploadFile(client, localPath, remotePath) {
-  const sftp = await getSftp(client);
-  try {
-    await new Promise((resolve, reject) => {
-      sftp.fastPut(localPath, remotePath, (err) => {
-        if (err) return reject(err);
-        resolve();
-      });
-    });
-  } finally {
-    sftp.end();
+  const { stdout } = runArgs("ssh", ["-T", "-o", "ConnectTimeout=5", "-o", "BatchMode=yes", `${user}@${host}`]);
+  const text = stdout;
+  if (text.includes("successfully authenticated") || text.includes("Welcome to GitLab") || text.includes("logged in as")) {
+    const userMatch = text.match(/Hi (\S+)!/) || text.match(/@(\S+)!/) || text.match(/logged in as (\S+)/);
+    return {
+      status: "ok",
+      message: `Git SSH authentication to ${host} succeeded${userMatch ? ` as ${userMatch[1]}` : ""}`,
+      authenticatedAs: userMatch?.[1]
+    };
   }
-}
-async function downloadFile(client, remotePath, localPath) {
-  const sftp = await getSftp(client);
-  try {
-    await new Promise((resolve, reject) => {
-      sftp.fastGet(remotePath, localPath, (err) => {
-        if (err) return reject(err);
-        resolve();
-      });
-    });
-  } finally {
-    sftp.end();
+  if (text.includes("Permission denied")) {
+    return {
+      status: "error",
+      message: `Permission denied for ${host}. Either no key is loaded in the agent or your key isn't registered with ${host}. Run ssh_key_list to check, then ssh_key_load if needed.`
+    };
   }
-}
-async function listDir(client, remotePath) {
-  const sftp = await getSftp(client);
-  try {
-    return await new Promise((resolve, reject) => {
-      sftp.readdir(remotePath, (err, list) => {
-        if (err) return reject(err);
-        resolve(list.map((item) => item.filename));
-      });
-    });
-  } finally {
-    sftp.end();
+  if (text.includes("Connection refused")) {
+    return { status: "error", message: `Connection refused by ${host}. SSH may not be available on this host.` };
   }
+  if (text.includes("timed out") || text.includes("Connection timed out")) {
+    return { status: "error", message: `Connection to ${host} timed out. Check your network or firewall.` };
+  }
+  if (text.includes("Could not resolve")) {
+    return { status: "error", message: `Could not resolve hostname "${host}". Check DNS or spelling.` };
+  }
+  return { status: "error", message: `Git SSH check for ${host}: ${text || "no response (agent may not be running)"}` };
 }
-
-// src/pool.ts
-var ConnectionPool = class {
-  entries = /* @__PURE__ */ new Map();
-  idleTtlMs;
-  maxPoolSize;
-  constructor(options) {
-    this.idleTtlMs = options?.idleTtlMs ?? 6e4;
-    this.maxPoolSize = options?.maxPoolSize ?? 100;
+function testConnection(host, port = 22) {
+  if (!isValidHostname(host)) {
+    return { status: "error", message: `Invalid hostname: "${host}"` };
   }
-  async acquire(config) {
-    const resolved = resolveConfig(config);
-    const cc = resolved.connectConfig;
-    const key = `${cc.username}@${cc.host}:${cc.port}`;
-    const existing = this.entries.get(key);
-    if (existing && !existing.dead) {
-      existing.refCount++;
-      if (existing.idleTimer) {
-        clearTimeout(existing.idleTimer);
-        existing.idleTimer = null;
-      }
-      return existing.client;
-    }
-    if (existing?.dead) {
-      this.entries.delete(key);
-    }
-    if (this.entries.size >= this.maxPoolSize) {
-      let evicted = false;
-      for (const [k, e] of this.entries) {
-        if (e.refCount === 0) {
-          if (e.idleTimer) clearTimeout(e.idleTimer);
-          try {
-            e.client.end();
-          } catch {
-          }
-          this.entries.delete(k);
-          evicted = true;
-          break;
-        }
-      }
-      if (!evicted) {
-        throw new Error(`Connection pool is full (${this.maxPoolSize} active connections)`);
-      }
-    }
-    try {
-      const client = await connectWithProxy(resolved);
-      const entry = { client, key, refCount: 1, idleTimer: null, dead: false };
-      const markDead = () => {
-        entry.dead = true;
-        if (entry.idleTimer) {
-          clearTimeout(entry.idleTimer);
-          entry.idleTimer = null;
-        }
-        if (this.entries.get(key) === entry) {
-          this.entries.delete(key);
-        }
-      };
-      client.on("close", markDead);
-      client.on("end", markDead);
-      client.on("error", markDead);
-      this.entries.set(key, entry);
-      return client;
-    } catch (err) {
-      const diag = formatDiagnostics(config.host);
-      if (diag) {
-        const message = err instanceof Error ? err.message : String(err);
-        const enhanced = new Error(`${message}
-
-SSH Diagnostics:
-${diag}`);
-        enhanced.cause = err;
-        throw enhanced;
-      }
-      throw err;
-    }
+  const start = Date.now();
+  const { ok, stdout } = runArgs("ssh", [
+    "-o",
+    "ConnectTimeout=5",
+    "-o",
+    "BatchMode=yes",
+    "-o",
+    "StrictHostKeyChecking=no",
+    "-p",
+    String(port),
+    host,
+    "echo",
+    "SSH_OK"
+  ]);
+  const elapsed = Date.now() - start;
+  if (ok && stdout.includes("SSH_OK")) {
+    return { status: "ok", message: `Connected to ${host}:${port} in ${elapsed}ms` };
   }
-  release(client) {
-    for (const entry of this.entries.values()) {
-      if (entry.client === client) {
-        entry.refCount = Math.max(0, entry.refCount - 1);
-        if (entry.refCount === 0 && !entry.dead) {
-          entry.idleTimer = setTimeout(() => {
-            try {
-              entry.client.end();
-            } catch {
-            }
-            this.entries.delete(entry.key);
-          }, this.idleTtlMs);
-          entry.idleTimer.unref();
-        }
-        return;
-      }
-    }
-    try {
-      client.end();
-    } catch {
-    }
+  if (stdout.includes("Permission denied")) {
+    return {
+      status: "error",
+      message: `Authentication failed to ${host}:${port} (${elapsed}ms). Key not authorized. Check: ssh-add -l, verify correct username, verify key is in remote authorized_keys.`
+    };
   }
-  async withConnection(config, fn) {
-    const client = await this.acquire(config);
-    try {
-      return await fn(client);
-    } finally {
-      this.release(client);
-    }
+  if (stdout.includes("Connection refused")) {
+    return {
+      status: "error",
+      message: `Connection refused at ${host}:${port}. SSH server not running or port blocked.`
+    };
   }
-  drain() {
-    for (const entry of this.entries.values()) {
-      if (entry.idleTimer) {
-        clearTimeout(entry.idleTimer);
-      }
-      try {
-        entry.client.end();
-      } catch {
-      }
-    }
-    this.entries.clear();
+  if (stdout.includes("timed out")) {
+    return { status: "error", message: `Connection timed out to ${host}:${port}. Host down or firewall blocking.` };
   }
-  get size() {
-    return this.entries.size;
+  if (stdout.includes("Host key verification failed")) {
+    return {
+      status: "error",
+      message: `Host key mismatch for ${host}. Instance was likely recreated. Fix with ssh_known_hosts_fix.`
+    };
   }
-  get stats() {
-    let active = 0;
-    let idle = 0;
-    for (const entry of this.entries.values()) {
-      if (entry.refCount > 0) active++;
-      else idle++;
-    }
-    return { active, idle };
+  if (stdout.includes("Could not resolve")) {
+    return { status: "error", message: `Could not resolve "${host}". Check DNS, /etc/hosts, or SSH config.` };
   }
-};
-
-// src/server.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-
-// src/tools.ts
-import { z } from "zod";
+  return { status: "error", message: `Connection failed to ${host}:${port}: ${stdout}` };
+}
 
-// src/env.ts
-import { appendFileSync, existsSync as existsSync2, readFileSync as readFileSync3, readdirSync as readdirSync2, statSync } from "fs";
+// src/ssh.ts
+import { readFileSync as readFileSync3 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join3 } from "path";
-function ensureAgent() {
-  const sock = process.env.SSH_AUTH_SOCK;
-  if (sock) {
-    const { stdout: stdout2, ok: ok2 } = runArgs("ssh-add", ["-l"]);
-    const noIdentities = stdout2.includes("no identities") || stdout2.includes("The agent has no identities");
-    if (ok2 || noIdentities) {
-      const keys = ok2 && !noIdentities ? stdout2.split("\n").filter(Boolean) : [];
-      return {
-        running: true,
-        reachable: true,
-        socket: sock,
-        keys,
-        started: false,
-        message: keys.length > 0 ? `ssh-agent running with ${keys.length} key(s) loaded` : "ssh-agent running but no keys loaded. Use ssh_key_load to add one."
-      };
-    }
-  }
-  if (!sock && process.platform === "win32") {
-    const { stdout: stdout2, ok: ok2 } = runArgs("ssh-add", ["-l"]);
-    const noIdentities = stdout2.includes("no identities") || stdout2.includes("The agent has no identities");
-    if (ok2 || noIdentities) {
-      const keys = ok2 && !noIdentities ? stdout2.split("\n").filter(Boolean) : [];
-      return {
-        running: true,
-        reachable: true,
-        socket: "\\\\.\\pipe\\openssh-ssh-agent",
-        keys,
-        started: false,
-        message: keys.length > 0 ? `Windows OpenSSH agent running with ${keys.length} key(s) loaded` : "Windows OpenSSH agent running but no keys loaded. Use ssh_key_load to add one."
-      };
-    }
-  }
-  const { stdout, ok } = runArgs("ssh-agent", ["-s"]);
-  if (ok) {
-    const sockMatch = stdout.match(/SSH_AUTH_SOCK=([^;]+)/);
-    const pidMatch = stdout.match(/SSH_AGENT_PID=([^;]+)/);
-    if (sockMatch) {
-      process.env.SSH_AUTH_SOCK = sockMatch[1];
-      if (pidMatch) process.env.SSH_AGENT_PID = pidMatch[1];
-      return {
-        running: true,
-        reachable: true,
-        socket: sockMatch[1],
-        keys: [],
-        started: true,
-        env: { SSH_AUTH_SOCK: sockMatch[1], SSH_AGENT_PID: pidMatch?.[1] },
-        message: "Started new ssh-agent. No keys loaded yet \u2014 use ssh_key_load to add one."
-      };
-    }
-  }
-  return {
-    running: false,
-    reachable: false,
-    keys: [],
-    started: false,
-    message: process.platform === "win32" ? "Windows OpenSSH agent not running. Start it: Get-Service ssh-agent | Set-Service -StartupType Automatic; Start-Service ssh-agent" : 'Could not start ssh-agent. Run manually: eval "$(ssh-agent -s)"'
-  };
-}
-function detectKeyType(filePath, fileName) {
-  const pubPath = `${filePath}.pub`;
-  if (existsSync2(pubPath)) {
-    try {
-      const pub = readFileSync3(pubPath, "utf8");
-      if (pub.includes("ssh-ed25519")) return "ed25519";
-      if (pub.includes("ssh-rsa")) return "rsa";
-      if (pub.includes("ecdsa")) return "ecdsa";
-      if (pub.includes("ssh-dss")) return "dsa";
-    } catch {
+import { Client } from "ssh2";
+function resolveFromSshConfig(host) {
+  try {
+    const { stdout, ok } = runArgs("ssh", ["-G", host]);
+    if (!ok) return null;
+    const config = {};
+    const identityFiles = [];
+    for (const line of stdout.split("\n")) {
+      const spaceIdx = line.indexOf(" ");
+      if (spaceIdx > 0) {
+        const key = line.substring(0, spaceIdx);
+        const value = line.substring(spaceIdx + 1);
+        if (key === "identityfile") {
+          identityFiles.push(value);
+        } else {
+          config[key] = value;
+        }
+      }
     }
-  }
-  if (fileName.includes("ed25519")) return "ed25519";
-  if (fileName.includes("rsa")) return "rsa";
-  if (fileName.includes("ecdsa")) return "ecdsa";
-  if (fileName.includes("dsa")) return "dsa";
-  try {
-    const content = readFileSync3(filePath, "utf8");
-    if (content.includes("RSA PRIVATE KEY")) return "rsa";
-    if (content.includes("EC PRIVATE KEY")) return "ecdsa";
-    if (content.includes("DSA PRIVATE KEY")) return "dsa";
+    return {
+      hostname: config.hostname || host,
+      user: config.user || "",
+      port: config.port || "22",
+      identityFiles,
+      proxyJump: config.proxyjump && config.proxyjump !== "none" ? config.proxyjump : void 0
+    };
   } catch {
+    return null;
   }
-  return "unknown";
 }
-function listSshKeys() {
-  const sshDir = join3(homedir3(), ".ssh");
-  if (!existsSync2(sshDir)) return [];
-  const loadedFingerprints = /* @__PURE__ */ new Set();
-  const { stdout: agentOut, ok: agentOk } = runArgs("ssh-add", ["-l"]);
-  if (agentOk && !agentOut.includes("no identities")) {
-    for (const line of agentOut.split("\n").filter(Boolean)) {
-      const match = line.match(/(\S+:\S+)/);
-      if (match) loadedFingerprints.add(match[1]);
-    }
-  }
-  const skipFiles = /* @__PURE__ */ new Set(["known_hosts", "known_hosts.old", "config", "authorized_keys", "environment"]);
+function readKnownHostsKeys(host, port) {
+  if (!isValidHostname(host)) return [];
+  const targets = port && port !== 22 ? [`[${host}]:${port}`, host] : [host];
   const keys = [];
-  let files;
-  try {
-    files = readdirSync2(sshDir);
-  } catch {
-    return [];
-  }
-  for (const file of files) {
-    if (file.endsWith(".pub") || file.startsWith(".") || skipFiles.has(file)) continue;
-    const filePath = join3(sshDir, file);
-    try {
-      const stat = statSync(filePath);
-      if (!stat.isFile()) continue;
-      const content = readFileSync3(filePath, "utf8");
-      if (!content.includes("PRIVATE KEY")) continue;
-      const type = detectKeyType(filePath, file);
-      let fingerprint;
-      const { stdout: fpOut, ok: fpOk } = runArgs("ssh-keygen", ["-lf", filePath]);
-      if (fpOk) {
-        const match = fpOut.match(/(\S+:\S+)/);
-        fingerprint = match?.[1];
+  for (const target of targets) {
+    const { stdout, ok } = runArgs("ssh-keygen", ["-F", target]);
+    if (!ok || !stdout.trim()) continue;
+    for (const line of stdout.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const parts = trimmed.split(/\s+/);
+      if (parts.length < 3) continue;
+      try {
+        keys.push(Buffer.from(parts[2], "base64"));
+      } catch {
       }
-      const loadedInAgent = fingerprint ? loadedFingerprints.has(fingerprint) : false;
-      keys.push({ name: file, path: filePath, type, fingerprint, loadedInAgent });
-    } catch {
     }
   }
   return keys;
 }
-function loadKey(keyPath) {
-  const agent = ensureAgent();
-  if (!agent.reachable) {
-    return { status: "error", message: agent.message };
-  }
-  const resolved = keyPath.startsWith("~") ? join3(homedir3(), keyPath.slice(1)) : keyPath;
-  if (!existsSync2(resolved)) {
-    return { status: "error", message: `Key not found: ${resolved}` };
-  }
-  const { stdout, ok } = runArgs("ssh-add", [resolved]);
-  if (ok) {
-    return { status: "ok", message: `Key loaded: ${resolved}` };
+function buildHostVerifier(hosts, port) {
+  const strict = process.env.SSH_MCP_STRICT_HOST_KEY === "1";
+  return (key) => {
+    const known = hosts.flatMap((h) => readKnownHostsKeys(h, port));
+    if (known.length === 0) {
+      return !strict;
+    }
+    return known.some((k) => k.equals(key));
+  };
+}
+function resolveConfig(config) {
+  const sshConfig = resolveFromSshConfig(config.host);
+  const port = config.port || (sshConfig ? Number.parseInt(sshConfig.port, 10) : 22);
+  const verifierHosts = [config.host];
+  if (sshConfig?.hostname && sshConfig.hostname !== config.host) {
+    verifierHosts.push(sshConfig.hostname);
   }
-  if (stdout.includes("passphrase") || stdout.includes("incorrect") || stdout.includes("bad permissions")) {
-    if (stdout.includes("UNPROTECTED PRIVATE KEY")) {
-      return { status: "error", message: `Key ${resolved} has too-open permissions. Fix: chmod 600 ${resolved}` };
+  const connectConfig = {
+    host: sshConfig?.hostname || config.host,
+    port,
+    username: config.username || sshConfig?.user || process.env.USER || process.env.USERNAME || "root",
+    keepaliveInterval: 15e3,
+    keepaliveCountMax: 3,
+    hostVerifier: buildHostVerifier(verifierHosts, port)
+  };
+  if (config.privateKeyPath) {
+    connectConfig.privateKey = readFileSync3(config.privateKeyPath);
+  } else if (config.password) {
+    connectConfig.password = config.password;
+  } else {
+    const agentSock = config.agent || process.env.SSH_AUTH_SOCK || (process.platform === "win32" ? "\\\\.\\pipe\\openssh-ssh-agent" : void 0);
+    if (agentSock) {
+      connectConfig.agent = agentSock;
+    } else {
+      const home = homedir3();
+      const keyPaths = sshConfig && sshConfig.identityFiles.length > 0 ? sshConfig.identityFiles.map((p) => p.startsWith("~") ? join3(home, p.slice(1)) : p) : [join3(home, ".ssh", "id_ed25519"), join3(home, ".ssh", "id_rsa"), join3(home, ".ssh", "id_ecdsa")];
+      for (const keyPath of keyPaths) {
+        try {
+          connectConfig.privateKey = readFileSync3(keyPath);
+          break;
+        } catch {
+        }
+      }
     }
-    return { status: "error", message: `Key ${resolved} requires a passphrase. Add it manually: ssh-add ${resolved}` };
   }
-  return { status: "error", message: `Failed to load key: ${stdout}` };
+  return { connectConfig, proxyJump: sshConfig?.proxyJump };
 }
-function configLookup(host) {
-  if (!isValidHostname(host)) {
-    return { error: `Invalid hostname: "${host}"` };
+var DIAG_CACHE_TTL_MS = 2e3;
+var diagAgentCache = null;
+var diagKeysCache = null;
+function cachedAgentCheck() {
+  const now = Date.now();
+  if (diagAgentCache && now - diagAgentCache.at < DIAG_CACHE_TTL_MS) {
+    return diagAgentCache.result;
+  }
+  const result = checkSshAgent();
+  diagAgentCache = { at: now, result };
+  return result;
+}
+function cachedKeysCheck() {
+  const now = Date.now();
+  if (diagKeysCache && now - diagKeysCache.at < DIAG_CACHE_TTL_MS) {
+    return diagKeysCache.result;
+  }
+  const result = checkSshKeys();
+  diagKeysCache = { at: now, result };
+  return result;
+}
+function formatDiagnostics(host) {
+  try {
+    const checks = [
+      { name: "SSH Agent", ...cachedAgentCheck() },
+      { name: "SSH Keys", ...cachedKeysCheck() },
+      { name: "SSH Config", ...checkSshConfig(host) },
+      { name: "Known Hosts", ...checkKnownHosts(host) }
+    ];
+    const parts = [];
+    const suggestions = [];
+    for (const check of checks) {
+      if (check.status !== "ok") {
+        parts.push(`[${check.status.toUpperCase()}] ${check.name}: ${check.message}`);
+      }
+    }
+    const agent = checks[0];
+    if (agent.status === "error") suggestions.push('Start ssh-agent: eval "$(ssh-agent -s)"');
+    if (agent.status === "warning") suggestions.push("Load a key: ssh-add ~/.ssh/id_ed25519");
+    const keys = checks[1];
+    if (keys.status === "error") suggestions.push('Generate a key: ssh-keygen -t ed25519 -C "your@email.com"');
+    const known = checks[3];
+    if (known.status === "warning") suggestions.push(`Add host key: ssh-keyscan -H "${host}" >> ~/.ssh/known_hosts`);
+    if (suggestions.length > 0) {
+      parts.push(`Suggested fixes: ${suggestions.join(" | ")}`);
+    }
+    return parts.length > 0 ? parts.join("\n") : "";
+  } catch {
+    return "";
   }
-  const { stdout, ok } = runArgs("ssh", ["-G", host]);
-  if (!ok) {
-    return { error: `Failed to resolve SSH config for ${host}: ${stdout}` };
+}
+function connectRaw(connectConfig) {
+  return new Promise((resolve, reject) => {
+    const client = new Client();
+    client.on("ready", () => resolve(client)).on("error", (err) => reject(err)).connect(connectConfig);
+  });
+}
+async function connectWithProxy(resolved) {
+  if (!resolved.proxyJump) {
+    return connectRaw(resolved.connectConfig);
   }
-  const all = {};
-  const identityFiles = [];
-  for (const line of stdout.split("\n")) {
-    const spaceIdx = line.indexOf(" ");
-    if (spaceIdx > 0) {
-      const key = line.substring(0, spaceIdx);
-      const value = line.substring(spaceIdx + 1);
-      if (key === "identityfile") {
-        identityFiles.push(value);
-      } else {
-        all[key] = value;
+  const jumpResolved = resolveConfig({ host: resolved.proxyJump });
+  const jumpClient = await connectWithProxy(jumpResolved);
+  const targetHost = resolved.connectConfig.host;
+  const targetPort = resolved.connectConfig.port;
+  const stream = await new Promise((resolve, reject) => {
+    jumpClient.forwardOut("127.0.0.1", 0, targetHost, targetPort, (err, stream2) => {
+      if (err) {
+        jumpClient.end();
+        return reject(err);
+      }
+      resolve(stream2);
+    });
+  });
+  return new Promise((resolve, reject) => {
+    const client = new Client();
+    client.on("ready", () => resolve(client)).on("error", (err) => {
+      jumpClient.end();
+      reject(err);
+    }).on("close", () => {
+      jumpClient.end();
+    }).connect({ ...resolved.connectConfig, sock: stream });
+  });
+}
+var DEFAULT_MAX_EXEC_BYTES = 10 * 1024 * 1024;
+function exec(client, command, timeoutMs = 3e4, maxBytes = DEFAULT_MAX_EXEC_BYTES) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let activeStream = null;
+    const settle = (fn) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      fn();
+    };
+    const timer = setTimeout(() => {
+      if (activeStream) {
+        try {
+          activeStream.signal("TERM");
+        } catch {
+        }
+        try {
+          activeStream.close();
+        } catch {
+        }
+      }
+      settle(() => reject(new Error(`Command timed out after ${timeoutMs}ms`)));
+    }, timeoutMs);
+    client.exec(command, (err, stream) => {
+      if (err) {
+        settle(() => reject(err));
+        return;
       }
+      activeStream = stream;
+      const stdoutChunks = [];
+      const stderrChunks = [];
+      let stdoutBytes = 0;
+      let stderrBytes = 0;
+      let stdoutTruncated = false;
+      let stderrTruncated = false;
+      const appendStdout = (data) => {
+        if (stdoutTruncated) return;
+        const remaining = maxBytes - stdoutBytes;
+        if (data.length <= remaining) {
+          stdoutChunks.push(data);
+          stdoutBytes += data.length;
+        } else {
+          if (remaining > 0) {
+            stdoutChunks.push(data.subarray(0, remaining));
+            stdoutBytes += remaining;
+          }
+          stdoutTruncated = true;
+        }
+      };
+      const appendStderr = (data) => {
+        if (stderrTruncated) return;
+        const remaining = maxBytes - stderrBytes;
+        if (data.length <= remaining) {
+          stderrChunks.push(data);
+          stderrBytes += data.length;
+        } else {
+          if (remaining > 0) {
+            stderrChunks.push(data.subarray(0, remaining));
+            stderrBytes += remaining;
+          }
+          stderrTruncated = true;
+        }
+      };
+      stream.on("close", (code) => {
+        let stdout = Buffer.concat(stdoutChunks).toString("utf8");
+        let stderr = Buffer.concat(stderrChunks).toString("utf8");
+        if (stdoutTruncated) stdout += `
+[output truncated at ${maxBytes} bytes]`;
+        if (stderrTruncated) stderr += `
+[stderr truncated at ${maxBytes} bytes]`;
+        settle(() => resolve({ stdout, stderr, code: code ?? 0 }));
+      }).on("data", appendStdout).on("error", (err2) => {
+        settle(() => reject(err2));
+      });
+      stream.stderr.on("data", appendStderr).on("error", (err2) => {
+        settle(() => reject(err2));
+      });
+    });
+  });
+}
+function getSftp(client) {
+  return new Promise((resolve, reject) => {
+    client.sftp((err, sftp) => {
+      if (err) return reject(err);
+      resolve(sftp);
+    });
+  });
+}
+var DEFAULT_MAX_READ_BYTES = 10 * 1024 * 1024;
+async function readFile(client, remotePath, maxBytes = DEFAULT_MAX_READ_BYTES) {
+  const sftp = await getSftp(client);
+  try {
+    const stats = await new Promise((resolve, reject) => {
+      sftp.stat(remotePath, (err, stats2) => {
+        if (err) return reject(err);
+        resolve(stats2);
+      });
+    });
+    if (stats.size > maxBytes) {
+      throw new Error(
+        `File is ${(stats.size / 1024 / 1024).toFixed(1)} MB, exceeds ${(maxBytes / 1024 / 1024).toFixed(0)} MB limit. Use ssh_exec with head/tail to read a portion.`
+      );
     }
+    return await new Promise((resolve, reject) => {
+      sftp.readFile(remotePath, (err, data) => {
+        if (err) return reject(err);
+        resolve(data.toString("utf8"));
+      });
+    });
+  } finally {
+    sftp.end();
   }
-  return {
-    hostname: all.hostname || host,
-    user: all.user || "",
-    port: all.port || "22",
-    identityFile: identityFiles,
-    proxyJump: all.proxyjump !== "none" ? all.proxyjump : void 0,
-    proxyCommand: all.proxycommand !== "none" ? all.proxycommand : void 0,
-    all,
-    raw: stdout
-  };
 }
-function fixKnownHosts(host, port = 22) {
-  if (!isValidHostname(host)) {
-    return { status: "error", message: `Invalid hostname: "${host}"`, actions: [] };
-  }
-  const actions = [];
-  const { ok: removeOk } = runArgs("ssh-keygen", ["-R", host]);
-  if (removeOk) {
-    actions.push(`Removed old host key for ${host}`);
-  }
-  if (port !== 22) {
-    const { ok } = runArgs("ssh-keygen", ["-R", `[${host}]:${port}`]);
-    if (ok) actions.push(`Removed old host key for [${host}]:${port}`);
-  }
-  const scanArgs = port !== 22 ? ["-H", "-p", String(port), host] : ["-H", host];
-  const { stdout: scanOut, ok: scanOk } = runArgs("ssh-keyscan", scanArgs);
-  if (scanOk && scanOut.trim()) {
-    try {
-      const knownHostsPath = join3(homedir3(), ".ssh", "known_hosts");
-      appendFileSync(knownHostsPath, `
-${scanOut.trim()}
-`);
-      actions.push(`Added new host key for ${host}`);
-      return { status: "ok", message: `Host key refreshed for ${host}`, actions };
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      return { status: "error", message: `Scanned key but failed to write known_hosts: ${msg}`, actions };
-    }
+async function writeFile(client, remotePath, content) {
+  const sftp = await getSftp(client);
+  try {
+    await new Promise((resolve, reject) => {
+      sftp.writeFile(remotePath, content, (err) => {
+        if (err) return reject(err);
+        resolve();
+      });
+    });
+  } finally {
+    sftp.end();
   }
-  return { status: "error", message: `Could not scan host key for ${host}. Host may be unreachable.`, actions };
 }
-function checkGitSsh(host = "github.com", user = "git") {
-  if (!isValidHostname(host)) {
-    return { status: "error", message: `Invalid hostname: "${host}"` };
-  }
-  const { stdout } = runArgs("ssh", ["-T", "-o", "ConnectTimeout=5", "-o", "BatchMode=yes", `${user}@${host}`]);
-  const text = stdout;
-  if (text.includes("successfully authenticated") || text.includes("Welcome to GitLab") || text.includes("logged in as")) {
-    const userMatch = text.match(/Hi (\S+?)!/) || text.match(/@(\S+?)!/) || text.match(/logged in as (\S+)/);
-    return {
-      status: "ok",
-      message: `Git SSH authentication to ${host} succeeded${userMatch ? ` as ${userMatch[1]}` : ""}`,
-      authenticatedAs: userMatch?.[1]
-    };
-  }
-  if (text.includes("Permission denied")) {
-    return {
-      status: "error",
-      message: `Permission denied for ${host}. Either no key is loaded in the agent or your key isn't registered with ${host}. Run ssh_key_list to check, then ssh_key_load if needed.`
-    };
-  }
-  if (text.includes("Connection refused")) {
-    return { status: "error", message: `Connection refused by ${host}. SSH may not be available on this host.` };
+async function uploadFile(client, localPath, remotePath) {
+  const sftp = await getSftp(client);
+  try {
+    await new Promise((resolve, reject) => {
+      sftp.fastPut(localPath, remotePath, (err) => {
+        if (err) return reject(err);
+        resolve();
+      });
+    });
+  } finally {
+    sftp.end();
   }
-  if (text.includes("timed out") || text.includes("Connection timed out")) {
-    return { status: "error", message: `Connection to ${host} timed out. Check your network or firewall.` };
+}
+async function downloadFile(client, remotePath, localPath) {
+  const sftp = await getSftp(client);
+  try {
+    await new Promise((resolve, reject) => {
+      sftp.fastGet(remotePath, localPath, (err) => {
+        if (err) return reject(err);
+        resolve();
+      });
+    });
+  } finally {
+    sftp.end();
   }
-  if (text.includes("Could not resolve")) {
-    return { status: "error", message: `Could not resolve hostname "${host}". Check DNS or spelling.` };
+}
+async function listDir(client, remotePath) {
+  const sftp = await getSftp(client);
+  try {
+    return await new Promise((resolve, reject) => {
+      sftp.readdir(remotePath, (err, list) => {
+        if (err) return reject(err);
+        resolve(list.map((item) => item.filename));
+      });
+    });
+  } finally {
+    sftp.end();
   }
-  return { status: "error", message: `Git SSH check for ${host}: ${text || "no response (agent may not be running)"}` };
 }
-function testConnection(host, port = 22) {
-  if (!isValidHostname(host)) {
-    return { status: "error", message: `Invalid hostname: "${host}"` };
+
+// src/pool.ts
+var ConnectionPool = class {
+  entries = /* @__PURE__ */ new Map();
+  // Coalesces concurrent connect attempts for the same key so we don't open N
+  // duplicate TCP connections when N tool calls fire simultaneously.
+  pending = /* @__PURE__ */ new Map();
+  idleTtlMs;
+  maxPoolSize;
+  // Total number of successful connects ever made by this pool. Useful for
+  // introspection and for tests that want to prove connection reuse.
+  _connectCount = 0;
+  constructor(options) {
+    this.idleTtlMs = options?.idleTtlMs ?? 6e4;
+    this.maxPoolSize = options?.maxPoolSize ?? 100;
   }
-  const start = Date.now();
-  const { ok, stdout } = runArgs("ssh", [
-    "-o",
-    "ConnectTimeout=5",
-    "-o",
-    "BatchMode=yes",
-    "-o",
-    "StrictHostKeyChecking=no",
-    "-p",
-    String(port),
-    host,
-    "echo",
-    "SSH_OK"
-  ]);
-  const elapsed = Date.now() - start;
-  if (ok && stdout.includes("SSH_OK")) {
-    return { status: "ok", message: `Connected to ${host}:${port} in ${elapsed}ms` };
+  async acquire(config) {
+    const resolved = resolveConfig(config);
+    const cc = resolved.connectConfig;
+    const key = `${cc.username}@${cc.host}:${cc.port}`;
+    const MAX_ACQUIRE_ATTEMPTS = 3;
+    let lastErr;
+    for (let attempt = 0; attempt < MAX_ACQUIRE_ATTEMPTS; attempt++) {
+      const existing = this.entries.get(key);
+      if (existing && !existing.dead) {
+        existing.refCount++;
+        if (existing.idleTimer) {
+          clearTimeout(existing.idleTimer);
+          existing.idleTimer = null;
+        }
+        return existing.client;
+      }
+      if (existing?.dead) {
+        this.entries.delete(key);
+      }
+      let pending = this.pending.get(key);
+      if (!pending) {
+        if (this.entries.size >= this.maxPoolSize) {
+          let evicted = false;
+          for (const [k, e] of this.entries) {
+            if (e.refCount === 0) {
+              if (e.idleTimer) clearTimeout(e.idleTimer);
+              try {
+                e.client.end();
+              } catch {
+              }
+              this.entries.delete(k);
+              evicted = true;
+              break;
+            }
+          }
+          if (!evicted) {
+            throw new Error(`Connection pool is full (${this.maxPoolSize} active connections)`);
+          }
+        }
+        pending = (async () => {
+          try {
+            const client2 = await connectWithProxy(resolved);
+            this._connectCount++;
+            const entry2 = { client: client2, key, refCount: 0, idleTimer: null, dead: false };
+            const markDead = () => {
+              entry2.dead = true;
+              if (entry2.idleTimer) {
+                clearTimeout(entry2.idleTimer);
+                entry2.idleTimer = null;
+              }
+              if (this.entries.get(key) === entry2) {
+                this.entries.delete(key);
+              }
+            };
+            client2.on("close", markDead);
+            client2.on("end", markDead);
+            client2.on("error", markDead);
+            this.entries.set(key, entry2);
+            return client2;
+          } finally {
+            this.pending.delete(key);
+          }
+        })();
+        this.pending.set(key, pending);
+      }
+      let client;
+      try {
+        client = await pending;
+      } catch (err) {
+        const diag = formatDiagnostics(config.host);
+        if (diag) {
+          const message = err instanceof Error ? err.message : String(err);
+          const enhanced = new Error(`${message}
+
+SSH Diagnostics:
+${diag}`);
+          enhanced.cause = err;
+          throw enhanced;
+        }
+        throw err;
+      }
+      const entry = this.entries.get(key);
+      if (!entry || entry.dead || entry.client !== client) {
+        lastErr = new Error("connection died before acquire could take a ref");
+        continue;
+      }
+      entry.refCount++;
+      if (entry.idleTimer) {
+        clearTimeout(entry.idleTimer);
+        entry.idleTimer = null;
+      }
+      return client;
+    }
+    throw new Error(
+      `Failed to acquire SSH connection for ${key} after ${MAX_ACQUIRE_ATTEMPTS} attempts: ${lastErr instanceof Error ? lastErr.message : String(lastErr)}`
+    );
   }
-  if (stdout.includes("Permission denied")) {
-    return {
-      status: "error",
-      message: `Authentication failed to ${host}:${port} (${elapsed}ms). Key not authorized. Check: ssh-add -l, verify correct username, verify key is in remote authorized_keys.`
-    };
+  release(client) {
+    for (const entry of this.entries.values()) {
+      if (entry.client === client) {
+        entry.refCount = Math.max(0, entry.refCount - 1);
+        if (entry.refCount === 0 && !entry.dead) {
+          entry.idleTimer = setTimeout(() => {
+            try {
+              entry.client.end();
+            } catch {
+            }
+            this.entries.delete(entry.key);
+          }, this.idleTtlMs);
+          entry.idleTimer.unref();
+        }
+        return;
+      }
+    }
+    try {
+      client.end();
+    } catch {
+    }
   }
-  if (stdout.includes("Connection refused")) {
-    return {
-      status: "error",
-      message: `Connection refused at ${host}:${port}. SSH server not running or port blocked.`
-    };
+  async withConnection(config, fn) {
+    const client = await this.acquire(config);
+    try {
+      return await fn(client);
+    } finally {
+      this.release(client);
+    }
   }
-  if (stdout.includes("timed out")) {
-    return { status: "error", message: `Connection timed out to ${host}:${port}. Host down or firewall blocking.` };
+  drain() {
+    for (const entry of this.entries.values()) {
+      if (entry.idleTimer) {
+        clearTimeout(entry.idleTimer);
+      }
+      try {
+        entry.client.end();
+      } catch {
+      }
+    }
+    this.entries.clear();
   }
-  if (stdout.includes("Host key verification failed")) {
-    return {
-      status: "error",
-      message: `Host key mismatch for ${host}. Instance was likely recreated. Fix with ssh_known_hosts_fix.`
-    };
+  get size() {
+    return this.entries.size;
   }
-  if (stdout.includes("Could not resolve")) {
-    return { status: "error", message: `Could not resolve "${host}". Check DNS, /etc/hosts, or SSH config.` };
+  get stats() {
+    let active = 0;
+    let idle = 0;
+    for (const entry of this.entries.values()) {
+      if (entry.refCount > 0) active++;
+      else idle++;
+    }
+    return { active, idle };
   }
-  return { status: "error", message: `Connection failed to ${host}:${port}: ${stdout}` };
-}
+  /** Total number of successful SSH connects made by this pool since construction. */
+  get connectCount() {
+    return this._connectCount;
+  }
+};
+
+// src/server.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { dirname, join as join4 } from "path";
+import { fileURLToPath } from "url";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/tools.ts
+import { z } from "zod";
 
 // src/ops.ts
 function shellQuote(s) {
@@ -1007,39 +1123,43 @@ async function find(client, options, timeoutMs = 3e4) {
       `Invalid maxsize format: "${options.maxsize}". Expected: digits followed by optional k/M/G/T/P (e.g. "10M", "500k")`
     );
   }
-  const args = [shellQuote(options.path)];
+  const args = ["--", shellQuote(options.path)];
   if (options.maxdepth !== void 0) args.push("-maxdepth", String(options.maxdepth));
   if (options.type) args.push("-type", options.type);
   if (options.name) args.push("-name", shellQuote(options.name));
   if (options.minsize) args.push("-size", `+${options.minsize}`);
   if (options.maxsize) args.push("-size", `-${options.maxsize}`);
   if (options.newer) args.push("-newer", shellQuote(options.newer));
-  const command = `find ${args.join(" ")} 2>/dev/null`;
+  const command = `find ${args.join(" ")}`;
   const result = await exec(client, command, timeoutMs);
+  if (!result.stdout.trim() && result.stderr.trim()) {
+    throw new Error(result.stderr.trim());
+  }
   return result.stdout.split("\n").filter(Boolean);
 }
 async function tail(client, path, lines = 100, grep, timeoutMs = 3e4) {
-  let command = `tail -n ${lines} ${shellQuote(path)}`;
+  let command = `tail -n ${lines} -- ${shellQuote(path)}`;
   if (grep) {
-    command += ` | grep -i ${shellQuote(grep)}`;
+    command += ` | grep -i -e ${shellQuote(grep)}`;
   }
   const result = await exec(client, command, timeoutMs);
-  if (result.code !== 0 && result.stderr && !grep) {
+  if (result.stderr.trim()) {
     throw new Error(result.stderr.trim());
   }
   return result.stdout;
 }
 async function serviceStatus(client, serviceName, timeoutMs = 3e4) {
-  const result = await exec(client, `systemctl status ${shellQuote(serviceName)} 2>&1`, timeoutMs);
+  const result = await exec(client, `systemctl status -- ${shellQuote(serviceName)} 2>&1`, timeoutMs);
   const raw = result.stdout;
   const activeMatch = raw.match(/Active:\s+(\S+)\s+\(([^)]+)\)/);
   const descMatch = raw.match(/^\s+.*?-\s+(.+)$/m);
   const pidMatch = raw.match(/Main PID:\s+(\d+)/);
   const sinceMatch = raw.match(/since\s+(.+?);/);
+  const fallbackStatus = result.code === 0 ? "active" : "inactive";
   return {
     name: serviceName,
     active: activeMatch?.[1] === "active",
-    status: activeMatch ? `${activeMatch[1]} (${activeMatch[2]})` : result.code === 0 ? "active" : "unknown",
+    status: activeMatch ? `${activeMatch[1]} (${activeMatch[2]})` : fallbackStatus,
     description: descMatch?.[1]?.trim(),
     since: sinceMatch?.[1]?.trim(),
     pid: pidMatch ? Number.parseInt(pidMatch[1], 10) : void 0,
@@ -1052,7 +1172,9 @@ var HostSchema = z.string().describe("SSH hostname or IP address");
 var PortSchema = z.number().int().min(1).max(65535).optional().describe("SSH port (default: 22)");
 var UsernameSchema = z.string().optional().describe("SSH username (default: current user)");
 var KeyPathSchema = z.string().optional().describe("Path to SSH private key");
-var PasswordSchema = z.string().optional().describe("SSH password (prefer keys)");
+var PasswordSchema = z.string().optional().describe(
+  "SSH password. STRONGLY prefer key-based auth (privateKeyPath or ssh-agent). Passwords pass through MCP protocol frames as plaintext and may be logged by the transport or host process."
+);
 var TimeoutSchema = z.number().int().positive().optional().describe("Command timeout in milliseconds (default: 30000)");
 var connectionParams = {
   host: HostSchema,
@@ -1071,8 +1193,8 @@ function registerTools(server, pool) {
       command: z.string().describe("Shell command to execute on the remote host (interpreted by the remote login shell)"),
       timeout: TimeoutSchema
     },
-    async ({ host, port, username, privateKeyPath, password, command, timeout }) => {
-      return connectionPool.withConnection({ host, port, username, privateKeyPath, password }, async (client) => {
+    async ({ command, timeout, ...conn }) => {
+      return connectionPool.withConnection(conn, async (client) => {
         const result = await exec(client, command, timeout || 3e4);
         const parts = [];
         if (result.stdout) parts.push(result.stdout);
@@ -1090,8 +1212,8 @@ ${result.stderr}`);
       ...connectionParams,
       path: z.string().describe("Absolute path to the remote file")
     },
-    async ({ host, port, username, privateKeyPath, password, path }) => {
-      return connectionPool.withConnection({ host, port, username, privateKeyPath, password }, async (client) => {
+    async ({ path, ...conn }) => {
+      return connectionPool.withConnection(conn, async (client) => {
         const content = await readFile(client, path);
         return { content: [{ type: "text", text: content }] };
       });
@@ -1105,8 +1227,8 @@ ${result.stderr}`);
       path: z.string().describe("Absolute path to the remote file"),
       content: z.string().describe("File content to write")
     },
-    async ({ host, port, username, privateKeyPath, password, path, content }) => {
-      return connectionPool.withConnection({ host, port, username, privateKeyPath, password }, async (client) => {
+    async ({ path, content, ...conn }) => {
+      return connectionPool.withConnection(conn, async (client) => {
         await writeFile(client, path, content);
         return { content: [{ type: "text", text: `Wrote ${content.length} bytes to ${path}` }] };
       });
@@ -1120,8 +1242,8 @@ ${result.stderr}`);
       localPath: z.string().describe("Path to the local file to upload"),
       remotePath: z.string().describe("Absolute path on the remote host")
     },
-    async ({ host, port, username, privateKeyPath, password, localPath, remotePath }) => {
-      return connectionPool.withConnection({ host, port, username, privateKeyPath, password }, async (client) => {
+    async ({ localPath, remotePath, ...conn }) => {
+      return connectionPool.withConnection(conn, async (client) => {
         await uploadFile(client, localPath, remotePath);
         return { content: [{ type: "text", text: `Uploaded ${localPath} \u2192 ${remotePath}` }] };
       });
@@ -1135,8 +1257,8 @@ ${result.stderr}`);
       remotePath: z.string().describe("Absolute path to the remote file"),
       localPath: z.string().describe("Local path to save the downloaded file")
     },
-    async ({ host, port, username, privateKeyPath, password, remotePath, localPath }) => {
-      return connectionPool.withConnection({ host, port, username, privateKeyPath, password }, async (client) => {
+    async ({ remotePath, localPath, ...conn }) => {
+      return connectionPool.withConnection(conn, async (client) => {
         await downloadFile(client, remotePath, localPath);
         return { content: [{ type: "text", text: `Downloaded ${remotePath} \u2192 ${localPath}` }] };
       });
@@ -1149,8 +1271,8 @@ ${result.stderr}`);
       ...connectionParams,
       path: z.string().describe("Absolute path to the remote directory")
     },
-    async ({ host, port, username, privateKeyPath, password, path }) => {
-      return connectionPool.withConnection({ host, port, username, privateKeyPath, password }, async (client) => {
+    async ({ path, ...conn }) => {
+      return connectionPool.withConnection(conn, async (client) => {
         const files = await listDir(client, path);
         return { content: [{ type: "text", text: files.join("\n") }] };
       });
@@ -1356,21 +1478,8 @@ ${result.stderr}`);
       maxsize: z.string().optional().describe("Maximum file size (e.g. '10M', '500k')"),
       timeout: TimeoutSchema
     },
-    async ({
-      host,
-      port,
-      username,
-      privateKeyPath,
-      password,
-      path,
-      name,
-      type,
-      maxdepth,
-      minsize,
-      maxsize,
-      timeout
-    }) => {
-      return connectionPool.withConnection({ host, port, username, privateKeyPath, password }, async (client) => {
+    async ({ path, name, type, maxdepth, minsize, maxsize, timeout, ...conn }) => {
+      return connectionPool.withConnection(conn, async (client) => {
         const files = await find(client, { path, name, type, maxdepth, minsize, maxsize }, timeout || 3e4);
         if (files.length === 0) {
           return { content: [{ type: "text", text: "No files found." }] };
@@ -1390,8 +1499,8 @@ ${files.join("\n")}` }] };
       grep: z.string().optional().describe("Case-insensitive pattern to filter lines"),
       timeout: TimeoutSchema
     },
-    async ({ host, port, username, privateKeyPath, password, path, lines, grep, timeout }) => {
-      return connectionPool.withConnection({ host, port, username, privateKeyPath, password }, async (client) => {
+    async ({ path, lines, grep, timeout, ...conn }) => {
+      return connectionPool.withConnection(conn, async (client) => {
         const output = await tail(client, path, lines || 100, grep, timeout || 3e4);
         if (!output.trim()) {
           return {
@@ -1415,8 +1524,8 @@ ${files.join("\n")}` }] };
       service: z.string().describe("Systemd service name (e.g. nginx, sshd, docker)"),
       timeout: TimeoutSchema
     },
-    async ({ host, port, username, privateKeyPath, password, service, timeout }) => {
-      return connectionPool.withConnection({ host, port, username, privateKeyPath, password }, async (client) => {
+    async ({ service, timeout, ...conn }) => {
+      return connectionPool.withConnection(conn, async (client) => {
         const status = await serviceStatus(client, service, timeout || 3e4);
         const lines = [];
         lines.push(`Service: ${status.name}`);
@@ -1433,10 +1542,12 @@ ${files.join("\n")}` }] };
 }
 
 // src/server.ts
+var pkgPath = join4(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+var { version } = JSON.parse(readFileSync4(pkgPath, "utf8"));
 function createServer(pool) {
   const server = new McpServer({
     name: "ssh-mcp",
-    version: "0.7.0"
+    version
   });
   registerTools(server, pool);
   return server;
@@ -1449,6 +1560,7 @@ async function main() {
   const transport = new StdioServerTransport();
   const shutdown = () => {
     pool.drain();
+    killStartedAgent();
     process.exit(0);
   };
   process.on("SIGINT", shutdown);