mcp-ssh-pty 1.0.0 → 1.1.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",
@@ -27,6 +45,17 @@ async function main() {
         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

@@ -21,6 +21,9 @@ export declare class ShellManager {
     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

@@ -85,14 +85,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 = {

package/dist/ssh-manager.d.ts

@@ -10,6 +10,10 @@ export declare class SSHManager {
     connect(config: ServerConfig): Promise<void>;
     disconnect(): Promise<void>;
     private cleanup;
+    /**
+     * 注册服务器配置中的敏感信息
+     */
+    private registerSensitiveInfo;
     getShellManager(): ShellManager;
     getStatus(): ConnectionStatus;
 }

package/dist/ssh-manager.js

@@ -3,6 +3,7 @@ import { readFileSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
 import { ShellManager } from "./shell-manager.js";
+import { getSanitizer } from "./sanitizer.js";
 export class SSHManager {
     client = null;
     currentServer = null;
@@ -26,6 +27,8 @@ export class SSHManager {
             this.client.on("ready", async () => {
                 this.isConnected = true;
                 this.currentServer = config;
+                // 注册敏感信息到过滤器
+                this.registerSensitiveInfo(config);
                 // 连接成功后自动打开 shell
                 try {
                     await this.shellManager.open(this.client);
@@ -83,6 +86,21 @@ export class SSHManager {
         this.isConnected = 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;