mcp-ssh-pty 1.0.0

package/dist/config.d.ts

@@ -0,0 +1,12 @@
+import { ServersConfig, ServerConfig } from "./types.js";
+export declare class ConfigManager {
+    private config;
+    private configPath;
+    constructor(configPath?: string);
+    private resolveConfigPath;
+    private expandPath;
+    load(): ServersConfig;
+    getServer(name: string): ServerConfig | undefined;
+    listServers(): ServerConfig[];
+    getConfigPath(): string;
+}

package/dist/config.js

@@ -0,0 +1,58 @@
+import { readFileSync, existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+export class ConfigManager {
+    config = null;
+    configPath;
+    constructor(configPath) {
+        this.configPath = configPath || this.resolveConfigPath();
+    }
+    resolveConfigPath() {
+        // 1. 优先使用环境变量
+        if (process.env.SSH_MCP_CONFIG_PATH) {
+            return this.expandPath(process.env.SSH_MCP_CONFIG_PATH);
+        }
+        // 2. 查找项目目录下的 .claude/ssh-servers.json
+        const projectPath = join(process.cwd(), ".claude", "ssh-servers.json");
+        if (existsSync(projectPath)) {
+            return projectPath;
+        }
+        // 3. 查找用户目录下的 ~/.claude/ssh-servers.json
+        return join(homedir(), ".claude", "ssh-servers.json");
+    }
+    expandPath(path) {
+        if (path.startsWith("~")) {
+            return join(homedir(), path.slice(1));
+        }
+        return path;
+    }
+    load() {
+        if (!existsSync(this.configPath)) {
+            throw new Error(`配置文件不存在: ${this.configPath}\n请创建配置文件或设置 SSH_MCP_CONFIG_PATH 环境变量`);
+        }
+        try {
+            const content = readFileSync(this.configPath, "utf-8");
+            this.config = JSON.parse(content);
+            return this.config;
+        }
+        catch (error) {
+            if (error instanceof SyntaxError) {
+                throw new Error(`配置文件格式错误: ${this.configPath}\n${error.message}`);
+            }
+            throw error;
+        }
+    }
+    getServer(name) {
+        if (!this.config)
+            this.load();
+        return this.config.servers.find((s) => s.name === name);
+    }
+    listServers() {
+        if (!this.config)
+            this.load();
+        return this.config.servers;
+    }
+    getConfigPath() {
+        return this.configPath;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { SSHManager } from "./ssh-manager.js";
+import { ConfigManager } from "./config.js";
+import { registerTools } from "./tools.js";
+async function main() {
+    const server = new McpServer({
+        name: "ssh-mcp-server",
+        version: "1.0.0",
+    });
+    const sshManager = new SSHManager();
+    const configManager = new ConfigManager();
+    registerTools(server, sshManager, configManager);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("SSH MCP Server 已启动");
+    console.error(`配置文件路径: ${configManager.getConfigPath()}`);
+    process.on("SIGINT", async () => {
+        console.error("收到 SIGINT，正在关闭...");
+        await sshManager.disconnect();
+        process.exit(0);
+    });
+    process.on("SIGTERM", async () => {
+        console.error("收到 SIGTERM，正在关闭...");
+        await sshManager.disconnect();
+        process.exit(0);
+    });
+}
+main().catch((error) => {
+    console.error("启动失败:", error);
+    process.exit(1);
+});

package/dist/shell-manager.d.ts

@@ -0,0 +1,50 @@
+import { Client } from "ssh2";
+import { ShellResult, ShellConfig } from "./types.js";
+export declare class ShellManager {
+    private shell;
+    private outputBuffer;
+    private outputLines;
+    private lastOutputTime;
+    private config;
+    constructor(config?: Partial<ShellConfig>);
+    /**
+     * 打开 PTY Shell（在 SSH 连接成功后调用）
+     */
+    open(client: Client): Promise<void>;
+    /**
+     * 检查 shell 是否已打开
+     */
+    isOpen(): boolean;
+    /**
+     * 发送命令，智能等待完成
+     */
+    send(input: string, config?: Partial<ShellConfig>): Promise<ShellResult>;
+    /**
+     * 读取缓冲区内容
+     */
+    read(lines?: number, offset?: number, clear?: boolean): ShellResult;
+    /**
+     * 发送信号
+     */
+    sendSignal(signal: "SIGINT" | "SIGTSTP" | "SIGQUIT"): boolean;
+    /**
+     * 关闭 shell
+     */
+    close(): void;
+    /**
+     * 获取当前缓冲区行数
+     */
+    getBufferLineCount(): number;
+    /**
+     * 私有方法：等待命令完成
+     */
+    private waitForCompletion;
+    /**
+     * 私有方法：检测提示符
+     */
+    private detectPrompt;
+    /**
+     * 私有方法：构建结果对象
+     */
+    private buildResult;
+}

package/dist/shell-manager.js

@@ -0,0 +1,256 @@
+const DEFAULT_CONFIG = {
+    quickTimeout: 2000,
+    maxTimeout: 5000,
+    maxLines: 200,
+    maxBufferLines: 10000,
+};
+export class ShellManager {
+    shell = null;
+    outputBuffer = "";
+    outputLines = [];
+    lastOutputTime = 0;
+    config;
+    constructor(config) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * 打开 PTY Shell（在 SSH 连接成功后调用）
+     */
+    async open(client) {
+        return new Promise((resolve, reject) => {
+            client.shell({ term: "xterm-256color", rows: 40, cols: 120 }, (err, stream) => {
+                if (err) {
+                    reject(new Error(`无法打开 shell: ${err.message}`));
+                    return;
+                }
+                this.shell = stream;
+                this.outputBuffer = "";
+                this.outputLines = [];
+                this.lastOutputTime = Date.now();
+                // 监听数据事件
+                stream.on("data", (data) => {
+                    const text = data.toString();
+                    this.outputBuffer += text;
+                    this.lastOutputTime = Date.now();
+                    // 按行分割并存储
+                    const lines = this.outputBuffer.split("\n");
+                    // 最后一个可能是不完整的行，保留在 buffer
+                    this.outputBuffer = lines.pop() || "";
+                    this.outputLines.push(...lines);
+                    // 限制缓冲区大小
+                    if (this.outputLines.length > this.config.maxBufferLines) {
+                        this.outputLines = this.outputLines.slice(-this.config.maxBufferLines);
+                    }
+                });
+                // 监听关闭事件
+                stream.on("close", () => {
+                    this.shell = null;
+                });
+                stream.on("error", (err) => {
+                    console.error("Shell error:", err.message);
+                });
+                // 等待初始提示符
+                setTimeout(() => {
+                    resolve();
+                }, 500);
+            });
+        });
+    }
+    /**
+     * 检查 shell 是否已打开
+     */
+    isOpen() {
+        return this.shell !== null;
+    }
+    /**
+     * 发送命令，智能等待完成
+     */
+    async send(input, config) {
+        if (!this.shell) {
+            return {
+                output: "",
+                totalLines: 0,
+                complete: false,
+                message: "Shell 未打开，请先连接服务器",
+            };
+        }
+        const mergedConfig = { ...this.config, ...config };
+        // 清空之前的输出，准备收集新输出
+        const startLineCount = this.outputLines.length;
+        this.outputBuffer = "";
+        // 发送命令
+        this.shell.write(input + "\n");
+        // 等待命令完成
+        return await this.waitForCompletion(startLineCount, mergedConfig);
+    }
+    /**
+     * 读取缓冲区内容
+     */
+    read(lines, offset, clear) {
+        const startIdx = offset || 0;
+        const endIdx = lines ? startIdx + lines : this.outputLines.length;
+        const selectedLines = this.outputLines.slice(startIdx, endIdx);
+        // 包含不完整的最后一行
+        let output = selectedLines.join("\n");
+        if (this.outputBuffer && (!lines || endIdx >= this.outputLines.length)) {
+            output += (output ? "\n" : "") + this.outputBuffer;
+        }
+        const result = {
+            output,
+            totalLines: this.outputLines.length + (this.outputBuffer ? 1 : 0),
+            complete: true,
+            message: `读取了 ${selectedLines.length} 行`,
+        };
+        if (clear) {
+            this.outputLines = [];
+            this.outputBuffer = "";
+        }
+        return result;
+    }
+    /**
+     * 发送信号
+     */
+    sendSignal(signal) {
+        if (!this.shell) {
+            return false;
+        }
+        // 通过写入控制字符来模拟信号
+        const signalChars = {
+            SIGINT: "\x03", // Ctrl+C
+            SIGTSTP: "\x1a", // Ctrl+Z
+            SIGQUIT: "\x1c", // Ctrl+\
+        };
+        const char = signalChars[signal];
+        if (char) {
+            this.shell.write(char);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * 关闭 shell
+     */
+    close() {
+        if (this.shell) {
+            this.shell.end();
+            this.shell = null;
+        }
+        this.outputLines = [];
+        this.outputBuffer = "";
+    }
+    /**
+     * 获取当前缓冲区行数
+     */
+    getBufferLineCount() {
+        return this.outputLines.length + (this.outputBuffer ? 1 : 0);
+    }
+    /**
+     * 私有方法：等待命令完成
+     */
+    async waitForCompletion(startLineCount, config) {
+        const startTime = Date.now();
+        let lastCheckTime = startTime;
+        let stableCount = 0;
+        return new Promise((resolve) => {
+            const check = setInterval(() => {
+                const elapsed = Date.now() - startTime;
+                const timeSinceLastOutput = Date.now() - this.lastOutputTime;
+                // 获取新输出
+                const newLines = this.outputLines.slice(startLineCount);
+                const currentOutput = newLines.join("\n") +
+                    (this.outputBuffer ? "\n" + this.outputBuffer : "");
+                const lastLine = this.outputBuffer ||
+                    (newLines.length > 0 ? newLines[newLines.length - 1] : "");
+                const hasPrompt = this.detectPrompt(lastLine);
+                // 检测输出是否稳定（连续 3 次检查没有新输出）
+                if (this.lastOutputTime <= lastCheckTime) {
+                    stableCount++;
+                }
+                else {
+                    stableCount = 0;
+                }
+                lastCheckTime = Date.now();
+                // 策略 A: 快速 + 提示符（< 2秒）
+                if (elapsed <= config.quickTimeout && hasPrompt && stableCount >= 2) {
+                    clearInterval(check);
+                    resolve(this.buildResult(currentOutput, newLines.length, true, false, false, false));
+                    return;
+                }
+                // 策略 B: 慢速 + 提示符（2-5秒）
+                if (elapsed > config.quickTimeout && elapsed <= config.maxTimeout && hasPrompt && stableCount >= 2) {
+                    clearInterval(check);
+                    resolve(this.buildResult(currentOutput, newLines.length, true, false, true, false));
+                    return;
+                }
+                // 策略 C: 超时（> 5秒）
+                if (elapsed > config.maxTimeout) {
+                    clearInterval(check);
+                    const truncated = newLines.length > config.maxLines;
+                    const truncatedLines = truncated
+                        ? newLines.slice(-config.maxLines)
+                        : newLines;
+                    const truncatedOutput = truncatedLines.join("\n") +
+                        (this.outputBuffer ? "\n" + this.outputBuffer : "");
+                    resolve(this.buildResult(truncatedOutput, newLines.length, hasPrompt, truncated, true, !hasPrompt));
+                    return;
+                }
+                // 策略 D: 输出稳定但无提示符（500ms 无新输出）
+                if (timeSinceLastOutput > 500 && stableCount >= 5 && elapsed > 1000) {
+                    clearInterval(check);
+                    resolve(this.buildResult(currentOutput, newLines.length, false, false, false, true));
+                    return;
+                }
+            }, 100);
+        });
+    }
+    /**
+     * 私有方法：检测提示符
+     */
+    detectPrompt(line) {
+        // 移除 ANSI 转义序列
+        const cleanLine = line.replace(/\x1b\[[0-9;]*m/g, "").trim();
+        if (!cleanLine)
+            return false;
+        // 常见提示符模式
+        const patterns = [
+            /\$\s*$/, // $ 结尾（普通用户）
+            /#\s*$/, // # 结尾（root 用户）
+            />\s*$/, // > 结尾（Windows/PowerShell）
+            /\]\$\s*$/, // ]$ 结尾（[user@host dir]$）
+            /\]#\s*$/, // ]# 结尾（[user@host dir]#）
+            /\)\s*[$#>]\s*$/, // )$ 或 )# 结尾（一些自定义 PS1）
+            /~\s*[$#>]\s*$/, // ~$ 结尾
+            /@.*:\s*[$#>]\s*$/, // user@host: $ 格式
+        ];
+        return patterns.some((p) => p.test(cleanLine));
+    }
+    /**
+     * 私有方法：构建结果对象
+     */
+    buildResult(output, totalLines, complete, truncated, slow, waiting) {
+        let message = "";
+        if (complete) {
+            message = slow
+                ? `命令执行完成（耗时较长），共 ${totalLines} 行`
+                : `命令执行完成，共 ${totalLines} 行`;
+        }
+        else if (truncated) {
+            message = `输出超时，已截断至最近 ${this.config.maxLines} 行（共 ${totalLines} 行）。使用 read 获取完整输出。`;
+        }
+        else if (waiting) {
+            message = `输出已稳定，命令可能在等待输入或仍在运行。共 ${totalLines} 行。`;
+        }
+        else {
+            message = `共 ${totalLines} 行`;
+        }
+        return {
+            output,
+            totalLines,
+            complete,
+            truncated: truncated || undefined,
+            slow: slow || undefined,
+            waiting: waiting || undefined,
+            message,
+        };
+    }
+}

package/dist/ssh-manager.d.ts

@@ -0,0 +1,15 @@
+import { ServerConfig, ConnectionStatus } from "./types.js";
+import { ShellManager } from "./shell-manager.js";
+export declare class SSHManager {
+    private client;
+    private currentServer;
+    private isConnected;
+    private shellManager;
+    constructor();
+    private expandPath;
+    connect(config: ServerConfig): Promise<void>;
+    disconnect(): Promise<void>;
+    private cleanup;
+    getShellManager(): ShellManager;
+    getStatus(): ConnectionStatus;
+}

package/dist/ssh-manager.js

@@ -0,0 +1,98 @@
+import { Client } from "ssh2";
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { ShellManager } from "./shell-manager.js";
+export class SSHManager {
+    client = null;
+    currentServer = null;
+    isConnected = false;
+    shellManager;
+    constructor() {
+        this.shellManager = new ShellManager();
+    }
+    expandPath(path) {
+        if (path.startsWith("~")) {
+            return join(homedir(), path.slice(1));
+        }
+        return path;
+    }
+    async connect(config) {
+        if (this.isConnected) {
+            await this.disconnect();
+        }
+        return new Promise((resolve, reject) => {
+            this.client = new Client();
+            this.client.on("ready", async () => {
+                this.isConnected = true;
+                this.currentServer = config;
+                // 连接成功后自动打开 shell
+                try {
+                    await this.shellManager.open(this.client);
+                    resolve();
+                }
+                catch (err) {
+                    this.cleanup();
+                    reject(err);
+                }
+            });
+            this.client.on("error", (err) => {
+                this.cleanup();
+                reject(err);
+            });
+            this.client.on("close", () => {
+                this.cleanup();
+            });
+            const connectConfig = {
+                host: config.host,
+                port: config.port || 22,
+                username: config.username,
+            };
+            if (config.privateKeyPath) {
+                try {
+                    const keyPath = this.expandPath(config.privateKeyPath);
+                    connectConfig.privateKey = readFileSync(keyPath);
+                    if (config.passphrase) {
+                        connectConfig.passphrase = config.passphrase;
+                    }
+                }
+                catch (error) {
+                    reject(new Error(`无法读取私钥文件: ${config.privateKeyPath}`));
+                    return;
+                }
+            }
+            else if (config.password) {
+                connectConfig.password = config.password;
+            }
+            else {
+                reject(new Error("必须提供 password 或 privateKeyPath"));
+                return;
+            }
+            this.client.connect(connectConfig);
+        });
+    }
+    async disconnect() {
+        // 先关闭 shell
+        this.shellManager.close();
+        if (this.client && this.isConnected) {
+            this.client.end();
+        }
+        this.cleanup();
+    }
+    cleanup() {
+        this.isConnected = false;
+        this.currentServer = null;
+        this.client = null;
+    }
+    getShellManager() {
+        return this.shellManager;
+    }
+    getStatus() {
+        return {
+            connected: this.isConnected,
+            serverName: this.currentServer?.name || null,
+            host: this.currentServer?.host || null,
+            username: this.currentServer?.username || null,
+        };
+    }
+}

package/dist/tools.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SSHManager } from "./ssh-manager.js";
+import { ConfigManager } from "./config.js";
+export declare function registerTools(server: McpServer, sshManager: SSHManager, configManager: ConfigManager): void;

package/dist/tools.js

@@ -0,0 +1,328 @@
+import { z } from "zod";
+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 继续交互`,
+        inputSchema: {
+            action: z
+                .enum(["list", "connect", "disconnect", "status"])
+                .optional()
+                .describe("操作类型：list/connect/disconnect/status"),
+            server: z.string().optional().describe("服务器名称（connect 时必填）"),
+            command: z.string().optional().describe("要执行的命令（直接执行，无需 action）"),
+        },
+    }, async ({ action, server: serverName, command }) => {
+        try {
+            // 快捷命令模式
+            if (command) {
+                const status = sshManager.getStatus();
+                if (!status.connected) {
+                    return {
+                        content: [{ type: "text", text: "未连接服务器，请先使用 ssh({ action: 'connect', server: '服务器名' }) 连接" }],
+                        isError: true,
+                    };
+                }
+                const shellManager = sshManager.getShellManager();
+                const result = await shellManager.send(command);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                server: status.serverName,
+                                command,
+                                ...result,
+                            }, null, 2),
+                        }],
+                    isError: !result.complete && !result.waiting,
+                };
+            }
+            // 默认 action 为 status
+            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,
+                    }));
+                    return {
+                        content: [{ type: "text", text: JSON.stringify(list, null, 2) }],
+                    };
+                }
+                case "connect": {
+                    if (!serverName) {
+                        return {
+                            content: [{ type: "text", text: "缺少 server 参数" }],
+                            isError: true,
+                        };
+                    }
+                    const serverConfig = configManager.getServer(serverName);
+                    if (!serverConfig) {
+                        const available = configManager.listServers().map((s) => s.name);
+                        return {
+                            content: [{
+                                    type: "text",
+                                    text: `服务器 '${serverName}' 不存在。可用服务器: ${available.join(", ")}`,
+                                }],
+                            isError: true,
+                        };
+                    }
+                    await sshManager.connect(serverConfig);
+                    // 不暴露 IP/端口/用户名
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `成功连接到 '${serverName}'，PTY Shell 已就绪`,
+                            }],
+                    };
+                }
+                case "disconnect": {
+                    const status = sshManager.getStatus();
+                    if (!status.connected) {
+                        return {
+                            content: [{ type: "text", text: "当前没有活跃的连接" }],
+                        };
+                    }
+                    const name = status.serverName;
+                    await sshManager.disconnect();
+                    return {
+                        content: [{ type: "text", text: `已断开与 '${name}' 的连接` }],
+                    };
+                }
+                case "status": {
+                    const status = sshManager.getStatus();
+                    const shellManager = sshManager.getShellManager();
+                    if (status.connected) {
+                        // 不暴露 host/username
+                        return {
+                            content: [{
+                                    type: "text",
+                                    text: JSON.stringify({
+                                        connected: true,
+                                        server: status.serverName,
+                                        shellOpen: shellManager.isOpen(),
+                                        bufferLines: shellManager.getBufferLineCount(),
+                                    }, null, 2),
+                                }],
+                        };
+                    }
+                    else {
+                        return {
+                            content: [{ type: "text", text: JSON.stringify({ connected: false }, null, 2) }],
+                        };
+                    }
+                }
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [{ type: "text", text: `错误: ${message}` }],
+                isError: true,
+            };
+        }
+    });
+    // 工具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/dist/types.d.ts

@@ -0,0 +1,38 @@
+export interface ServerConfig {
+    name: string;
+    host: string;
+    port: number;
+    username: string;
+    password?: string;
+    privateKeyPath?: string;
+    passphrase?: string;
+}
+export interface ServersConfig {
+    servers: ServerConfig[];
+}
+export interface CommandResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+export interface ConnectionStatus {
+    connected: boolean;
+    serverName: string | null;
+    host: string | null;
+    username: string | null;
+}
+export interface ShellResult {
+    output: string;
+    totalLines: number;
+    complete: boolean;
+    truncated?: boolean;
+    slow?: boolean;
+    waiting?: boolean;
+    message: string;
+}
+export interface ShellConfig {
+    quickTimeout: number;
+    maxTimeout: number;
+    maxLines: number;
+    maxBufferLines: number;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "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"
+  }
+}

package/ssh-servers.example.json

@@ -0,0 +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"
+    }
+  ]
+}