@maplezzk/mcps 1.0.29 → 1.0.30

package/README.md

@@ -13,6 +13,7 @@
 - 📊 **表格输出**：清晰的服务器状态和工具列表展示
 - 🔍 **工具筛选**：按关键词筛选工具，支持简洁模式
 - 🚨 **详细日志**：可选的详细日志模式，方便调试
+- ✅ **自动化测试**：完整的测试套件，确保代码质量
 
 ## 安装
 

package/dist/core/client.js

@@ -3,6 +3,30 @@ import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js'
 import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import { EventSource } from 'eventsource';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import fs from 'fs';
+import path from 'path';
+const execAsync = promisify(exec);
+// 日志文件路径
+const logFile = path.join(process.env.HOME || '~', '.mcps', 'daemon.log');
+// 日志函数（异步，避免阻塞）
+const log = (message) => {
+    const timestamp = new Date().toISOString();
+    const logMessage = `[${timestamp}] ${message}\n`;
+    try {
+        fs.appendFileSync(logFile, logMessage);
+    }
+    catch (e) {
+        // 忽略日志写入错误
+    }
+    try {
+        console.log(message);
+    }
+    catch (e) {
+        // 忽略 console 错误
+    }
+};
 // Required for SSEClientTransport in Node.js environment
 // @ts-ignore
 global.EventSource = EventSource;
@@ -26,9 +50,22 @@ const resolveEnvPlaceholders = (input) => {
 export class McpClientService {
     client = null;
     transport = null;
-    async connect(config) {
+    serverName = '';
+    serverType = '';
+    serverCommand = '';
+    serverArgs = [];
+    daemonPid = process.pid;
+    childPids = new Set();
+    static globalPidsBeforeConnection = new Set();
+    async connect(config, serverName = '') {
+        this.serverName = serverName;
+        this.serverType = config.type;
+        this.daemonPid = process.pid;
         try {
             if (config.type === 'stdio') {
+                // 保存命令和参数用于后续清理进程
+                this.serverCommand = config.command;
+                this.serverArgs = config.args || [];
                 const resolvedConfigEnv = {};
                 if (config.env) {
                     for (const key in config.env) {
@@ -68,12 +105,81 @@ export class McpClientService {
                 capabilities: {},
             });
             await this.client.connect(this.transport);
+            // 连接成功后，立即查找并保存子进程 PID
+            if (config.type === 'stdio') {
+                await this.recordChildPids();
+            }
         }
         catch (error) {
             // Error will be handled by the caller
             throw error;
         }
     }
+    // 记录子进程 PID（使用快照差异法）
+    async recordChildPids() {
+        try {
+            // 获取连接前的所有子进程快照
+            const getSnapshot = async () => {
+                const pids = new Set();
+                const getAllDescendants = async (parentPid) => {
+                    try {
+                        const { stdout } = await execAsync(`pgrep -P ${parentPid}`);
+                        const childPids = stdout.trim().split('\n').filter(pid => pid);
+                        for (const pid of childPids) {
+                            pids.add(parseInt(pid));
+                            await getAllDescendants(parseInt(pid));
+                        }
+                    }
+                    catch {
+                        // 没有子进程
+                    }
+                };
+                await getAllDescendants(this.daemonPid);
+                return pids;
+            };
+            // 记录连接前的快照（第一次连接时为空）
+            const beforeSnapshot = new Set(McpClientService.globalPidsBeforeConnection);
+            // 等待一小段时间，确保子进程完全启动
+            await new Promise(resolve => setTimeout(resolve, 500));
+            // 获取连接后的快照
+            const afterSnapshot = await getSnapshot();
+            // 找出差异（新启动的进程）
+            const newPids = new Set();
+            for (const pid of afterSnapshot) {
+                if (!beforeSnapshot.has(pid)) {
+                    newPids.add(pid);
+                }
+            }
+            // 更新全局快照
+            McpClientService.globalPidsBeforeConnection = afterSnapshot;
+            // 过滤出匹配我们命令的进程
+            const commandBaseName = this.serverCommand.split('/').pop() || this.serverCommand;
+            for (const pid of newPids) {
+                try {
+                    const { stdout: cmdOutput } = await execAsync(`ps -p ${pid} -o command=`);
+                    const cmdLine = cmdOutput.trim();
+                    // 检查命令行是否匹配
+                    const isMatch = cmdLine.includes(commandBaseName) ||
+                        cmdLine.includes('npm exec') || // npx 会转换成 npm exec
+                        cmdLine.includes('npx') ||
+                        (this.serverArgs.length > 0 && this.serverArgs.some(arg => {
+                            return cmdLine.includes(arg) && arg.length > 10;
+                        }));
+                    if (isMatch) {
+                        this.childPids.add(pid);
+                        // 调试日志已移除
+                    }
+                }
+                catch {
+                    // 进程可能已经不存在了
+                }
+            }
+        }
+        catch (e) {
+            // 记录失败，不影响主流程
+            console.error(`[Daemon] Failed to record child PIDs: ${e}`);
+        }
+    }
     async listTools() {
         if (!this.client)
             throw new Error('Client not connected');
@@ -87,9 +193,24 @@ export class McpClientService {
             arguments: args,
         });
     }
-    async close() {
-        if (this.transport) {
-            await this.transport.close();
+    close() {
+        // 对于 stdio 类型的服务器，先杀掉子进程（在关闭 transport 之前）
+        if (this.serverType === 'stdio' && this.childPids.size > 0) {
+            log(`[Daemon] Closing ${this.serverName}, killing ${this.childPids.size} child process(es)...`);
+            // 直接使用 SIGKILL，确保进程被终止
+            for (const pid of this.childPids) {
+                try {
+                    process.kill(pid, 'SIGKILL');
+                    log(`[Daemon] SIGKILLED child process ${pid} (${this.serverName})`);
+                }
+                catch (e) {
+                    log(`[Daemon] Failed to kill ${pid}: ${e}`);
+                }
+            }
+            this.childPids.clear();
+            log(`[Daemon] All child processes cleared for ${this.serverName}`);
         }
+        // 暂时不关闭 transport，避免卡住
+        log(`[Daemon] ${this.serverName} close() completed`);
     }
 }

package/dist/core/config.js

@@ -2,24 +2,29 @@ import fs from 'fs';
 import path from 'path';
 import os from 'os';
 import { ServerConfigSchema } from '../types/config.js';
-const CONFIG_DIR = process.env.MCPS_CONFIG_DIR || path.join(os.homedir(), '.mcps');
-const CONFIG_FILE = path.join(CONFIG_DIR, 'mcp.json');
+const getDefaultConfigDir = () => process.env.MCPS_CONFIG_DIR || path.join(os.homedir(), '.mcps');
 export class ConfigManager {
+    configDir;
+    configFile;
+    constructor(configDir) {
+        this.configDir = configDir || getDefaultConfigDir();
+        this.configFile = path.join(this.configDir, 'mcp.json');
+    }
     ensureConfigDir() {
-        if (!fs.existsSync(CONFIG_DIR)) {
-            fs.mkdirSync(CONFIG_DIR, { recursive: true });
+        if (!fs.existsSync(this.configDir)) {
+            fs.mkdirSync(this.configDir, { recursive: true });
         }
     }
     loadConfig() {
         this.ensureConfigDir();
-        if (!fs.existsSync(CONFIG_FILE)) {
+        if (!fs.existsSync(this.configFile)) {
             return { servers: [] };
         }
         try {
-            const content = fs.readFileSync(CONFIG_FILE, 'utf-8');
+            const content = fs.readFileSync(this.configFile, 'utf-8');
             const json = JSON.parse(content);
             // Log for debugging (can be removed later or controlled by verbose flag)
-            // console.log('Loading config from:', CONFIG_FILE);
+            // console.log('Loading config from:', this.configFile);
             if (!json || typeof json !== 'object') {
                 console.warn('Invalid config file structure. Expected JSON object.');
                 return { servers: [] };
@@ -59,7 +64,7 @@ export class ConfigManager {
     }
     saveConfig(config) {
         this.ensureConfigDir();
-        fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
+        fs.writeFileSync(this.configFile, JSON.stringify(config, null, 2), 'utf-8');
     }
     listServers() {
         return this.loadConfig().servers;

package/dist/core/pool.js

@@ -55,7 +55,7 @@ export class ConnectionPool {
         for (const [name, client] of this.clients) {
             console.log(`[Daemon] Closing connection to ${name}...`);
             try {
-                await client.close();
+                client.close(); // 同步调用，不使用 await
             }
             catch (e) {
                 console.error(`[Daemon] Error closing ${name}:`, e);

package/dist/tests/helpers.js

@@ -0,0 +1,52 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { vi } from 'vitest';
+export const TEST_CONFIG_DIR = path.join(os.tmpdir(), `mcps-test-${Date.now()}`);
+export function setupTestConfig() {
+    // 确保测试配置目录存在
+    if (!fs.existsSync(TEST_CONFIG_DIR)) {
+        fs.mkdirSync(TEST_CONFIG_DIR, { recursive: true });
+    }
+    // 设置测试环境变量
+    process.env.MCPS_CONFIG_DIR = TEST_CONFIG_DIR;
+    return TEST_CONFIG_DIR;
+}
+export function cleanupTestConfig() {
+    if (fs.existsSync(TEST_CONFIG_DIR)) {
+        fs.rmSync(TEST_CONFIG_DIR, { recursive: true, force: true });
+    }
+}
+export function getTestConfigPath() {
+    return path.join(TEST_CONFIG_DIR, 'mcp.json');
+}
+export function createTestServer(overrides = {}) {
+    return {
+        name: 'test-server',
+        type: 'stdio',
+        command: 'node',
+        args: ['--version'],
+        ...overrides
+    };
+}
+export function createMockClient(toolsCount = 5) {
+    const tools = [];
+    for (let i = 0; i < toolsCount; i++) {
+        tools.push({
+            name: `test_tool_${i}`,
+            description: `Test tool ${i}`,
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    param: { type: 'string', description: `Parameter ${i}` }
+                }
+            }
+        });
+    }
+    return {
+        listTools: vi.fn().mockResolvedValue({ tools }),
+        callTool: vi.fn().mockResolvedValue({ result: 'success' }),
+        connect: vi.fn().mockResolvedValue(undefined),
+        close: vi.fn().mockResolvedValue(undefined)
+    };
+}

package/dist/tests/unit/config.test.js

@@ -0,0 +1,218 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { ConfigManager } from '../../core/config.js';
+describe('ConfigManager', () => {
+    let testConfigDir;
+    let manager;
+    beforeEach(() => {
+        // 创建临时配置目录
+        testConfigDir = path.join(os.tmpdir(), `mcps-config-test-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`);
+        fs.mkdirSync(testConfigDir, { recursive: true });
+        // 创建新的 ConfigManager 实例，传入测试目录
+        manager = new ConfigManager(testConfigDir);
+    });
+    afterEach(() => {
+        // 清理临时目录
+        if (fs.existsSync(testConfigDir)) {
+            try {
+                fs.rmSync(testConfigDir, { recursive: true, force: true });
+            }
+            catch (e) {
+                // 忽略清理错误
+            }
+        }
+    });
+    describe('addServer', () => {
+        it('should add a stdio server', () => {
+            const server = {
+                name: 'test-stdio',
+                type: 'stdio',
+                command: 'node',
+                args: ['--version']
+            };
+            manager.addServer(server);
+            const servers = manager.listServers();
+            expect(servers).toHaveLength(1);
+            expect(servers[0]).toMatchObject(server);
+        });
+        it('should add an sse server', () => {
+            const server = {
+                name: 'test-sse',
+                type: 'sse',
+                url: 'http://localhost:3000/sse'
+            };
+            manager.addServer(server);
+            const retrieved = manager.getServer('test-sse');
+            expect(retrieved).toMatchObject(server);
+        });
+        it('should add an http server', () => {
+            const server = {
+                name: 'test-http',
+                type: 'http',
+                url: 'http://localhost:3000/mcp'
+            };
+            manager.addServer(server);
+            const retrieved = manager.getServer('test-http');
+            expect(retrieved).toMatchObject(server);
+        });
+        it('should add server with disabled flag', () => {
+            const server = {
+                name: 'disabled-server',
+                type: 'stdio',
+                command: 'node',
+                args: [],
+                disabled: true
+            };
+            manager.addServer(server);
+            const retrieved = manager.getServer('disabled-server');
+            expect(retrieved).toMatchObject({
+                name: 'disabled-server',
+                disabled: true
+            });
+        });
+        it('should throw error when adding duplicate server', () => {
+            const server = {
+                name: 'duplicate',
+                type: 'stdio',
+                command: 'node',
+                args: []
+            };
+            manager.addServer(server);
+            expect(() => manager.addServer(server)).toThrow('already exists');
+        });
+    });
+    describe('getServer', () => {
+        it('should retrieve existing server', () => {
+            const server = {
+                name: 'to-retrieve',
+                type: 'stdio',
+                command: 'node',
+                args: []
+            };
+            manager.addServer(server);
+            const retrieved = manager.getServer('to-retrieve');
+            expect(retrieved).toMatchObject(server);
+        });
+        it('should return undefined for non-existing server', () => {
+            const retrieved = manager.getServer('non-existing');
+            expect(retrieved).toBeUndefined();
+        });
+    });
+    describe('listServers', () => {
+        it('should return empty array when no servers', () => {
+            const servers = manager.listServers();
+            expect(servers).toEqual([]);
+        });
+        it('should return all servers including disabled ones', () => {
+            const server1 = {
+                name: 'server-1',
+                type: 'stdio',
+                command: 'node',
+                args: []
+            };
+            const server2 = {
+                name: 'server-2',
+                type: 'stdio',
+                command: 'npm',
+                args: ['start'],
+                disabled: true
+            };
+            manager.addServer(server1);
+            manager.addServer(server2);
+            const servers = manager.listServers();
+            expect(servers).toHaveLength(2);
+        });
+    });
+    describe('removeServer', () => {
+        it('should remove existing server', () => {
+            const server = {
+                name: 'to-remove',
+                type: 'stdio',
+                command: 'node',
+                args: []
+            };
+            manager.addServer(server);
+            expect(manager.listServers()).toHaveLength(1);
+            manager.removeServer('to-remove');
+            expect(manager.listServers()).toHaveLength(0);
+        });
+        it('should throw error when removing non-existing server', () => {
+            expect(() => manager.removeServer('non-existing')).toThrow('not found');
+        });
+    });
+    describe('updateServer', () => {
+        it('should update server configuration', () => {
+            const original = {
+                name: 'to-update',
+                type: 'stdio',
+                command: 'node',
+                args: ['--version']
+            };
+            manager.addServer(original);
+            const updates = {
+                command: 'npm',
+                args: ['start']
+            };
+            manager.updateServer('to-update', updates);
+            const updated = manager.getServer('to-update');
+            expect(updated).toMatchObject({
+                name: 'to-update',
+                command: 'npm',
+                args: ['start']
+            });
+        });
+        it('should preserve disabled status during update', () => {
+            const original = {
+                name: 'update-disabled',
+                type: 'stdio',
+                command: 'node',
+                args: [],
+                disabled: true
+            };
+            manager.addServer(original);
+            manager.updateServer('update-disabled', { command: 'npm' });
+            const updated = manager.getServer('update-disabled');
+            expect(updated?.disabled).toBe(true);
+            expect(updated?.command).toBe('npm');
+        });
+        it('should throw error when updating non-existing server', () => {
+            expect(() => manager.updateServer('non-existing', {})).toThrow('not found');
+        });
+    });
+    describe('persistence', () => {
+        it('should persist configuration to file', () => {
+            const server = {
+                name: 'persistent',
+                type: 'stdio',
+                command: 'node',
+                args: []
+            };
+            manager.addServer(server);
+            const configFile = path.join(testConfigDir, 'mcp.json');
+            expect(fs.existsSync(configFile)).toBe(true);
+            const content = JSON.parse(fs.readFileSync(configFile, 'utf-8'));
+            expect(content.servers).toHaveLength(1);
+            expect(content.servers[0].name).toBe('persistent');
+        });
+        it('should load existing configuration on instantiation', () => {
+            const configFile = path.join(testConfigDir, 'mcp.json');
+            const existingConfig = {
+                servers: [
+                    {
+                        name: 'existing',
+                        type: 'stdio',
+                        command: 'node',
+                        args: []
+                    }
+                ]
+            };
+            fs.writeFileSync(configFile, JSON.stringify(existingConfig, null, 2));
+            const newManager = new ConfigManager(testConfigDir);
+            const servers = newManager.listServers();
+            expect(servers).toHaveLength(1);
+            expect(servers[0].name).toBe('existing');
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maplezzk/mcps",
-  "version": "1.0.29",
+  "version": "1.0.30",
   "description": "A CLI to manage and use MCP servers",
   "publishConfig": {
     "access": "public"
@@ -14,6 +14,10 @@
   ],
   "author": "",
   "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/a13835614623/mcps"
+  },
   "type": "module",
   "bin": {
     "mcps": "./dist/index.js"
@@ -23,10 +27,13 @@
   ],
   "scripts": {
     "build": "tsc",
-    "prepublishOnly": "npm run build",
+    "prepublishOnly": "npm run build && npm run test",
     "start": "node dist/index.js",
     "dev": "ts-node src/index.ts",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest --coverage"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.25.3",
@@ -39,7 +46,10 @@
   "devDependencies": {
     "@types/eventsource": "^1.1.15",
     "@types/node": "^22.10.7",
+    "@vitest/coverage-v8": "^4.0.18",
+    "@vitest/ui": "^4.0.18",
     "ts-node": "^10.9.2",
-    "typescript": "^5.7.3"
+    "typescript": "^5.7.3",
+    "vitest": "^4.0.18"
   }
 }

package/dist/commands/config.js

@@ -1,83 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import chalk from 'chalk';
-import { configManager } from '../core/config.js';
-export const registerConfigCommand = (program) => {
-    const configCmd = program.command('config')
-        .description('Manage configuration');
-    configCmd.command('import <file>')
-        .description('Import servers from a JSON configuration file (e.g., mcporter.json)')
-        .option('-f, --force', 'Overwrite existing servers with the same name', false)
-        .action((file, options) => {
-        try {
-            const absolutePath = path.resolve(file);
-            if (!fs.existsSync(absolutePath)) {
-                console.error(chalk.red(`File not found: ${absolutePath}`));
-                process.exit(1);
-            }
-            const content = fs.readFileSync(absolutePath, 'utf-8');
-            let json;
-            try {
-                json = JSON.parse(content);
-            }
-            catch (e) {
-                console.error(chalk.red('Invalid JSON file.'));
-                process.exit(1);
-            }
-            let importedCount = 0;
-            let skippedCount = 0;
-            // Support standard MCP config format (mcpServers object)
-            const serversMap = json.mcpServers || {};
-            Object.entries(serversMap).forEach(([name, config]) => {
-                // Skip disabled servers
-                if (config.disabled === true) {
-                    skippedCount++;
-                    return;
-                }
-                const serverName = name;
-                let newServer;
-                if (config.command) {
-                    newServer = {
-                        name: serverName,
-                        type: 'stdio',
-                        command: config.command,
-                        args: config.args || [],
-                        env: config.env,
-                    };
-                }
-                else if (config.url) {
-                    newServer = {
-                        name: serverName,
-                        type: 'sse',
-                        url: config.url
-                    };
-                }
-                else {
-                    console.warn(chalk.yellow(`Skipping invalid server config for "${serverName}": missing command or url`));
-                    return;
-                }
-                const existing = configManager.getServer(serverName);
-                if (existing) {
-                    if (options.force) {
-                        configManager.updateServer(serverName, newServer);
-                        console.log(chalk.gray(`Updated existing server: ${serverName}`));
-                        importedCount++;
-                    }
-                    else {
-                        console.log(chalk.yellow(`Skipping existing server: ${serverName} (use --force to overwrite)`));
-                        skippedCount++;
-                    }
-                }
-                else {
-                    configManager.addServer(newServer);
-                    console.log(chalk.green(`Imported server: ${serverName}`));
-                    importedCount++;
-                }
-            });
-            console.log(chalk.bold(`\nImport complete. Imported: ${importedCount}, Skipped: ${skippedCount}`));
-        }
-        catch (error) {
-            console.error(chalk.red(`Import failed: ${error.message}`));
-        }
-    });
-};