@yawlabs/ssh-mcp 0.3.0 → 0.5.0

package/dist/server.js

@@ -25,6 +25,25 @@ function runArgs(cmd, args) {
 }
 function checkSshAgent() {
   const sock = process.env.SSH_AUTH_SOCK;
+  if (!sock && process.platform === "win32") {
+    const { stdout: stdout2, ok: ok2 } = runArgs("ssh-add", ["-l"]);
+    if (ok2) {
+      return { status: "ok", message: `Windows OpenSSH agent running with keys:
+${stdout2}` };
+    }
+    if (stdout2.includes("no identities") || stdout2.includes("The agent has no identities")) {
+      return {
+        status: "warning",
+        message: "Windows OpenSSH agent is running but has no keys loaded. Run: ssh-add <key-path>"
+      };
+    }
+    if (!stdout2.includes("Error connecting") && !stdout2.includes("unable to")) {
+      return {
+        status: "warning",
+        message: "Windows OpenSSH Authentication Agent may not be running. Start it: Get-Service ssh-agent | Set-Service -StartupType Automatic; Start-Service ssh-agent"
+      };
+    }
+  }
   if (!sock) {
     return {
       status: "error",
@@ -254,6 +273,21 @@ function ensureAgent() {
       };
     }
   }
+  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=([^;]+)/);
@@ -277,7 +311,7 @@ function ensureAgent() {
     reachable: false,
     keys: [],
     started: false,
-    message: 'Could not start ssh-agent. Run manually: eval "$(ssh-agent -s)"'
+    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) {
@@ -515,23 +549,57 @@ import { readFileSync as readFileSync3 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join3 } from "path";
 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;
+        }
+      }
+    }
+    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;
+  }
+}
 function resolveConfig(config) {
+  const sshConfig = resolveFromSshConfig(config.host);
   const connectConfig = {
-    host: config.host,
-    port: config.port || 22,
-    username: config.username || process.env.USER || process.env.USERNAME || "root"
+    host: sshConfig?.hostname || config.host,
+    port: config.port || (sshConfig ? Number.parseInt(sshConfig.port, 10) : 22),
+    username: config.username || sshConfig?.user || process.env.USER || process.env.USERNAME || "root",
+    keepaliveInterval: 15e3,
+    keepaliveCountMax: 3
   };
+  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 (config.password) {
-    connectConfig.password = config.password;
-  } else if (config.agent || process.env.SSH_AUTH_SOCK) {
-    connectConfig.agent = config.agent || process.env.SSH_AUTH_SOCK;
-  } else {
+  } else if (!agentSock) {
     const home = homedir3();
-    const defaultKeys = ["id_ed25519", "id_rsa", "id_ecdsa"];
-    for (const keyName of defaultKeys) {
-      const keyPath = join3(home, ".ssh", keyName);
+    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;
@@ -539,7 +607,7 @@ function resolveConfig(config) {
       }
     }
   }
-  return connectConfig;
+  return { connectConfig, proxyJump: sshConfig?.proxyJump };
 }
 function formatDiagnostics(host) {
   try {
@@ -571,24 +639,56 @@ function formatDiagnostics(host) {
     return "";
   }
 }
-function connect(config) {
+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 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();
-    const connectConfig = resolveConfig(config);
     client.on("ready", () => resolve(client)).on("error", (err) => {
-      const diag = formatDiagnostics(config.host);
-      if (diag) {
-        const enhanced = new Error(`${err.message}
+      jumpClient.end();
+      reject(err);
+    }).on("close", () => {
+      jumpClient.end();
+    }).connect({ ...resolved.connectConfig, sock: stream });
+  });
+}
+async function connect(config) {
+  const resolved = resolveConfig(config);
+  try {
+    return await connectWithProxy(resolved);
+  } 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;
-        reject(enhanced);
-      } else {
-        reject(err);
-      }
-    }).connect(connectConfig);
-  });
+      enhanced.cause = err;
+      throw enhanced;
+    }
+    throw err;
+  }
 }
 function exec(client, command, timeoutMs = 3e4) {
   return new Promise((resolve, reject) => {
@@ -698,6 +798,184 @@ async function listDir(client, remotePath) {
   }
 }
 
+// src/ops.ts
+function shellQuote(s) {
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+async function multiExec(pool, hosts, command, timeoutMs = 3e4) {
+  const results = await Promise.allSettled(
+    hosts.map(async (hostConfig) => {
+      return pool.withConnection(hostConfig, async (client) => {
+        const result = await exec(client, command, timeoutMs);
+        return { host: hostConfig.host, ...result };
+      });
+    })
+  );
+  return results.map((result, i) => {
+    if (result.status === "fulfilled") {
+      return result.value;
+    }
+    return {
+      host: hosts[i].host,
+      stdout: "",
+      stderr: "",
+      code: -1,
+      error: result.reason instanceof Error ? result.reason.message : String(result.reason)
+    };
+  });
+}
+async function find(client, options, timeoutMs = 3e4) {
+  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 result = await exec(client, command, timeoutMs);
+  return result.stdout.split("\n").filter(Boolean);
+}
+async function tail(client, path, lines = 100, grep, timeoutMs = 3e4) {
+  let command = `tail -n ${lines} ${shellQuote(path)}`;
+  if (grep) {
+    command += ` | grep -i ${shellQuote(grep)}`;
+  }
+  const result = await exec(client, command, timeoutMs);
+  if (result.code !== 0 && result.stderr && !grep) {
+    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 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+(.+?);/);
+  return {
+    name: serviceName,
+    active: activeMatch?.[1] === "active",
+    status: activeMatch ? `${activeMatch[1]} (${activeMatch[2]})` : result.code === 0 ? "active" : "unknown",
+    description: descMatch?.[1]?.trim(),
+    since: sinceMatch?.[1]?.trim(),
+    pid: pidMatch ? Number.parseInt(pidMatch[1], 10) : void 0,
+    raw
+  };
+}
+
+// src/pool.ts
+var ConnectionPool = class {
+  entries = /* @__PURE__ */ new Map();
+  idleTtlMs;
+  constructor(options) {
+    this.idleTtlMs = options?.idleTtlMs ?? 6e4;
+  }
+  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);
+    }
+    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;
+    }
+  }
+  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 {
+    }
+  }
+  async withConnection(config, fn) {
+    const client = await this.acquire(config);
+    try {
+      return await fn(client);
+    } finally {
+      this.release(client);
+    }
+  }
+  drain() {
+    for (const entry of this.entries.values()) {
+      if (entry.idleTimer) {
+        clearTimeout(entry.idleTimer);
+      }
+      try {
+        entry.client.end();
+      } catch {
+      }
+    }
+    this.entries.clear();
+  }
+  get size() {
+    return this.entries.size;
+  }
+  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 };
+  }
+};
+
 // src/tools.ts
 var HostSchema = z.string().describe("SSH hostname or IP address");
 var PortSchema = z.number().optional().describe("SSH port (default: 22)");
@@ -712,7 +990,8 @@ var connectionParams = {
   privateKeyPath: KeyPathSchema,
   password: PasswordSchema
 };
-function registerTools(server) {
+function registerTools(server, pool) {
+  const connectionPool = pool ?? new ConnectionPool();
   server.tool(
     "ssh_exec",
     "Execute a command on a remote host via SSH. Returns stdout, stderr, and exit code.",
@@ -722,8 +1001,7 @@ function registerTools(server) {
       timeout: TimeoutSchema
     },
     async ({ host, port, username, privateKeyPath, password, command, timeout }) => {
-      const client = await connect({ host, port, username, privateKeyPath, password });
-      try {
+      return connectionPool.withConnection({ host, port, username, privateKeyPath, password }, async (client) => {
         const result = await exec(client, command, timeout || 3e4);
         const parts = [];
         if (result.stdout) parts.push(result.stdout);
@@ -731,9 +1009,7 @@ function registerTools(server) {
 ${result.stderr}`);
         parts.push(`[exit code: ${result.code}]`);
         return { content: [{ type: "text", text: parts.join("\n") }] };
-      } finally {
-        client.end();
-      }
+      });
     }
   );
   server.tool(
@@ -744,13 +1020,10 @@ ${result.stderr}`);
       path: z.string().describe("Absolute path to the remote file")
     },
     async ({ host, port, username, privateKeyPath, password, path }) => {
-      const client = await connect({ host, port, username, privateKeyPath, password });
-      try {
+      return connectionPool.withConnection({ host, port, username, privateKeyPath, password }, async (client) => {
         const content = await readFile(client, path);
         return { content: [{ type: "text", text: content }] };
-      } finally {
-        client.end();
-      }
+      });
     }
   );
   server.tool(
@@ -762,13 +1035,10 @@ ${result.stderr}`);
       content: z.string().describe("File content to write")
     },
     async ({ host, port, username, privateKeyPath, password, path, content }) => {
-      const client = await connect({ host, port, username, privateKeyPath, password });
-      try {
+      return connectionPool.withConnection({ host, port, username, privateKeyPath, password }, async (client) => {
         await writeFile(client, path, content);
         return { content: [{ type: "text", text: `Wrote ${content.length} bytes to ${path}` }] };
-      } finally {
-        client.end();
-      }
+      });
     }
   );
   server.tool(
@@ -780,13 +1050,10 @@ ${result.stderr}`);
       remotePath: z.string().describe("Absolute path on the remote host")
     },
     async ({ host, port, username, privateKeyPath, password, localPath, remotePath }) => {
-      const client = await connect({ host, port, username, privateKeyPath, password });
-      try {
+      return connectionPool.withConnection({ host, port, username, privateKeyPath, password }, async (client) => {
         await uploadFile(client, localPath, remotePath);
         return { content: [{ type: "text", text: `Uploaded ${localPath} \u2192 ${remotePath}` }] };
-      } finally {
-        client.end();
-      }
+      });
     }
   );
   server.tool(
@@ -798,13 +1065,10 @@ ${result.stderr}`);
       localPath: z.string().describe("Local path to save the downloaded file")
     },
     async ({ host, port, username, privateKeyPath, password, remotePath, localPath }) => {
-      const client = await connect({ host, port, username, privateKeyPath, password });
-      try {
+      return connectionPool.withConnection({ host, port, username, privateKeyPath, password }, async (client) => {
         await downloadFile(client, remotePath, localPath);
         return { content: [{ type: "text", text: `Downloaded ${remotePath} \u2192 ${localPath}` }] };
-      } finally {
-        client.end();
-      }
+      });
     }
   );
   server.tool(
@@ -815,13 +1079,10 @@ ${result.stderr}`);
       path: z.string().describe("Absolute path to the remote directory")
     },
     async ({ host, port, username, privateKeyPath, password, path }) => {
-      const client = await connect({ host, port, username, privateKeyPath, password });
-      try {
+      return connectionPool.withConnection({ host, port, username, privateKeyPath, password }, async (client) => {
         const files = await listDir(client, path);
         return { content: [{ type: "text", text: files.join("\n") }] };
-      } finally {
-        client.end();
-      }
+      });
     }
   );
   server.tool(
@@ -980,18 +1241,136 @@ ${result.stderr}`);
       return { content: [{ type: "text", text: lines.join("\n") }], isError: result.status === "error" };
     }
   );
+  server.tool(
+    "ssh_multi_exec",
+    "Execute a command on multiple remote hosts in parallel. Returns results per host. Use this instead of calling ssh_exec multiple times \u2014 it's faster and shows results side by side.",
+    {
+      hosts: z.array(z.string()).describe("List of SSH hostnames or IPs"),
+      command: z.string().describe("Shell command to execute on all hosts"),
+      username: UsernameSchema,
+      privateKeyPath: KeyPathSchema,
+      password: PasswordSchema,
+      timeout: TimeoutSchema
+    },
+    async ({ hosts, command, username, privateKeyPath, password, timeout }) => {
+      const hostConfigs = hosts.map((host) => ({ host, username, privateKeyPath, password }));
+      const results = await multiExec(connectionPool, hostConfigs, command, timeout || 3e4);
+      const lines = [];
+      for (const r of results) {
+        lines.push(`--- ${r.host} ---`);
+        if (r.error) {
+          lines.push(`[ERROR] ${r.error}`);
+        } else {
+          if (r.stdout) lines.push(r.stdout);
+          if (r.stderr) lines.push(`[stderr] ${r.stderr}`);
+          lines.push(`[exit code: ${r.code}]`);
+        }
+        lines.push("");
+      }
+      const hasErrors = results.some((r) => r.error || r.code !== 0);
+      return { content: [{ type: "text", text: lines.join("\n") }], isError: hasErrors };
+    }
+  );
+  server.tool(
+    "ssh_find",
+    "Search for files on a remote host. Wraps the find command with structured parameters so you don't have to construct find syntax manually.",
+    {
+      ...connectionParams,
+      path: z.string().describe("Directory to search in (e.g. /var/log, /home/user)"),
+      name: z.string().optional().describe("Filename pattern with wildcards (e.g. '*.log', 'config.*')"),
+      type: z.enum(["f", "d", "l"]).optional().describe("File type: f=file, d=directory, l=symlink"),
+      maxdepth: z.number().optional().describe("Maximum directory depth to search"),
+      minsize: z.string().optional().describe("Minimum file size (e.g. '1M', '100k')"),
+      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) => {
+        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." }] };
+        }
+        return { content: [{ type: "text", text: `Found ${files.length} result(s):
+${files.join("\n")}` }] };
+      });
+    }
+  );
+  server.tool(
+    "ssh_tail",
+    "Read the last N lines of a file on a remote host, optionally filtering by a grep pattern. Use this for reading log files instead of ssh_exec with manual tail/grep commands.",
+    {
+      ...connectionParams,
+      path: z.string().describe("Absolute path to the file to tail"),
+      lines: z.number().optional().describe("Number of lines to read from the end (default: 100)"),
+      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) => {
+        const output = await tail(client, path, lines || 100, grep, timeout || 3e4);
+        if (!output.trim()) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: grep ? `No lines matching "${grep}" in last ${lines || 100} lines.` : "File is empty or does not exist."
+              }
+            ]
+          };
+        }
+        return { content: [{ type: "text", text: output }] };
+      });
+    }
+  );
+  server.tool(
+    "ssh_service_status",
+    "Check the status of a systemd service on a remote host. Returns whether it's active, its PID, uptime, and description. Use this instead of ssh_exec with systemctl.",
+    {
+      ...connectionParams,
+      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) => {
+        const status = await serviceStatus(client, service, timeout || 3e4);
+        const lines = [];
+        lines.push(`Service: ${status.name}`);
+        lines.push(`Status: ${status.status}`);
+        if (status.description) lines.push(`Description: ${status.description}`);
+        if (status.pid) lines.push(`PID: ${status.pid}`);
+        if (status.since) lines.push(`Since: ${status.since}`);
+        lines.push("");
+        lines.push(status.raw);
+        return { content: [{ type: "text", text: lines.join("\n") }], isError: !status.active };
+      });
+    }
+  );
 }
 
 // src/server.ts
-function createServer() {
+function createServer(pool) {
   const server = new McpServer({
     name: "ssh-mcp",
-    version: "0.3.0"
+    version: "0.5.0"
   });
-  registerTools(server);
+  registerTools(server, pool);
   return server;
 }
 export {
+  ConnectionPool,
   checkConnectivity,
   checkGitSsh,
   checkKnownHosts,
@@ -1000,17 +1379,25 @@ export {
   checkSshKeys,
   configLookup,
   connect,
+  connectRaw,
+  connectWithProxy,
   createServer,
   diagnose,
   downloadFile,
   ensureAgent,
   exec,
+  find,
   fixKnownHosts,
+  formatDiagnostics,
   listDir,
   listSshKeys,
   loadKey,
+  multiExec,
   readFile,
   registerTools,
+  resolveConfig,
+  serviceStatus,
+  tail,
   testConnection,
   uploadFile,
   writeFile

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yawlabs/ssh-mcp",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "MCP server for SSH operations with built-in diagnostics",
   "type": "module",
   "bin": {
@@ -24,6 +24,7 @@
     "lint:fix": "biome check --write src/",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
+    "test:integration": "docker compose -f test/docker/docker-compose.yml up -d --build --wait && SSH_MCP_INTEGRATION=1 vitest run src/tests/integration.test.ts; docker compose -f test/docker/docker-compose.yml down",
     "test:ci": "npm run build && npm test",
     "prepublishOnly": "npm run build"
   },