mcp-ssh-pty 1.1.0 → 1.2.0

package/README.md

@@ -11,7 +11,7 @@ npm install -g mcp-ssh-pty
 ### Add to Claude Code
 
 ```bash
-claude mcp add ssh -- npx -y mcp-ssh-pty
+claude mcp add --transport stdio ssh -- npx -y mcp-ssh-pty
 ```
 
 ## CLI Commands
@@ -28,7 +28,7 @@ mcp-ssh-pty list --all     # Show both levels
 ### Add server
 
 ```bash
-# Interactive mode (will ask for config level)
+# Interactive mode
 mcp-ssh-pty add
 
 # Save to project level
@@ -58,22 +58,6 @@ mcp-ssh-pty test my-server
 mcp-ssh-pty config
 ```
 
-```
-? 选择配置级别:
-❯ 📁 项目级别 (已存在)
-  🌐 用户级别 (新建)
-
-? 选择操作:
-❯ 📋 查看所有服务器
-  ➕ 添加服务器
-  ✏️  编辑服务器
-  🗑️  删除服务器
-  🔌 测试连接
-  🔄 切换配置级别
-  📁 显示配置文件路径
-  🚪 退出
-```
-
 ## Configuration
 
 ### Config file locations
@@ -84,8 +68,6 @@ mcp-ssh-pty config
 | User | `~/.claude/ssh-servers.json` | Low |
 | Custom | `SSH_MCP_CONFIG_PATH` env | Highest |
 
-Project level config overrides user level when exists.
-
 ### Config format
 
 ```json
@@ -104,13 +86,25 @@ Project level config overrides user level when exists.
 
 ## MCP Usage
 
-### Connection
+### List Servers
 
 ```
 ssh({ action: "list" })
-ssh({ action: "connect", server: "my-server" })
-ssh({ action: "status" })
-ssh({ action: "disconnect" })
+```
+
+Returns:
+```json
+[
+  { "name": "local", "connected": false, "type": "built-in" },
+  { "name": "my-server", "connected": false, "type": "configured" }
+]
+```
+
+### Connect
+
+```
+ssh({ action: "connect", server: "local" })      # Local shell
+ssh({ action: "connect", server: "my-server" })  # Remote SSH
 ```
 
 ### Command Execution
@@ -144,6 +138,24 @@ ssh({ read: true })
 ssh({ signal: "SIGINT" })          # Ctrl+C
 ```
 
+### Disconnect
+
+```
+ssh({ action: "disconnect" })
+```
+
+### Status
+
+```
+ssh({ action: "status" })
+```
+
+## Built-in Servers
+
+| Name | Description |
+|------|-------------|
+| `local` | Local shell (uses system default shell) |
+
 ## License
 
 MIT

package/dist/cli.js

@@ -26,6 +26,9 @@ function formatScope(scope) {
  * list 命令
  */
 async function listServers(options) {
+    // 先显示内置服务器
+    console.log("=== 内置服务器 ===");
+    console.log(`  • local (本地 shell)\n`);
     if (options.all) {
         // 显示两个级别的配置
         console.log("=== 项目级别 (local) ===");
@@ -64,14 +67,13 @@ async function listServers(options) {
     const scope = options.local ? "local" : options.global ? "global" : undefined;
     const configManager = getConfigManager(scope);
     const servers = configManager.listServers();
-    console.log(`配置级别: ${formatScope(configManager.getScope())}`);
-    console.log(`配置文件: ${configManager.getConfigPath()}\n`);
+    console.log(`=== ${formatScope(configManager.getScope())} ===`);
+    console.log(`路径: ${configManager.getConfigPath()}\n`);
     if (servers.length === 0) {
-        console.log("没有配置任何服务器");
+        console.log("(空)");
         console.log("\n使用 'mcp-ssh-pty add' 添加服务器");
         return;
     }
-    console.log("已配置的服务器:\n");
     servers.forEach((server, index) => {
         console.log(`  ${index + 1}. ${formatServer(server)}`);
     });

package/dist/index.js

@@ -32,15 +32,11 @@ async function startServer() {
     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);
     });

package/dist/shell-manager.d.ts

@@ -2,19 +2,33 @@ import { Client } from "ssh2";
 import { ShellResult, ShellConfig } from "./types.js";
 export declare class ShellManager {
     private shell;
+    private localProcess;
     private outputBuffer;
     private outputLines;
     private lastOutputTime;
     private config;
+    private isLocal;
     constructor(config?: Partial<ShellConfig>);
     /**
-     * 打开 PTY Shell（在 SSH 连接成功后调用）
+     * 打开远程 PTY Shell（在 SSH 连接成功后调用）
      */
     open(client: Client): Promise<void>;
+    /**
+     * 打开本地 Shell
+     */
+    openLocal(): Promise<void>;
+    /**
+     * 设置 stream 的事件监听
+     */
+    private setupStream;
     /**
      * 检查 shell 是否已打开
      */
     isOpen(): boolean;
+    /**
+     * 是否是本地 shell
+     */
+    isLocalShell(): boolean;
     /**
      * 发送命令，智能等待完成
      */

package/dist/shell-manager.js

@@ -1,3 +1,4 @@
+import { spawn } from "child_process";
 const DEFAULT_CONFIG = {
     quickTimeout: 2000,
     maxTimeout: 5000,
@@ -6,15 +7,17 @@ const DEFAULT_CONFIG = {
 };
 export class ShellManager {
     shell = null;
+    localProcess = null;
     outputBuffer = "";
     outputLines = [];
     lastOutputTime = 0;
     config;
+    isLocal = false;
     constructor(config) {
         this.config = { ...DEFAULT_CONFIG, ...config };
     }
     /**
-     * 打开 PTY Shell（在 SSH 连接成功后调用）
+     * 打开远程 PTY Shell（在 SSH 连接成功后调用）
      */
     async open(client) {
         return new Promise((resolve, reject) => {
@@ -24,31 +27,8 @@ export class ShellManager {
                     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);
-                });
+                this.isLocal = false;
+                this.setupStream(stream);
                 // 等待初始提示符
                 setTimeout(() => {
                     resolve();
@@ -56,12 +36,111 @@ export class ShellManager {
             });
         });
     }
+    /**
+     * 打开本地 Shell
+     */
+    async openLocal() {
+        return new Promise((resolve, reject) => {
+            try {
+                // 检测系统默认 shell
+                const shellPath = process.env.SHELL || (process.platform === "win32" ? "cmd.exe" : "/bin/sh");
+                const proc = spawn(shellPath, [], {
+                    stdio: ["pipe", "pipe", "pipe"],
+                    env: { ...process.env, TERM: "xterm-256color" },
+                });
+                this.localProcess = proc;
+                this.isLocal = true;
+                // 创建统一的 stream 接口
+                const dataListeners = [];
+                const closeListeners = [];
+                const errorListeners = [];
+                proc.stdout?.on("data", (data) => {
+                    dataListeners.forEach((l) => l(data));
+                });
+                proc.stderr?.on("data", (data) => {
+                    dataListeners.forEach((l) => l(data));
+                });
+                proc.on("close", () => {
+                    closeListeners.forEach((l) => l());
+                });
+                proc.on("error", (err) => {
+                    errorListeners.forEach((l) => l(err));
+                });
+                const stream = {
+                    write: (data) => {
+                        proc.stdin?.write(data);
+                    },
+                    end: () => {
+                        proc.stdin?.end();
+                        proc.kill();
+                    },
+                    on: ((event, listener) => {
+                        if (event === "data") {
+                            dataListeners.push(listener);
+                        }
+                        else if (event === "close") {
+                            closeListeners.push(listener);
+                        }
+                        else if (event === "error") {
+                            errorListeners.push(listener);
+                        }
+                    }),
+                };
+                this.shell = stream;
+                this.setupStream(stream);
+                // 等待初始化
+                setTimeout(() => {
+                    resolve();
+                }, 300);
+            }
+            catch (error) {
+                reject(new Error(`无法打开本地 shell: ${error instanceof Error ? error.message : String(error)}`));
+            }
+        });
+    }
+    /**
+     * 设置 stream 的事件监听
+     */
+    setupStream(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;
+            this.localProcess = null;
+        });
+        stream.on("error", (err) => {
+            console.error("Shell error:", err.message);
+        });
+    }
     /**
      * 检查 shell 是否已打开
      */
     isOpen() {
         return this.shell !== null;
     }
+    /**
+     * 是否是本地 shell
+     */
+    isLocalShell() {
+        return this.isLocal;
+    }
     /**
      * 发送命令，智能等待完成
      */
@@ -140,8 +219,13 @@ export class ShellManager {
             this.shell.end();
             this.shell = null;
         }
+        if (this.localProcess) {
+            this.localProcess.kill();
+            this.localProcess = null;
+        }
         this.outputLines = [];
         this.outputBuffer = "";
+        this.isLocal = false;
     }
     /**
      * 获取当前缓冲区行数

package/dist/ssh-manager.d.ts

@@ -1,13 +1,27 @@
 import { ServerConfig, ConnectionStatus } from "./types.js";
 import { ShellManager } from "./shell-manager.js";
+export declare const LOCAL_SERVER: ServerConfig;
 export declare class SSHManager {
     private client;
     private currentServer;
     private isConnected;
     private shellManager;
+    private isLocalConnection;
     constructor();
     private expandPath;
+    /**
+     * 检查是否是本地连接
+     */
+    static isLocalServer(config: ServerConfig): boolean;
     connect(config: ServerConfig): Promise<void>;
+    /**
+     * 本地连接
+     */
+    private connectLocal;
+    /**
+     * SSH 远程连接
+     */
+    private connectSSH;
     disconnect(): Promise<void>;
     private cleanup;
     /**
@@ -15,5 +29,6 @@ export declare class SSHManager {
      */
     private registerSensitiveInfo;
     getShellManager(): ShellManager;
+    isLocal(): boolean;
     getStatus(): ConnectionStatus;
 }

package/dist/ssh-manager.js

@@ -4,11 +4,19 @@ 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();
     }
@@ -18,14 +26,46 @@ 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);
@@ -77,13 +117,14 @@ 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;
         // 清除敏感信息
@@ -105,11 +146,14 @@ export class SSHManager {
     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,4 +1,5 @@
 import { z } from "zod";
+import { LOCAL_SERVER } from "./ssh-manager.js";
 import { sanitize } from "./sanitizer.js";
 /**
  * 过滤 ShellResult 中的敏感信息
@@ -151,10 +152,19 @@ ssh({ signal: "SIGINT" })               # Ctrl+C 停止`,
                 case "list": {
                     const servers = configManager.listServers();
                     const status = sshManager.getStatus();
-                    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) }],
                     };
@@ -166,9 +176,19 @@ ssh({ signal: "SIGINT" })               # Ctrl+C 停止`,
                             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",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-ssh-pty",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "MCP Server for SSH remote command execution with PTY shell support",
   "type": "module",
   "main": "dist/index.js",