@yawlabs/ssh-mcp 0.7.0 → 0.9.0

package/dist/server.js

@@ -1,4 +1,7 @@
 // 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
@@ -6,7 +9,7 @@ import { z } from "zod";
 
 // 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) {
@@ -14,7 +17,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 {
@@ -256,40 +259,33 @@ function diagnose(host, port = 22) {
 }
 
 // src/env.ts
-import { appendFileSync, existsSync as existsSync2, readFileSync as readFileSync2, readdirSync as readdirSync2, statSync } from "fs";
+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";
+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 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."
-      };
-    }
+    const result = probeAgent(sock, "ssh-agent");
+    if (result) return result;
   }
   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 result = probeAgent("\\\\.\\pipe\\openssh-ssh-agent", "Windows OpenSSH agent");
+    if (result) return result;
   }
   const { stdout, ok } = runArgs("ssh-agent", ["-s"]);
   if (ok) {
@@ -297,7 +293,10 @@ function ensureAgent() {
     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];
+      if (pidMatch) {
+        process.env.SSH_AGENT_PID = pidMatch[1];
+        startedAgentPid = Number.parseInt(pidMatch[1], 10);
+      }
       return {
         running: true,
         reachable: true,
@@ -305,7 +304,7 @@ function ensureAgent() {
         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."
+        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."
       };
     }
   }
@@ -431,8 +430,8 @@ function configLookup(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,
+    proxyJump: all.proxyjump && all.proxyjump !== "none" ? all.proxyjump : void 0,
+    proxyCommand: all.proxycommand && all.proxycommand !== "none" ? all.proxycommand : void 0,
     all,
     raw: stdout
   };
@@ -474,7 +473,7 @@ function checkGitSsh(host = "github.com", user = "git") {
   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+)/);
+    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]}` : ""}`,
@@ -626,33 +625,54 @@ function resolveConfig(config) {
     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;
-  }
-  if (config.password) {
-    connectConfig.password = config.password;
-  }
   if (config.privateKeyPath) {
     connectConfig.privateKey = readFileSync3(config.privateKeyPath);
-  } else if (!agentSock) {
-    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 {
+  } 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 { connectConfig, proxyJump: sshConfig?.proxyJump };
 }
+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", ...checkSshAgent() },
-      { name: "SSH Keys", ...checkSshKeys() },
+      { name: "SSH Agent", ...cachedAgentCheck() },
+      { name: "SSH Keys", ...cachedKeysCheck() },
       { name: "SSH Config", ...checkSshConfig(host) },
       { name: "Known Hosts", ...checkKnownHosts(host) }
     ];
@@ -729,9 +749,11 @@ ${diag}`);
     throw err;
   }
 }
-function exec(client, command, timeoutMs = 3e4) {
+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;
@@ -739,6 +761,16 @@ function exec(client, command, timeoutMs = 3e4) {
       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) => {
@@ -746,18 +778,53 @@ function exec(client, command, timeoutMs = 3e4) {
         settle(() => reject(err));
         return;
       }
-      let stdout = "";
-      let stderr = "";
+      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", (data) => {
-        stdout += data.toString();
-      }).on("error", (err2) => {
+      }).on("data", appendStdout).on("error", (err2) => {
         settle(() => reject(err2));
       });
-      stream.stderr.on("data", (data) => {
-        stderr += data.toString();
-      }).on("error", (err2) => {
+      stream.stderr.on("data", appendStderr).on("error", (err2) => {
         settle(() => reject(err2));
       });
     });
@@ -887,39 +954,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,
@@ -930,8 +1001,14 @@ async function serviceStatus(client, serviceName, timeoutMs = 3e4) {
 // 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;
@@ -940,67 +1017,98 @@ var ConnectionPool = class {
     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;
+    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 (!evicted) {
-        throw new Error(`Connection pool is full (${this.maxPoolSize} active connections)`);
+      if (existing?.dead) {
+        this.entries.delete(key);
       }
-    }
-    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);
+      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)`);
+          }
         }
-      };
-      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}
+        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;
+          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;
       }
-      throw err;
+      return client;
     }
+    throw new Error(
+      `Failed to acquire SSH connection for ${key} after ${MAX_ACQUIRE_ATTEMPTS} attempts: ${lastErr instanceof Error ? lastErr.message : String(lastErr)}`
+    );
   }
   release(client) {
     for (const entry of this.entries.values()) {
@@ -1056,6 +1164,10 @@ ${diag}`);
     }
     return { active, idle };
   }
+  /** Total number of successful SSH connects made by this pool since construction. */
+  get connectCount() {
+    return this._connectCount;
+  }
 };
 
 // src/tools.ts
@@ -1063,7 +1175,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,
@@ -1082,8 +1196,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);
@@ -1101,8 +1215,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 }] };
       });
@@ -1116,8 +1230,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}` }] };
       });
@@ -1131,8 +1245,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}` }] };
       });
@@ -1146,8 +1260,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}` }] };
       });
@@ -1160,8 +1274,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") }] };
       });
@@ -1367,21 +1481,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." }] };
@@ -1401,8 +1502,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 {
@@ -1426,8 +1527,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}`);
@@ -1444,10 +1545,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;