@maplezzk/mcps 1.0.31 → 1.1.1

package/dist/commands/server.js

@@ -1,6 +1,7 @@
 import chalk from 'chalk';
 import { configManager } from '../core/config.js';
 import { DaemonClient } from '../core/daemon-client.js';
+import { detectServerType } from '../types/config.js';
 export const registerServerCommands = (program) => {
     const listServersAction = () => {
         const servers = configManager.listServers();
@@ -30,19 +31,21 @@ export const registerServerCommands = (program) => {
         // Build table rows
         const rows = servers.map(server => {
             const disabled = server.disabled === true;
-            const typeColor = server.type === 'stdio' ? chalk.cyan : chalk.yellow;
+            const serverType = detectServerType(server);
+            const typeColor = serverType === 'stdio' ? chalk.cyan : chalk.yellow;
             const enabledMark = disabled ? chalk.red('✗') : chalk.green('✓');
             // Build command/URL string
             let command = '';
-            if (server.type === 'stdio') {
-                command = `${server.command} ${server.args.join(' ')}`;
+            if ('command' in server && server.command) {
+                const args = server.args;
+                command = `${server.command} ${args?.join(' ') || ''}`;
             }
-            else {
-                command = server.url || '';
+            else if ('url' in server && server.url) {
+                command = server.url;
             }
             return {
                 name: server.name,
-                type: typeColor(server.type),
+                type: typeColor(serverType),
                 enabled: enabledMark,
                 command: command,
                 disabled
@@ -67,12 +70,10 @@ export const registerServerCommands = (program) => {
     };
     const addServerAction = (name, options) => {
         try {
-            if (options.type === 'sse' || options.type === 'http') {
+            if (options.type === 'sse' || options.type === 'http' || options.url) {
                 if (!options.url)
-                    throw new Error(`URL is required for ${options.type} servers`);
-                configManager.addServer({
-                    name,
-                    type: options.type,
+                    throw new Error(`URL is required for ${options.type || 'HTTP/SSE'} servers`);
+                configManager.addServer(name, {
                     url: options.url,
                 });
             }
@@ -89,9 +90,7 @@ export const registerServerCommands = (program) => {
                             env[k] = v;
                     });
                 }
-                configManager.addServer({
-                    name,
-                    type: 'stdio',
+                configManager.addServer(name, {
                     command: options.command,
                     args: options.args || [],
                     env: Object.keys(env).length > 0 ? env : undefined,

package/dist/core/client.js

@@ -2,6 +2,7 @@ import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 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 { detectServerType } from '../types/config.js';
 import { EventSource } from 'eventsource';
 import { exec } from 'child_process';
 import { promisify } from 'util';
@@ -59,23 +60,25 @@ export class McpClientService {
     static globalPidsBeforeConnection = new Set();
     async connect(config, serverName = '') {
         this.serverName = serverName;
-        this.serverType = config.type;
+        const serverType = detectServerType(config);
+        this.serverType = serverType;
         this.daemonPid = process.pid;
         try {
-            if (config.type === 'stdio') {
+            if (serverType === 'stdio' && 'command' in config) {
+                const stdioConfig = config;
                 // 保存命令和参数用于后续清理进程
-                this.serverCommand = config.command;
-                this.serverArgs = config.args || [];
+                this.serverCommand = stdioConfig.command;
+                this.serverArgs = stdioConfig.args || [];
                 const resolvedConfigEnv = {};
-                if (config.env) {
-                    for (const key in config.env) {
-                        const val = config.env[key];
+                if (stdioConfig.env) {
+                    for (const key in stdioConfig.env) {
+                        const val = stdioConfig.env[key];
                         if (typeof val === 'string') {
                             resolvedConfigEnv[key] = resolveEnvPlaceholders(val);
                         }
                     }
                 }
-                const rawEnv = config.env ? { ...process.env, ...resolvedConfigEnv } : process.env;
+                const rawEnv = stdioConfig.env ? { ...process.env, ...resolvedConfigEnv } : process.env;
                 const env = {};
                 for (const key in rawEnv) {
                     const val = rawEnv[key];
@@ -83,21 +86,24 @@ export class McpClientService {
                         env[key] = val;
                     }
                 }
-                const args = config.args ? config.args.map(arg => resolveEnvPlaceholders(arg)) : [];
+                const args = stdioConfig.args ? stdioConfig.args.map(arg => resolveEnvPlaceholders(arg)) : [];
                 this.transport = new StdioClientTransport({
-                    command: config.command,
+                    command: stdioConfig.command,
                     args,
                     env: env,
                 });
             }
-            else if (config.type === 'http') {
+            else if (serverType === 'http' && 'url' in config) {
                 const url = resolveEnvPlaceholders(config.url);
                 this.transport = new StreamableHTTPClientTransport(new URL(url));
             }
-            else {
+            else if ('url' in config) {
                 const url = resolveEnvPlaceholders(config.url);
                 this.transport = new SSEClientTransport(new URL(url));
             }
+            else {
+                throw new Error('Invalid server configuration: must have either command (for stdio) or url (for sse/http)');
+            }
             this.client = new Client({
                 name: 'mcp-cli',
                 version: '1.0.0',

package/dist/core/config.js

@@ -18,48 +18,36 @@ export class ConfigManager {
     loadConfig() {
         this.ensureConfigDir();
         if (!fs.existsSync(this.configFile)) {
-            return { servers: [] };
+            return { mcpServers: {} };
         }
         try {
             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:', this.configFile);
             if (!json || typeof json !== 'object') {
                 console.warn('Invalid config file structure. Expected JSON object.');
-                return { servers: [] };
+                return { mcpServers: {} };
             }
-            // Handle both { servers: [...] } and { mcpServers: { ... } } (VSCode/Claude style)
-            let servers = [];
-            if (Array.isArray(json.servers)) {
-                servers = json.servers;
+            // Only accept standard MCP format: { mcpServers: { ... } }
+            if (!json.mcpServers || typeof json.mcpServers !== 'object') {
+                console.warn('Invalid config format. Expected { mcpServers: { ... } }');
+                return { mcpServers: {} };
             }
-            else if (json.mcpServers && typeof json.mcpServers === 'object') {
-                // Convert map to array and add default type='stdio' if missing
-                servers = Object.entries(json.mcpServers).map(([name, config]) => ({
-                    name,
-                    type: config.type || (config.command ? 'stdio' : undefined), // Auto-detect type
-                    ...config
-                }));
-            }
-            const validServers = [];
-            for (const server of servers) {
-                const result = ServerConfigSchema.safeParse(server);
+            // Validate each server config
+            const validServers = {};
+            for (const [name, serverConfig] of Object.entries(json.mcpServers)) {
+                const result = ServerConfigSchema.safeParse(serverConfig);
                 if (result.success) {
-                    validServers.push(result.data);
+                    validServers[name] = result.data;
                 }
                 else {
-                    // Only warn if it looks like a server config we *should* have supported
-                    if (server.name) {
-                        console.warn(`Skipping invalid server config "${server.name}":`, result.error.errors[0]?.message);
-                    }
+                    console.warn(`Skipping invalid server config "${name}":`, result.error.errors[0]?.message);
                 }
             }
-            return { servers: validServers };
+            return { mcpServers: validServers };
         }
         catch (error) {
             console.error('Failed to parse config file:', error);
-            return { servers: [] };
+            return { mcpServers: {} };
         }
     }
     saveConfig(config) {
@@ -67,43 +55,47 @@ export class ConfigManager {
         fs.writeFileSync(this.configFile, JSON.stringify(config, null, 2), 'utf-8');
     }
     listServers() {
-        return this.loadConfig().servers;
+        const config = this.loadConfig();
+        return Object.entries(config.mcpServers).map(([name, server]) => ({
+            name,
+            ...server,
+        }));
     }
     getServer(name) {
         const config = this.loadConfig();
-        return config.servers.find(s => s.name === name);
+        const server = config.mcpServers[name];
+        if (!server)
+            return undefined;
+        return { name, ...server };
     }
-    addServer(server) {
+    addServer(name, server) {
         const config = this.loadConfig();
-        if (config.servers.find(s => s.name === server.name)) {
-            throw new Error(`Server with name "${server.name}" already exists.`);
+        if (config.mcpServers[name]) {
+            throw new Error(`Server with name "${name}" already exists.`);
         }
-        config.servers.push(server);
+        config.mcpServers[name] = server;
         this.saveConfig(config);
     }
     removeServer(name) {
         const config = this.loadConfig();
-        const initialLength = config.servers.length;
-        config.servers = config.servers.filter(s => s.name !== name);
-        if (config.servers.length === initialLength) {
+        if (!config.mcpServers[name]) {
             throw new Error(`Server with name "${name}" not found.`);
         }
+        delete config.mcpServers[name];
         this.saveConfig(config);
     }
     updateServer(name, updates) {
         const config = this.loadConfig();
-        const index = config.servers.findIndex(s => s.name === name);
-        if (index === -1) {
+        const current = config.mcpServers[name];
+        if (!current) {
             throw new Error(`Server with name "${name}" not found.`);
         }
-        const current = config.servers[index];
         const updated = { ...current, ...updates };
-        // Validate the updated object matches the schema (especially type consistency)
         const result = ServerConfigSchema.safeParse(updated);
         if (!result.success) {
             throw new Error(`Invalid update: ${result.error.message}`);
         }
-        config.servers[index] = result.data;
+        config.mcpServers[name] = result.data;
         this.saveConfig(config);
     }
 }

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

@@ -26,74 +26,75 @@ describe('ConfigManager', () => {
     });
     describe('addServer', () => {
         it('should add a stdio server', () => {
-            const server = {
-                name: 'test-stdio',
-                type: 'stdio',
+            const serverName = 'test-stdio';
+            const serverConfig = {
                 command: 'node',
                 args: ['--version']
             };
-            manager.addServer(server);
+            manager.addServer(serverName, serverConfig);
             const servers = manager.listServers();
             expect(servers).toHaveLength(1);
-            expect(servers[0]).toMatchObject(server);
+            expect(servers[0].name).toBe(serverName);
+            expect(servers[0].command).toBe('node');
+            expect(servers[0].args).toEqual(['--version']);
         });
         it('should add an sse server', () => {
-            const server = {
-                name: 'test-sse',
-                type: 'sse',
+            const serverName = 'test-sse';
+            const serverConfig = {
                 url: 'http://localhost:3000/sse'
             };
-            manager.addServer(server);
+            manager.addServer(serverName, serverConfig);
             const retrieved = manager.getServer('test-sse');
-            expect(retrieved).toMatchObject(server);
+            expect(retrieved).toBeDefined();
+            expect(retrieved.name).toBe(serverName);
+            expect(retrieved.url).toBe('http://localhost:3000/sse');
         });
         it('should add an http server', () => {
-            const server = {
-                name: 'test-http',
-                type: 'http',
+            const serverName = 'test-http';
+            const serverConfig = {
                 url: 'http://localhost:3000/mcp'
             };
-            manager.addServer(server);
+            manager.addServer(serverName, serverConfig);
             const retrieved = manager.getServer('test-http');
-            expect(retrieved).toMatchObject(server);
+            expect(retrieved).toBeDefined();
+            expect(retrieved.name).toBe(serverName);
+            expect(retrieved.url).toBe('http://localhost:3000/mcp');
         });
         it('should add server with disabled flag', () => {
-            const server = {
-                name: 'disabled-server',
-                type: 'stdio',
+            const serverName = 'disabled-server';
+            const serverConfig = {
                 command: 'node',
                 args: [],
                 disabled: true
             };
-            manager.addServer(server);
+            manager.addServer(serverName, serverConfig);
             const retrieved = manager.getServer('disabled-server');
-            expect(retrieved).toMatchObject({
-                name: 'disabled-server',
-                disabled: true
-            });
+            expect(retrieved).toBeDefined();
+            expect(retrieved.name).toBe('disabled-server');
+            expect(retrieved.disabled).toBe(true);
         });
         it('should throw error when adding duplicate server', () => {
-            const server = {
-                name: 'duplicate',
-                type: 'stdio',
+            const serverName = 'duplicate';
+            const serverConfig = {
                 command: 'node',
                 args: []
             };
-            manager.addServer(server);
-            expect(() => manager.addServer(server)).toThrow('already exists');
+            manager.addServer(serverName, serverConfig);
+            expect(() => manager.addServer(serverName, serverConfig)).toThrow('already exists');
         });
     });
     describe('getServer', () => {
         it('should retrieve existing server', () => {
-            const server = {
-                name: 'to-retrieve',
-                type: 'stdio',
+            const serverName = 'to-retrieve';
+            const serverConfig = {
                 command: 'node',
                 args: []
             };
-            manager.addServer(server);
+            manager.addServer(serverName, serverConfig);
             const retrieved = manager.getServer('to-retrieve');
-            expect(retrieved).toMatchObject(server);
+            expect(retrieved).toBeDefined();
+            expect(retrieved.name).toBe(serverName);
+            expect(retrieved.command).toBe('node');
         });
         it('should return undefined for non-existing server', () => {
             const retrieved = manager.getServer('non-existing');
@@ -106,34 +107,25 @@ describe('ConfigManager', () => {
             expect(servers).toEqual([]);
         });
         it('should return all servers including disabled ones', () => {
-            const server1 = {
-                name: 'server-1',
-                type: 'stdio',
+            manager.addServer('server-1', {
                 command: 'node',
                 args: []
-            };
-            const server2 = {
-                name: 'server-2',
-                type: 'stdio',
+            });
+            manager.addServer('server-2', {
                 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',
+            manager.addServer('to-remove', {
                 command: 'node',
                 args: []
-            };
-            manager.addServer(server);
+            });
             expect(manager.listServers()).toHaveLength(1);
             manager.removeServer('to-remove');
             expect(manager.listServers()).toHaveLength(0);
@@ -144,75 +136,83 @@ describe('ConfigManager', () => {
     });
     describe('updateServer', () => {
         it('should update server configuration', () => {
-            const original = {
-                name: 'to-update',
-                type: 'stdio',
+            manager.addServer('to-update', {
                 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',
+            });
+            manager.updateServer('to-update', {
                 command: 'npm',
                 args: ['start']
             });
+            const updated = manager.getServer('to-update');
+            expect(updated).toBeDefined();
+            expect(updated.command).toBe('npm');
+            expect(updated.args).toEqual(['start']);
         });
         it('should preserve disabled status during update', () => {
-            const original = {
-                name: 'update-disabled',
-                type: 'stdio',
+            manager.addServer('update-disabled', {
                 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');
+            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',
+        it('should persist configuration to file in standard MCP format', () => {
+            manager.addServer('persistent', {
                 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');
+            // Standard MCP format uses mcpServers object, not servers array
+            expect(content.mcpServers).toBeDefined();
+            expect(content.mcpServers.persistent).toBeDefined();
+            expect(content.mcpServers.persistent.command).toBe('node');
         });
         it('should load existing configuration on instantiation', () => {
             const configFile = path.join(testConfigDir, 'mcp.json');
+            // Standard MCP format
             const existingConfig = {
+                mcpServers: {
+                    existing: {
+                        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');
+        });
+        it('should reject old format (servers array)', () => {
+            const configFile = path.join(testConfigDir, 'mcp.json');
+            // Old format (should be rejected)
+            const oldConfig = {
                 servers: [
                     {
-                        name: 'existing',
+                        name: 'old-server',
                         type: 'stdio',
                         command: 'node',
                         args: []
                     }
                 ]
             };
-            fs.writeFileSync(configFile, JSON.stringify(existingConfig, null, 2));
+            fs.writeFileSync(configFile, JSON.stringify(oldConfig, null, 2));
             const newManager = new ConfigManager(testConfigDir);
             const servers = newManager.listServers();
-            expect(servers).toHaveLength(1);
-            expect(servers[0].name).toBe('existing');
+            // Old format should be rejected, returning empty list
+            expect(servers).toHaveLength(0);
         });
     });
 });

package/dist/types/config.js

@@ -1,23 +1,32 @@
 import { z } from 'zod';
+// Standard MCP server configuration (stdio type)
+export const StdioServerConfigSchema = z.object({
+    command: z.string(),
+    args: z.array(z.string()).optional(),
+    env: z.record(z.string()).optional(),
+    cwd: z.string().optional(),
+    disabled: z.boolean().optional(),
+    autoApprove: z.array(z.string()).optional(),
+}).passthrough();
+// Standard MCP server configuration (sse/http type)
+export const HttpServerConfigSchema = z.object({
+    url: z.string().url(),
+    disabled: z.boolean().optional(),
+    autoApprove: z.array(z.string()).optional(),
+}).passthrough();
+// Union of all server config types
 export const ServerConfigSchema = z.union([
-    z.object({
-        name: z.string(),
-        type: z.literal('stdio').optional().default('stdio'),
-        command: z.string(),
-        args: z.array(z.string()).optional().default([]),
-        env: z.record(z.string()).optional(),
-    }).passthrough(),
-    z.object({
-        name: z.string(),
-        type: z.literal('sse'),
-        url: z.string().url(),
-    }).passthrough(),
-    z.object({
-        name: z.string(),
-        type: z.literal('http'),
-        url: z.string().url(),
-    }).passthrough(),
+    StdioServerConfigSchema,
+    HttpServerConfigSchema,
 ]);
+// Standard MCP config format (mcpServers)
 export const ConfigSchema = z.object({
-    servers: z.array(ServerConfigSchema).default([]),
+    mcpServers: z.record(z.string(), ServerConfigSchema),
 });
+// Helper to detect server type from config
+export function detectServerType(config) {
+    if ('url' in config && typeof config.url === 'string') {
+        return config.url.includes('/sse') || config.url.endsWith('/sse') ? 'sse' : 'http';
+    }
+    return 'stdio';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maplezzk/mcps",
-  "version": "1.0.31",
+  "version": "1.1.1",
   "description": "A CLI to manage and use MCP servers",
   "publishConfig": {
     "access": "public"