@bingzi-233/ssh-mcp 1.0.0 → 1.2.0

package/README.md

@@ -8,11 +8,16 @@
 |---|---|
 | `list_servers` | 列出所有已配置的服务器（name / 描述 / 地址 / 用户，**不含密码私钥**） |
 | `run_command` | 在指定 `name` 的服务器上执行一条命令，返回 stdout / stderr / 退出码 |
+| `open_session` | 建立到服务器的长连接会话，返回会话 id 供 `run_command` 复用 |
+| `close_session` | 关闭长连接会话 |
+| `list_sessions` | 列出当前所有活跃的长连接会话 |
 | `upload_file` | 上传本机文件到远程（后台任务，支持断点续传） |
 | `download_file` | 从远程下载文件到本机（后台任务，支持断点续传） |
 | `transfer_status` | 查询传输进度（已传字节、百分比、速度、ETA、状态） |
 | `cancel_transfer` | 取消一个进行中的传输（已传部分保留，可续传） |
 
+> - **长连接**：用 `open_session` 建立持久连接，`run_command` 传入 `session` 参数复用，省去重复握手和认证开销。即便复用了连接，每条命令仍在独立 channel 中执行，工作目录和环境变量不保留。
+> - **安全策略**：内置拦截 `rm -rf /`、`dd` 写块设备、`mkfs`、fork 炸弹等高危命令。可在 `servers.json` 的 `security.blocked_patterns` 中追加自定义正则。传入 `force=true` 可绕过。
 > - 命令在独立会话中执行，**命令之间不保留工作目录和环境变量**。需要保持上下文时自行串接，例如 `cd /var/www && git pull`。
 > - 大文件传输是**后台任务**：`upload_file`/`download_file` 立即返回一个传输 id，用 `transfer_status` 轮询进度，不阻塞。
 > - **断点续传**基于目标文件的实际大小：对同一对路径再次发起传输会自动从已传字节处继续，进程重启后依然有效。
@@ -54,10 +59,13 @@ claude mcp add ssh -- node /绝对路径/ssh-mcp/dist/index.js
 
 ## 配置服务器
 
-默认从 `~/.ssh-mcp/servers.json` 读取（可用环境变量 `SSH_MCP_CONFIG` 指定别的路径）。参考 `servers.example.json`：
+默认从**运行目录下的 `./servers.json`** 读取（即 Claude 启动 MCP 服务器时所在的工作目录，通常是你当前的项目根目录）。也可用环境变量 `SSH_MCP_CONFIG` 指定任意路径。参考 `servers.example.json`：
 
 ```json
 {
+  "security": {
+    "blocked_patterns": []
+  },
   "servers": [
     {
       "name": "prod-web",
@@ -88,37 +96,6 @@ claude mcp add ssh -- node /绝对路径/ssh-mcp/dist/index.js
 
 ---
 
-## 发布到 npm（维护者）
-
-仓库已配置 GitHub Actions，推送 `vX.Y.Z` 形式的 tag 即自动发布到 npm。
-
-**一次性准备**：
-
-1. 在 npmjs.com 创建一个 **Automation** 类型的 Access Token。
-2. 把它加到仓库 Secrets：
-   ```bash
-   gh secret set NPM_TOKEN
-   ```
-   （或在 GitHub 网页 Settings → Secrets and variables → Actions 添加。）
-
-> 包名 scope `@bingzi-233` 必须是你拥有的 npm 用户名或组织。若不一致，改 `package.json` 的 `name` 与插件 `.mcp.json` 里的 `args`。
-
-**每次发版**：
-
-```bash
-# 1. 同步版本号（两处都改：npm 包与插件）
-#    - package.json 的 "version"
-#    - plugins/ssh-mcp/.claude-plugin/plugin.json 的 "version"
-# 2. 提交并打 tag
-git commit -am "release: v1.0.1"
-git tag v1.0.1
-git push && git push --tags
-```
-
-Actions 会自动 `npm ci && npm run build && npm publish`（带 provenance 来源证明）。
-
----
-
 ## ⚠️ 安全提示
 
 这个工具允许模型在你的服务器上执行**任意命令**、读写文件。请仅指向你拥有/授权的机器：
@@ -126,7 +103,7 @@ Actions 会自动 `npm ci && npm run build && npm publish`（带 provenance 来
 - `servers.json` 含明文凭据，已在 `.gitignore` 中排除，**切勿提交到仓库**。
 - 优先用私钥或 `ssh-agent`，尽量不在配置里写明文密码。
 - 给 SSH 账号最小权限；高危机器考虑用受限账号。
-- `run_command` 默认每条命令 60s 超时，可用 `timeout_ms` 调整。
+- 内置命令安全策略会拦截 `rm -rf /`、`dd` 写块设备、`mkfs`、fork 炸弹等高危模式。可在 `security.blocked_patterns` 中追加自定义正则（JSON 字符串，需双重转义，如 `"rm\\\\s.*-rf?\\\\s+/\\\\*"`）。传 `force=true` 可绕过。
 
 ## License
 

package/dist/config.js

@@ -1,6 +1,6 @@
 import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 /** 把开头的 ~ 展开成用户主目录。 */
 export function expandHome(p) {
     if (p === "~")
@@ -9,25 +9,28 @@ export function expandHome(p) {
         return join(homedir(), p.slice(2));
     return p;
 }
-/** 配置文件路径：优先环境变量 SSH_MCP_CONFIG，否则取 ~/.ssh-mcp/servers.json。 */
+/** 配置文件路径：优先环境变量 SSH_MCP_CONFIG，否则取运行目录下的 ./servers.json。 */
 export function configPath() {
     const fromEnv = process.env.SSH_MCP_CONFIG;
-    return fromEnv ? expandHome(fromEnv) : join(homedir(), ".ssh-mcp", "servers.json");
+    return fromEnv ? expandHome(fromEnv) : resolve(process.cwd(), "servers.json");
 }
-/**
- * 每次调用都从磁盘重新读取配置——配置文件就是唯一事实来源。
- * 这样新增服务器后无需重启 MCP 服务器。读取或校验失败时抛错，由调用方处理。
- */
-export function loadServers() {
+function readConfig() {
     const path = configPath();
     const raw = readFileSync(path, "utf8");
-    let parsed;
     try {
-        parsed = JSON.parse(raw);
+        return JSON.parse(raw);
     }
     catch (e) {
         throw new Error(`配置文件 ${path} 不是合法 JSON：${e.message}`);
     }
+}
+/**
+ * 每次调用都从磁盘重新读取配置——配置文件就是唯一事实来源。
+ * 这样新增服务器后无需重启 MCP 服务器。读取或校验失败时抛错，由调用方处理。
+ */
+export function loadServers() {
+    const parsed = readConfig();
+    const path = configPath();
     const list = parsed.servers;
     if (!Array.isArray(list)) {
         throw new Error(`配置文件 ${path} 缺少顶层 "servers" 数组`);
@@ -44,3 +47,55 @@ export function loadServers() {
     }
     return map;
 }
+/** 读取安全策略配置（如有）。 */
+export function loadSecurity() {
+    const parsed = readConfig();
+    return parsed.security ?? {};
+}
+const BUILTIN_RULES = [
+    {
+        // rm -rf /   rm -rf /*   rm -r -f /   rm -fr /   sudo rm -rf /
+        regex: /\brm\b\s+(?:-[a-z]*[rR][^\s]*f[^\s]*|-[a-z]*f[^\s]*[rR][^\s]*|-r\s+-f|-R\s+-f)(?:\s+\S+)*\s+(?:\/\s*\*?\s*$|['"]\/['"]\s*$)/,
+        desc: "rm 递归强制删除根目录",
+    },
+    {
+        // dd if=... of=/dev/sda
+        regex: /\bdd\b\s+.*\bof=\/dev\/(?:sd|hd|nvme|md|vd|xvd|mmcblk|loop|ram)/,
+        desc: "dd 覆盖块设备",
+    },
+    {
+        // mkfs.ext4 /dev/sda1
+        regex: /\bmkfs\.\S+\s+\/dev\/(?:sd|hd|nvme|md|vd|xvd|mmcblk|loop)/,
+        desc: "在块设备上创建文件系统",
+    },
+    {
+        // > /dev/sda  (redirect overwrite)
+        regex: /(?<![|&])\s*>\s*\/dev\/(?:sd|hd|nvme|md|vd|xvd|mmcblk|loop)\b/,
+        desc: "重定向覆盖块设备",
+    },
+    {
+        // fork bomb: :(){ :|:& };:
+        regex: /:\s*\(\s*\)\s*\{/,
+        desc: "疑似 fork 炸弹",
+    },
+];
+/**
+ * 校验命令是否命中安全拦截规则。
+ * 返回 null 表示通过；返回字符串则为拦截原因。
+ */
+export function validateCommand(command, extraPatterns = []) {
+    for (const { regex, desc } of BUILTIN_RULES) {
+        if (regex.test(command))
+            return `内置策略拦截：${desc}`;
+    }
+    for (const p of extraPatterns) {
+        try {
+            if (new RegExp(p).test(command))
+                return `自定义策略拦截（匹配模式: ${p}）`;
+        }
+        catch {
+            // 用户提供的正则无效，跳过不报错。
+        }
+    }
+    return null;
+}

package/dist/index.js

@@ -2,8 +2,8 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-import { configPath, loadServers } from "./config.js";
-import { runCommand } from "./ssh.js";
+import { configPath, loadSecurity, loadServers, validateCommand } from "./config.js";
+import { closeSession, listSessions, openSession, runCommand, } from "./ssh.js";
 import { cancelTransfer, getTransfer, listTransfers, startTransfer, } from "./transfer.js";
 const DEFAULT_TIMEOUT_MS = 60_000;
 function humanBytes(n) {
@@ -89,7 +89,12 @@ server.registerTool("run_command", {
     title: "在远程服务器上执行命令",
     description: "通过 SSH 在指定的远程服务器上执行一条 shell 命令，返回 stdout、stderr 和退出码。" +
         "用 server 参数指定目标服务器的 name（可先用 list_servers 查看）。" +
-        "注意：每条命令在独立的会话中执行，命令之间不保留工作目录或环境变量；" +
+        "可选传入 session（长连接会话 id）复用已有 TCP 连接，省去重复握手和认证；" +
+        "不传则每次新建连接、执行完即断开（短连接）。" +
+        "内置安全策略会拦截 rm -rf /、dd 写块设备、mkfs、fork 炸弹等高危命令，" +
+        "可在 servers.json 的 security.blocked_patterns 中追加自定义正则。" +
+        "传入 force=true 可绕过安全检查（需明确知道自己在做什么）。" +
+        "注意：即便是长连接，每条命令仍在独立 channel 中执行，命令之间不保留工作目录或环境变量；" +
         "需要保持上下文时请自行串接，例如 `cd /var/www && git pull`。",
     inputSchema: {
         server: z
@@ -102,9 +107,17 @@ server.registerTool("run_command", {
             .positive()
             .optional()
             .describe(`命令超时时间（毫秒），默认 ${DEFAULT_TIMEOUT_MS}`),
+        session: z
+            .string()
+            .optional()
+            .describe("长连接会话 id（由 open_session 返回）。不填则使用短连接。"),
+        force: z
+            .boolean()
+            .optional()
+            .describe("传入 true 跳过安全策略检查。请谨慎使用。"),
     },
     annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true },
-}, async ({ server: serverName, command, timeout_ms }) => {
+}, async ({ server: serverName, command, timeout_ms, session, force }) => {
     let servers;
     try {
         servers = loadServers();
@@ -125,8 +138,18 @@ server.registerTool("run_command", {
             isError: true,
         };
     }
+    if (!force) {
+        const security = loadSecurity();
+        const blocked = validateCommand(command, security.blocked_patterns ?? []);
+        if (blocked) {
+            return {
+                content: [{ type: "text", text: `${blocked}\n使用 force=true 可跳过安全检查。` }],
+                isError: true,
+            };
+        }
+    }
     try {
-        const r = await runCommand(cfg, command, timeout_ms ?? DEFAULT_TIMEOUT_MS);
+        const r = await runCommand(cfg, command, timeout_ms ?? DEFAULT_TIMEOUT_MS, session);
         const parts = [
             `服务器: ${cfg.name} (${cfg.username}@${cfg.host}:${cfg.port ?? 22})`,
             `退出码: ${r.code ?? "null"}${r.signal ? `  信号: ${r.signal}` : ""}`,
@@ -146,6 +169,67 @@ server.registerTool("run_command", {
         };
     }
 });
+server.registerTool("open_session", {
+    title: "打开到远程服务器的长连接会话",
+    description: "与指定服务器建立一条持久的 SSH 连接并返回会话 id。该会话可被后续的 run_command " +
+        "通过 session 参数复用，省去重复的 TCP 握手和 SSH 认证开销。" +
+        "注意：即使使用长连接，每次 exec 仍在独立 channel 中执行，命令之间不保留工作目录或环境变量。",
+    inputSchema: {
+        server: z.string().describe("目标服务器的 name（见 list_servers）"),
+    },
+    annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+}, async ({ server: serverName }) => {
+    try {
+        const servers = loadServers();
+        const cfg = servers.get(serverName);
+        if (!cfg) {
+            const names = [...servers.keys()].join(", ") || "（无）";
+            return {
+                content: [{ type: "text", text: `未找到名为 "${serverName}" 的服务器。可用：${names}` }],
+                isError: true,
+            };
+        }
+        const s = await openSession(cfg, 20_000);
+        return { content: [{ type: "text", text: `长连接会话已建立\n  id: ${s.id}\n  服务器: ${s.server}\n  创建时间: ${new Date(s.createdAt).toISOString()}` }] };
+    }
+    catch (e) {
+        return {
+            content: [{ type: "text", text: `打开长连接会话失败：${e.message}` }],
+            isError: true,
+        };
+    }
+});
+server.registerTool("close_session", {
+    title: "关闭长连接会话",
+    description: "关闭由 open_session 建立的长连接会话，释放底层 SSH 连接。",
+    inputSchema: {
+        session: z.string().describe("要关闭的会话 id（由 open_session 返回）"),
+    },
+    annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false },
+}, async ({ session }) => {
+    const ok = closeSession(session);
+    if (!ok) {
+        return {
+            content: [{ type: "text", text: `会话 ${session} 不存在或已断开。` }],
+            isError: true,
+        };
+    }
+    return { content: [{ type: "text", text: `会话 ${session} 已关闭。` }] };
+});
+server.registerTool("list_sessions", {
+    title: "列出当前所有长连接会话",
+    description: "列出当前已打开的所有长连接会话的 id、关联服务器和创建时间。",
+    inputSchema: {},
+    annotations: { readOnlyHint: true, openWorldHint: false },
+}, async () => {
+    const all = listSessions();
+    const text = all.length > 0
+        ? all
+            .map((s) => `  ${s.id} → ${s.server}（${new Date(s.createdAt).toISOString()}）`)
+            .join("\n")
+        : "当前没有长连接会话。";
+    return { content: [{ type: "text", text }] };
+});
 function loadServersOrError() {
     try {
         return { servers: loadServers(), error: null };

package/dist/ssh.js

@@ -1,6 +1,35 @@
 import { readFileSync } from "node:fs";
 import { Client } from "ssh2";
 import { expandHome } from "./config.js";
+const sessions = new Map();
+let sessionCounter = 0;
+export async function openSession(server, timeoutMs) {
+    const conn = await createConnection(server, timeoutMs);
+    const id = `s${++sessionCounter}`;
+    const session = { id, server: server.name, conn, createdAt: Date.now() };
+    sessions.set(id, session);
+    conn.on("close", () => sessions.delete(id));
+    conn.on("error", () => sessions.delete(id));
+    return { id: session.id, server: session.server, createdAt: session.createdAt };
+}
+export function getSession(id) {
+    return sessions.get(id);
+}
+export function closeSession(id) {
+    const session = sessions.get(id);
+    if (!session)
+        return false;
+    session.conn.end();
+    sessions.delete(id);
+    return true;
+}
+export function listSessions() {
+    return [...sessions.values()].map((s) => ({
+        id: s.id,
+        server: s.server,
+        createdAt: s.createdAt,
+    }));
+}
 /** 根据服务器配置组装 ssh2 的连接参数，挑选鉴权方式。 */
 export function buildConnectConfig(server, readyTimeoutMs) {
     const conf = {
@@ -57,11 +86,25 @@ export function createConnection(server, readyTimeoutMs) {
 /**
  * 在指定服务器上执行一条命令，收集 stdout/stderr/退出码后返回。
  *
- * 设计取舍：每次调用建立一条独立连接，执行完即断开。SSH 的 exec channel 本就
- * 无状态，命令之间不会保留工作目录或环境变量——需要时请用 `cd x && cmd` 自行串接。
+ * 短连接模式（默认）：每次调用建立一条独立连接，执行完即断开。
+ * 长连接模式（传入 sessionId）：复用已有 TCP 连接，省去重复握手和认证，
+ *   但注意每次 exec 仍在独立 channel 中执行，命令之间不保留工作目录或环境变量——
+ *   需要时请用 `cd x && cmd` 自行串接。
  */
-export async function runCommand(server, command, timeoutMs) {
-    const conn = await createConnection(server, timeoutMs);
+export async function runCommand(server, command, timeoutMs, sessionId) {
+    let conn;
+    let shouldEnd;
+    if (sessionId) {
+        const session = sessions.get(sessionId);
+        if (!session)
+            throw new Error(`长连接会话 ${sessionId} 不存在或已断开`);
+        conn = session.conn;
+        shouldEnd = false;
+    }
+    else {
+        conn = await createConnection(server, timeoutMs);
+        shouldEnd = true;
+    }
     return new Promise((resolve, reject) => {
         let settled = false;
         const finish = (fn) => {
@@ -70,7 +113,8 @@ export async function runCommand(server, command, timeoutMs) {
             settled = true;
             clearTimeout(timer);
             fn();
-            conn.end();
+            if (shouldEnd)
+                conn.end();
         };
         const timer = setTimeout(() => {
             finish(() => reject(new Error(`命令执行超时（${timeoutMs}ms）`)));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bingzi-233/ssh-mcp",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "通过 SSH/SFTP 让 AI 在多台远程服务器上执行命令并传输大文件（支持断点续传）的 MCP 服务器",
   "type": "module",
   "bin": {