mcp-ssh-pty 1.0.0 → 1.2.0

package/dist/ssh-manager.js

@@ -3,11 +3,20 @@ import { readFileSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
 import { ShellManager } from "./shell-manager.js";
+import { getSanitizer } from "./sanitizer.js";
+// 内置的本地服务器配置
+export const LOCAL_SERVER = {
+    name: "local",
+    host: "localhost",
+    port: 0,
+    username: process.env.USER || process.env.USERNAME || "local",
+};
 export class SSHManager {
     client = null;
     currentServer = null;
     isConnected = false;
     shellManager;
+    isLocalConnection = false;
     constructor() {
         this.shellManager = new ShellManager();
     }
@@ -17,15 +26,49 @@ export class SSHManager {
         }
         return path;
     }
+    /**
+     * 检查是否是本地连接
+     */
+    static isLocalServer(config) {
+        return config.name === "local" || config.host === "local";
+    }
     async connect(config) {
         if (this.isConnected) {
             await this.disconnect();
         }
+        // 检查是否是本地连接
+        if (SSHManager.isLocalServer(config)) {
+            return this.connectLocal();
+        }
+        return this.connectSSH(config);
+    }
+    /**
+     * 本地连接
+     */
+    async connectLocal() {
+        try {
+            await this.shellManager.openLocal();
+            this.isConnected = true;
+            this.isLocalConnection = true;
+            this.currentServer = LOCAL_SERVER;
+        }
+        catch (error) {
+            this.cleanup();
+            throw error;
+        }
+    }
+    /**
+     * SSH 远程连接
+     */
+    async connectSSH(config) {
         return new Promise((resolve, reject) => {
             this.client = new Client();
             this.client.on("ready", async () => {
                 this.isConnected = true;
+                this.isLocalConnection = false;
                 this.currentServer = config;
+                // 注册敏感信息到过滤器
+                this.registerSensitiveInfo(config);
                 // 连接成功后自动打开 shell
                 try {
                     await this.shellManager.open(this.client);
@@ -74,24 +117,43 @@ export class SSHManager {
     async disconnect() {
         // 先关闭 shell
         this.shellManager.close();
-        if (this.client && this.isConnected) {
+        if (this.client && this.isConnected && !this.isLocalConnection) {
             this.client.end();
         }
         this.cleanup();
     }
     cleanup() {
         this.isConnected = false;
+        this.isLocalConnection = false;
         this.currentServer = null;
         this.client = null;
+        // 清除敏感信息
+        getSanitizer().clearSensitiveValues();
+    }
+    /**
+     * 注册服务器配置中的敏感信息
+     */
+    registerSensitiveInfo(config) {
+        const sanitizer = getSanitizer();
+        sanitizer.addSensitiveValues([
+            config.host,
+            config.password,
+            config.passphrase,
+            config.username,
+            config.privateKeyPath,
+        ]);
     }
     getShellManager() {
         return this.shellManager;
     }
+    isLocal() {
+        return this.isLocalConnection;
+    }
     getStatus() {
         return {
             connected: this.isConnected,
             serverName: this.currentServer?.name || null,
-            host: this.currentServer?.host || null,
+            host: this.isLocalConnection ? "local" : (this.currentServer?.host || null),
             username: this.currentServer?.username || null,
         };
     }

package/dist/tools.js

@@ -1,55 +1,129 @@
 import { z } from "zod";
+import { LOCAL_SERVER } from "./ssh-manager.js";
+import { sanitize } from "./sanitizer.js";
+/**
+ * 过滤 ShellResult 中的敏感信息
+ */
+function sanitizeResult(result) {
+    return {
+        ...result,
+        output: sanitize(result.output),
+        message: sanitize(result.message),
+    };
+}
 export function registerTools(server, sshManager, configManager) {
-    // 工具1: ssh - 连接管理 + 快捷命令
     server.registerTool("ssh", {
-        description: `SSH 远程服务器连接管理和命令执行。使用持久 PTY Shell，支持交互式操作。
-
-## 操作类型 (action)
-- list: 列出所有可用服务器
-- connect: 连接服务器（需提供 server 参数）
-- disconnect: 断开当前连接
-- status: 查看连接状态和 shell 缓冲区行数
-
-## 快捷命令 (command)
-直接提供 command 参数可执行命令，无需指定 action。
-
-## 智能输出检测
-命令执行后自动检测完成状态：
-- 快速命令（<2秒）：检测到提示符后返回完整输出
-- 慢速命令（2-5秒）：返回完整输出，标记 slow=true
-- 超时命令（>5秒）：自动截断到最近 200 行，标记 truncated=true
-- 持续输出（如 tail -f）：输出稳定后返回，标记 waiting=true
-
-## 返回字段说明
-- output: 命令输出内容
-- totalLines: 总行数
-- complete: 是否检测到命令完成（出现提示符）
-- truncated: 是否被截断（超时时）
-- slow: 是否耗时较长
-- waiting: 命令可能仍在运行或等待输入
-- message: 状态描述
-
-## 使用示例
-1. 列出服务器: ssh({ action: "list" })
-2. 连接: ssh({ action: "connect", server: "my-server" })
-3. 执行命令: ssh({ command: "ls -la" })
-4. 查看状态: ssh({ action: "status" })
-5. 断开: ssh({ action: "disconnect" })
-
-## 注意事项
-- 如果 truncated=true，使用 ssh_shell read 获取完整输出
-- 如果 waiting=true，命令可能需要输入或是持续运行的程序，使用 ssh_shell 继续交互`,
+        description: `SSH 远程服务器连接管理和 PTY Shell 交互。
+
+## 连接管理 (action)
+- list: 列出所有可用服务器
+- connect: 连接服务器（需提供 server 参数）
+- disconnect: 断开当前连接
+- status: 查看连接状态和 shell 缓冲区行数
+
+## 命令执行 (command)
+直接提供 command 参数执行命令，支持交互式程序。
+
+## Shell 控制
+- read: 设为 true 读取缓冲区（配合 lines/offset/clear）
+- signal: 发送信号 SIGINT(Ctrl+C)/SIGTSTP(Ctrl+Z)/SIGQUIT
+
+## 智能输出检测
+- 快速命令（<2秒）：检测到提示符后返回
+- 慢速命令（2-5秒）：标记 slow=true
+- 超时命令（>5秒）：截断到最近 200 行，标记 truncated=true
+- 持续输出：输出稳定后返回，标记 waiting=true
+
+## 返回字段
+- output: 命令输出
+- totalLines: 总行数
+- complete: 是否完成（出现提示符）
+- truncated: 是否被截断
+- slow: 是否耗时较长
+- waiting: 可能在等待输入或仍在运行
+
+## 使用示例
+
+### 基本操作
+ssh({ action: "list" })
+ssh({ action: "connect", server: "my-server" })
+ssh({ command: "ls -la" })
+ssh({ action: "status" })
+ssh({ action: "disconnect" })
+
+### 读取缓冲区
+ssh({ read: true })                    # 读取最近 20 行
+ssh({ read: true, lines: -1 })         # 读取全部
+ssh({ read: true, lines: 100 })        # 读取 100 行
+
+### 交互式程序
+ssh({ command: "mysql -u root -p" })   # 启动 mysql
+ssh({ command: "password123" })         # 输入密码
+ssh({ command: "SHOW DATABASES;" })     # 执行 SQL
+
+### 信号控制
+ssh({ command: "tail -f /var/log/syslog" })
+ssh({ read: true })                     # 查看输出
+ssh({ signal: "SIGINT" })               # Ctrl+C 停止`,
         inputSchema: {
             action: z
                 .enum(["list", "connect", "disconnect", "status"])
                 .optional()
-                .describe("操作类型：list/connect/disconnect/status"),
+                .describe("连接管理操作"),
             server: z.string().optional().describe("服务器名称（connect 时必填）"),
-            command: z.string().optional().describe("要执行的命令（直接执行，无需 action）"),
+            command: z.string().optional().describe("要执行的命令"),
+            read: z.boolean().optional().describe("读取缓冲区"),
+            lines: z.number().optional().describe("读取行数，默认 20，-1 返回全部"),
+            offset: z.number().optional().describe("读取起始偏移，默认 0"),
+            clear: z.boolean().optional().describe("读取后清空缓冲区"),
+            signal: z
+                .enum(["SIGINT", "SIGTSTP", "SIGQUIT"])
+                .optional()
+                .describe("发送信号：SIGINT(Ctrl+C)/SIGTSTP(Ctrl+Z)/SIGQUIT"),
         },
-    }, async ({ action, server: serverName, command }) => {
+    }, async ({ action, server: serverName, command, read, lines, offset, clear, signal }) => {
         try {
-            // 快捷命令模式
+            // 1. 发送信号
+            if (signal) {
+                const status = sshManager.getStatus();
+                if (!status.connected) {
+                    return {
+                        content: [{ type: "text", text: "未连接服务器" }],
+                        isError: true,
+                    };
+                }
+                const shellManager = sshManager.getShellManager();
+                const success = shellManager.sendSignal(signal);
+                return {
+                    content: [{
+                            type: "text",
+                            text: success ? `已发送 ${signal}` : `发送 ${signal} 失败`,
+                        }],
+                    isError: !success,
+                };
+            }
+            // 2. 读取缓冲区
+            if (read) {
+                const status = sshManager.getStatus();
+                if (!status.connected) {
+                    return {
+                        content: [{ type: "text", text: "未连接服务器" }],
+                        isError: true,
+                    };
+                }
+                const shellManager = sshManager.getShellManager();
+                const result = sanitizeResult(shellManager.read(lines, offset, clear));
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                server: status.serverName,
+                                ...result,
+                            }, null, 2),
+                        }],
+                };
+            }
+            // 3. 执行命令
             if (command) {
                 const status = sshManager.getStatus();
                 if (!status.connected) {
@@ -59,7 +133,7 @@ export function registerTools(server, sshManager, configManager) {
                     };
                 }
                 const shellManager = sshManager.getShellManager();
-                const result = await shellManager.send(command);
+                const result = sanitizeResult(await shellManager.send(command));
                 return {
                     content: [{
                             type: "text",
@@ -72,17 +146,25 @@ export function registerTools(server, sshManager, configManager) {
                     isError: !result.complete && !result.waiting,
                 };
             }
-            // 默认 action 为 status
+            // 4. 连接管理操作
             const effectiveAction = action || "status";
             switch (effectiveAction) {
                 case "list": {
                     const servers = configManager.listServers();
                     const status = sshManager.getStatus();
-                    // 只返回服务器名称，不暴露 IP/端口/用户名
-                    const list = servers.map((s) => ({
-                        name: s.name,
-                        connected: status.serverName === s.name,
-                    }));
+                    // 添加内置的 local 服务器
+                    const list = [
+                        {
+                            name: LOCAL_SERVER.name,
+                            connected: status.serverName === LOCAL_SERVER.name,
+                            type: "built-in",
+                        },
+                        ...servers.map((s) => ({
+                            name: s.name,
+                            connected: status.serverName === s.name,
+                            type: "configured",
+                        })),
+                    ];
                     return {
                         content: [{ type: "text", text: JSON.stringify(list, null, 2) }],
                     };
@@ -94,9 +176,19 @@ export function registerTools(server, sshManager, configManager) {
                             isError: true,
                         };
                     }
+                    // 检查是否是本地连接
+                    if (serverName === "local") {
+                        await sshManager.connect(LOCAL_SERVER);
+                        return {
+                            content: [{
+                                    type: "text",
+                                    text: "成功连接到本地 Shell",
+                                }],
+                        };
+                    }
                     const serverConfig = configManager.getServer(serverName);
                     if (!serverConfig) {
-                        const available = configManager.listServers().map((s) => s.name);
+                        const available = ["local", ...configManager.listServers().map((s) => s.name)];
                         return {
                             content: [{
                                     type: "text",
@@ -106,7 +198,6 @@ export function registerTools(server, sshManager, configManager) {
                         };
                     }
                     await sshManager.connect(serverConfig);
-                    // 不暴露 IP/端口/用户名
                     return {
                         content: [{
                                 type: "text",
@@ -131,7 +222,6 @@ export function registerTools(server, sshManager, configManager) {
                     const status = sshManager.getStatus();
                     const shellManager = sshManager.getShellManager();
                     if (status.connected) {
-                        // 不暴露 host/username
                         return {
                             content: [{
                                     type: "text",
@@ -160,169 +250,4 @@ export function registerTools(server, sshManager, configManager) {
             };
         }
     });
-    // 工具2: ssh_shell - PTY Shell 会话控制
-    server.registerTool("ssh_shell", {
-        description: `PTY Shell 高级会话控制。用于交互式程序、长输出处理、信号发送等场景。
-
-## 操作类型 (action)
-
-### send - 发送命令或输入
-发送命令到 shell，智能等待完成。适用于：
-- 需要多次交互的程序（如 mysql, python 交互模式）
-- 需要发送特定输入（如回答 y/n 提示）
-参数：input（必填）- 要发送的内容
-
-### read - 读取缓冲区
-获取 shell 输出缓冲区内容。适用于：
-- 命令被截断后获取完整输出
-- 查看持续运行命令的最新输出
-- 分页读取大量输出
-参数：
-- lines: 返回行数（默认全部）
-- offset: 起始偏移（默认 0）
-- clear: 读取后清空缓冲区（默认 false）
-
-### signal - 发送信号
-向当前进程发送控制信号：
-- SIGINT: Ctrl+C，中断当前命令
-- SIGTSTP: Ctrl+Z，暂停进程
-- SIGQUIT: Ctrl+\，退出进程
-参数：signal（必填）
-
-### close - 关闭 shell
-关闭当前 shell 会话，但保持 SSH 连接。
-
-## 使用场景示例
-
-### 场景1：查看大文件
-\`\`\`
-ssh({ command: "cat /var/log/syslog" })
-# 返回 truncated=true，只有最近 200 行
-ssh_shell({ action: "read", lines: 500, offset: 0 })
-# 获取前 500 行
-\`\`\`
-
-### 场景2：交互式程序
-\`\`\`
-ssh({ command: "mysql -u root -p" })
-# 返回 waiting=true，等待密码
-ssh_shell({ action: "send", input: "password123" })
-# 发送密码
-ssh_shell({ action: "send", input: "SHOW DATABASES;" })
-# 执行 SQL
-\`\`\`
-
-### 场景3：监控日志
-\`\`\`
-ssh({ command: "tail -f /var/log/nginx/access.log" })
-# 返回 waiting=true
-# ... 等待一段时间 ...
-ssh_shell({ action: "read" })
-# 查看新日志
-ssh_shell({ action: "signal", signal: "SIGINT" })
-# 停止 tail
-\`\`\`
-
-### 场景4：vim 等全屏程序
-\`\`\`
-ssh_shell({ action: "send", input: "vim config.txt" })
-ssh_shell({ action: "send", input: "i" })  # 进入插入模式
-ssh_shell({ action: "send", input: "new content" })
-ssh_shell({ action: "send", input: "\\x1b" })  # ESC 键
-ssh_shell({ action: "send", input: ":wq" })  # 保存退出
-\`\`\``,
-        inputSchema: {
-            action: z
-                .enum(["send", "read", "signal", "close"])
-                .describe("操作类型：send/read/signal/close"),
-            input: z.string().optional().describe("send 时的命令或输入内容"),
-            signal: z
-                .enum(["SIGINT", "SIGTSTP", "SIGQUIT"])
-                .optional()
-                .describe("signal 时的信号类型：SIGINT(Ctrl+C)/SIGTSTP(Ctrl+Z)/SIGQUIT"),
-            lines: z.number().optional().describe("read 时返回的行数，默认全部"),
-            offset: z.number().optional().describe("read 时的起始行偏移，默认 0"),
-            clear: z.boolean().optional().describe("read 后是否清空缓冲区，默认 false"),
-        },
-    }, async ({ action, input, signal, lines, offset, clear }) => {
-        try {
-            const status = sshManager.getStatus();
-            if (!status.connected) {
-                return {
-                    content: [{ type: "text", text: "未连接服务器，请先使用 ssh 工具连接" }],
-                    isError: true,
-                };
-            }
-            const shellManager = sshManager.getShellManager();
-            if (!shellManager.isOpen()) {
-                return {
-                    content: [{ type: "text", text: "Shell 未打开" }],
-                    isError: true,
-                };
-            }
-            switch (action) {
-                case "send": {
-                    if (!input) {
-                        return {
-                            content: [{ type: "text", text: "缺少 input 参数" }],
-                            isError: true,
-                        };
-                    }
-                    const result = await shellManager.send(input);
-                    return {
-                        content: [{
-                                type: "text",
-                                text: JSON.stringify({
-                                    server: status.serverName,
-                                    input,
-                                    ...result,
-                                }, null, 2),
-                            }],
-                        isError: !result.complete && !result.waiting,
-                    };
-                }
-                case "read": {
-                    const result = shellManager.read(lines, offset, clear);
-                    return {
-                        content: [{
-                                type: "text",
-                                text: JSON.stringify({
-                                    server: status.serverName,
-                                    ...result,
-                                }, null, 2),
-                            }],
-                    };
-                }
-                case "signal": {
-                    if (!signal) {
-                        return {
-                            content: [{ type: "text", text: "缺少 signal 参数" }],
-                            isError: true,
-                        };
-                    }
-                    const success = shellManager.sendSignal(signal);
-                    return {
-                        content: [{
-                                type: "text",
-                                text: success ? `已发送 ${signal}` : `发送 ${signal} 失败`,
-                            }],
-                        isError: !success,
-                    };
-                }
-                case "close": {
-                    shellManager.close();
-                    return {
-                        content: [{ type: "text", text: "Shell 已关闭" }],
-                    };
-                }
-            }
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            return {
-                content: [{ type: "text", text: `错误: ${message}` }],
-                isError: true,
-            };
-        }
-    });
 }

package/package.json

@@ -1,46 +1,47 @@
-{
-  "name": "mcp-ssh-pty",
-  "version": "1.0.0",
-  "description": "MCP Server for SSH remote command execution with PTY shell support",
-  "type": "module",
-  "main": "dist/index.js",
-  "bin": {
-    "mcp-ssh-pty": "./dist/index.js"
-  },
-  "scripts": {
-    "build": "tsc",
-    "start": "node dist/index.js",
-    "dev": "tsc --watch",
-    "prepublishOnly": "npm run build"
-  },
-  "keywords": [
-    "mcp",
-    "ssh",
-    "claude",
-    "anthropic",
-    "ai",
-    "remote",
-    "shell",
-    "pty"
-  ],
-  "author": "me",
-  "license": "MIT",
-
-  "files": [
-    "dist",
-    "ssh-servers.example.json"
-  ],
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0",
-    "ssh2": "^1.16.0",
-    "zod": "^3.24.0"
-  },
-  "devDependencies": {
-    "@types/node": "^22.0.0",
-    "@types/ssh2": "^1.15.0",
-    "typescript": "^5.7.0"
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  }
-}
+{
+  "name": "mcp-ssh-pty",
+  "version": "1.2.0",
+  "description": "MCP Server for SSH remote command execution with PTY shell support",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "mcp-ssh-pty": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "ssh",
+    "claude",
+    "anthropic",
+    "ai",
+    "remote",
+    "shell",
+    "pty"
+  ],
+  "author": "me",
+  "license": "MIT",
+  "files": [
+    "dist",
+    "ssh-servers.example.json"
+  ],
+  "dependencies": {
+    "@inquirer/prompts": "^8.1.0",
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "commander": "^14.0.2",
+    "ssh2": "^1.16.0",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/ssh2": "^1.15.0",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/ssh-servers.example.json

@@ -1,18 +1,18 @@
-{
-  "servers": [
-    {
-      "name": "my-server",
-      "host": "192.168.1.100",
-      "port": 22,
-      "username": "root",
-      "privateKeyPath": "~/.ssh/id_rsa"
-    },
-    {
-      "name": "dev-server",
-      "host": "10.0.0.50",
-      "port": 22,
-      "username": "ubuntu",
-      "password": "your-password"
-    }
-  ]
-}
+{
+  "servers": [
+    {
+      "name": "my-server",
+      "host": "192.168.1.100",
+      "port": 22,
+      "username": "root",
+      "privateKeyPath": "~/.ssh/id_rsa"
+    },
+    {
+      "name": "dev-server",
+      "host": "10.0.0.50",
+      "port": 22,
+      "username": "ubuntu",
+      "password": "your-password"
+    }
+  ]
+}