mcp-ssh-pty 1.0.0 → 1.2.0

package/dist/config.d.ts

@@ -1,12 +1,24 @@
 import { ServersConfig, ServerConfig } from "./types.js";
+export type ConfigScope = "local" | "global";
 export declare class ConfigManager {
     private config;
     private configPath;
-    constructor(configPath?: string);
+    private scope;
+    constructor(configPath?: string, scope?: ConfigScope);
+    private getPathByScope;
+    static getLocalPath(): string;
+    static getGlobalPath(): string;
     private resolveConfigPath;
     private expandPath;
     load(): ServersConfig;
+    save(): void;
     getServer(name: string): ServerConfig | undefined;
     listServers(): ServerConfig[];
+    addServer(server: ServerConfig): void;
+    removeServer(name: string): boolean;
     getConfigPath(): string;
+    getScope(): ConfigScope;
+    configExists(): boolean;
+    static localConfigExists(): boolean;
+    static globalConfigExists(): boolean;
 }

package/dist/config.js

@@ -1,24 +1,55 @@
-import { readFileSync, existsSync } from "fs";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
 import { homedir } from "os";
-import { join } from "path";
+import { join, dirname } from "path";
 export class ConfigManager {
     config = null;
     configPath;
-    constructor(configPath) {
-        this.configPath = configPath || this.resolveConfigPath();
+    scope;
+    constructor(configPath, scope) {
+        if (configPath) {
+            this.configPath = configPath;
+            this.scope = "global";
+        }
+        else if (scope) {
+            this.configPath = this.getPathByScope(scope);
+            this.scope = scope;
+        }
+        else {
+            const resolved = this.resolveConfigPath();
+            this.configPath = resolved.path;
+            this.scope = resolved.scope;
+        }
+    }
+    getPathByScope(scope) {
+        if (scope === "local") {
+            return join(process.cwd(), ".claude", "ssh-servers.json");
+        }
+        return join(homedir(), ".claude", "ssh-servers.json");
+    }
+    static getLocalPath() {
+        return join(process.cwd(), ".claude", "ssh-servers.json");
+    }
+    static getGlobalPath() {
+        return join(homedir(), ".claude", "ssh-servers.json");
     }
     resolveConfigPath() {
         // 1. 优先使用环境变量
         if (process.env.SSH_MCP_CONFIG_PATH) {
-            return this.expandPath(process.env.SSH_MCP_CONFIG_PATH);
+            return {
+                path: this.expandPath(process.env.SSH_MCP_CONFIG_PATH),
+                scope: "global",
+            };
         }
         // 2. 查找项目目录下的 .claude/ssh-servers.json
         const projectPath = join(process.cwd(), ".claude", "ssh-servers.json");
         if (existsSync(projectPath)) {
-            return projectPath;
+            return { path: projectPath, scope: "local" };
         }
         // 3. 查找用户目录下的 ~/.claude/ssh-servers.json
-        return join(homedir(), ".claude", "ssh-servers.json");
+        return {
+            path: join(homedir(), ".claude", "ssh-servers.json"),
+            scope: "global",
+        };
     }
     expandPath(path) {
         if (path.startsWith("~")) {
@@ -28,7 +59,9 @@ export class ConfigManager {
     }
     load() {
         if (!existsSync(this.configPath)) {
-            throw new Error(`配置文件不存在: ${this.configPath}\n请创建配置文件或设置 SSH_MCP_CONFIG_PATH 环境变量`);
+            // 如果配置文件不存在，返回空配置
+            this.config = { servers: [] };
+            return this.config;
         }
         try {
             const content = readFileSync(this.configPath, "utf-8");
@@ -42,6 +75,14 @@ export class ConfigManager {
             throw error;
         }
     }
+    save() {
+        // 确保目录存在
+        const dir = dirname(this.configPath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        writeFileSync(this.configPath, JSON.stringify(this.config, null, 2), "utf-8");
+    }
     getServer(name) {
         if (!this.config)
             this.load();
@@ -52,7 +93,44 @@ export class ConfigManager {
             this.load();
         return this.config.servers;
     }
+    addServer(server) {
+        if (!this.config)
+            this.load();
+        // 检查是否已存在
+        const existing = this.config.servers.findIndex((s) => s.name === server.name);
+        if (existing >= 0) {
+            // 更新已有配置
+            this.config.servers[existing] = server;
+        }
+        else {
+            this.config.servers.push(server);
+        }
+        this.save();
+    }
+    removeServer(name) {
+        if (!this.config)
+            this.load();
+        const index = this.config.servers.findIndex((s) => s.name === name);
+        if (index < 0) {
+            return false;
+        }
+        this.config.servers.splice(index, 1);
+        this.save();
+        return true;
+    }
     getConfigPath() {
         return this.configPath;
     }
+    getScope() {
+        return this.scope;
+    }
+    configExists() {
+        return existsSync(this.configPath);
+    }
+    static localConfigExists() {
+        return existsSync(ConfigManager.getLocalPath());
+    }
+    static globalConfigExists() {
+        return existsSync(ConfigManager.getGlobalPath());
+    }
 }

package/dist/index.js

@@ -4,7 +4,25 @@ 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() {
+import { runCLI } from "./cli.js";
+// CLI 命令列表
+const CLI_COMMANDS = ["list", "add", "remove", "rm", "test", "config", "help", "--help", "-h", "--version", "-V"];
+/**
+ * 检查是否是 CLI 模式
+ */
+function isCLIMode() {
+    const args = process.argv.slice(2);
+    // 没有参数时启动 MCP 服务器
+    if (args.length === 0) {
+        return false;
+    }
+    // 如果第一个参数是 CLI 命令，则进入 CLI 模式
+    return CLI_COMMANDS.includes(args[0]);
+}
+/**
+ * 启动 MCP 服务器
+ */
+async function startServer() {
     const server = new McpServer({
         name: "ssh-mcp-server",
         version: "1.0.0",
@@ -14,19 +32,26 @@ async function main() {
     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);
     });
 }
+/**
+ * 主函数
+ */
+async function main() {
+    if (isCLIMode()) {
+        await runCLI();
+    }
+    else {
+        await startServer();
+    }
+}
 main().catch((error) => {
     console.error("启动失败:", error);
     process.exit(1);

package/dist/sanitizer.d.ts

@@ -0,0 +1,48 @@
+/**
+ * 敏感信息过滤器
+ * 用于在 MCP 返回中隐藏 IP、密码等敏感信息
+ */
+export interface SensitivePattern {
+    pattern: RegExp;
+    replacement: string;
+    description: string;
+}
+export declare class Sanitizer {
+    private sensitiveValues;
+    private patterns;
+    constructor();
+    /**
+     * 添加自定义正则模式
+     */
+    addPattern(pattern: SensitivePattern): void;
+    /**
+     * 注册敏感值（如密码、私钥路径等）
+     * 这些值会被精确匹配并替换
+     */
+    addSensitiveValue(value: string, minLength?: number): void;
+    /**
+     * 批量注册敏感值
+     */
+    addSensitiveValues(values: (string | undefined)[]): void;
+    /**
+     * 清除所有注册的敏感值（保留模式）
+     */
+    clearSensitiveValues(): void;
+    /**
+     * 过滤文本中的敏感信息
+     */
+    sanitize(text: string): string;
+    /**
+     * 过滤对象中的敏感信息（递归处理）
+     */
+    sanitizeObject<T>(obj: T): T;
+}
+export declare function getSanitizer(): Sanitizer;
+/**
+ * 便捷函数：过滤文本
+ */
+export declare function sanitize(text: string): string;
+/**
+ * 便捷函数：过滤对象
+ */
+export declare function sanitizeObject<T>(obj: T): T;

package/dist/sanitizer.js

@@ -0,0 +1,123 @@
+/**
+ * 敏感信息过滤器
+ * 用于在 MCP 返回中隐藏 IP、密码等敏感信息
+ */
+export class Sanitizer {
+    sensitiveValues = new Set();
+    patterns = [];
+    constructor() {
+        // 内置通用模式
+        this.addPattern({
+            pattern: /\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/g,
+            replacement: "[IP]",
+            description: "IPv4 地址",
+        });
+        this.addPattern({
+            pattern: /\b([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}\b/g,
+            replacement: "[IPv6]",
+            description: "IPv6 地址",
+        });
+        this.addPattern({
+            pattern: /\b([0-9a-fA-F]{1,4}:){1,7}:\b/g,
+            replacement: "[IPv6]",
+            description: "IPv6 简写",
+        });
+    }
+    /**
+     * 添加自定义正则模式
+     */
+    addPattern(pattern) {
+        this.patterns.push(pattern);
+    }
+    /**
+     * 注册敏感值（如密码、私钥路径等）
+     * 这些值会被精确匹配并替换
+     */
+    addSensitiveValue(value, minLength = 3) {
+        if (value && value.length >= minLength) {
+            this.sensitiveValues.add(value);
+        }
+    }
+    /**
+     * 批量注册敏感值
+     */
+    addSensitiveValues(values) {
+        values.forEach((v) => {
+            if (v)
+                this.addSensitiveValue(v);
+        });
+    }
+    /**
+     * 清除所有注册的敏感值（保留模式）
+     */
+    clearSensitiveValues() {
+        this.sensitiveValues.clear();
+    }
+    /**
+     * 过滤文本中的敏感信息
+     */
+    sanitize(text) {
+        if (!text)
+            return text;
+        let result = text;
+        // 1. 先替换精确匹配的敏感值（按长度降序，避免短串误匹配）
+        const sortedValues = Array.from(this.sensitiveValues)
+            .filter((v) => v.length >= 3)
+            .sort((a, b) => b.length - a.length);
+        for (const value of sortedValues) {
+            // 转义正则特殊字符
+            const escaped = value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            const regex = new RegExp(escaped, "g");
+            result = result.replace(regex, "[REDACTED]");
+        }
+        // 2. 应用正则模式
+        for (const { pattern, replacement } of this.patterns) {
+            // 重置正则状态（因为使用了 /g 标志）
+            pattern.lastIndex = 0;
+            result = result.replace(pattern, replacement);
+        }
+        return result;
+    }
+    /**
+     * 过滤对象中的敏感信息（递归处理）
+     */
+    sanitizeObject(obj) {
+        if (obj === null || obj === undefined) {
+            return obj;
+        }
+        if (typeof obj === "string") {
+            return this.sanitize(obj);
+        }
+        if (Array.isArray(obj)) {
+            return obj.map((item) => this.sanitizeObject(item));
+        }
+        if (typeof obj === "object") {
+            const result = {};
+            for (const [key, value] of Object.entries(obj)) {
+                result[key] = this.sanitizeObject(value);
+            }
+            return result;
+        }
+        return obj;
+    }
+}
+// 全局单例
+let globalSanitizer = null;
+export function getSanitizer() {
+    if (!globalSanitizer) {
+        globalSanitizer = new Sanitizer();
+    }
+    return globalSanitizer;
+}
+/**
+ * 便捷函数：过滤文本
+ */
+export function sanitize(text) {
+    return getSanitizer().sanitize(text);
+}
+/**
+ * 便捷函数：过滤对象
+ */
+export function sanitizeObject(obj) {
+    return getSanitizer().sanitizeObject(obj);
+}

package/dist/shell-manager.d.ts

@@ -2,25 +2,42 @@ 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;
     /**
      * 发送命令，智能等待完成
      */
     send(input: string, config?: Partial<ShellConfig>): Promise<ShellResult>;
     /**
      * 读取缓冲区内容
+     * @param lines 返回行数：不传默认 20 行，-1 返回全部，正整数返回对应行数
+     * @param offset 起始偏移，默认 0
+     * @param clear 读取后是否清空缓冲区
      */
     read(lines?: number, offset?: number, clear?: boolean): ShellResult;
     /**

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;
+    }
     /**
      * 发送命令，智能等待完成
      */
@@ -85,14 +164,19 @@ export class ShellManager {
     }
     /**
      * 读取缓冲区内容
+     * @param lines 返回行数：不传默认 20 行，-1 返回全部，正整数返回对应行数
+     * @param offset 起始偏移，默认 0
+     * @param clear 读取后是否清空缓冲区
      */
     read(lines, offset, clear) {
         const startIdx = offset || 0;
-        const endIdx = lines ? startIdx + lines : this.outputLines.length;
+        // 处理 lines 参数：undefined 默认 20，-1 返回全部，其他返回指定行数
+        const effectiveLines = lines === undefined ? 20 : (lines === -1 ? undefined : lines);
+        const endIdx = effectiveLines ? startIdx + effectiveLines : this.outputLines.length;
         const selectedLines = this.outputLines.slice(startIdx, endIdx);
         // 包含不完整的最后一行
         let output = selectedLines.join("\n");
-        if (this.outputBuffer && (!lines || endIdx >= this.outputLines.length)) {
+        if (this.outputBuffer && (!effectiveLines || endIdx >= this.outputLines.length)) {
             output += (output ? "\n" : "") + this.outputBuffer;
         }
         const result = {
@@ -135,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,15 +1,34 @@
 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;
+    /**
+     * 注册服务器配置中的敏感信息
+     */
+    private registerSensitiveInfo;
     getShellManager(): ShellManager;
+    isLocal(): boolean;
     getStatus(): ConnectionStatus;
 }