@maplezzk/mcps 1.0.29 → 1.0.30-beta.0

package/README.md

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

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/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-beta.0",
   "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}`));
-        }
-    });
-};