@maplezzk/mcps 1.0.18 → 1.0.24

package/dist/commands/daemon.js

@@ -24,8 +24,8 @@ function isPortInUse(port) {
     });
 }
 // Action functions for daemon commands
-const startAction = async (options, parentCmd) => {
-    const port = parseInt(options.port || DAEMON_PORT);
+const startAction = async (options) => {
+    const port = parseInt(options.port || process.env.MCPS_PORT || DAEMON_PORT);
     // Check if port is in use (more reliable than HTTP check)
     const portInUse = await isPortInUse(port);
     if (portInUse) {
@@ -51,7 +51,7 @@ const startAction = async (options, parentCmd) => {
         return;
     }
     // Otherwise, spawn a detached process
-    console.log(chalk.gray('Starting daemon in background...'));
+    console.log(chalk.cyan('Starting daemon in background...'));
     let childFailed = false;
     const subprocess = spawn(process.execPath, [process.argv[1], 'daemon', 'start'], {
         detached: true,
@@ -59,23 +59,27 @@ const startAction = async (options, parentCmd) => {
         stdio: ['ignore', 'pipe', 'pipe'],
         env: {
             ...process.env,
-            MCPS_DAEMON_DETACHED: 'true'
+            MCPS_DAEMON_DETACHED: 'true',
+            MCPS_VERBOSE: options.verbose ? 'true' : 'false'
         }
     });
     // Stream logs to current console while waiting for ready
     if (subprocess.stdout) {
         subprocess.stdout.on('data', (data) => {
-            process.stdout.write(chalk.gray(`[Daemon] ${data}`));
+            process.stdout.write(`${data}`);
         });
     }
     if (subprocess.stderr) {
         subprocess.stderr.on('data', (data) => {
             const msg = data.toString();
-            process.stderr.write(chalk.red(`[Daemon] ${msg}`));
             // Detect port conflict in child process
             if (msg.includes('Port') && msg.includes('is already in use')) {
                 childFailed = true;
             }
+            // Only show error output if it contains critical errors
+            if (msg.includes('Error') || msg.includes('EADDRINUSE')) {
+                process.stderr.write(chalk.red(`[Daemon] ${msg}`));
+            }
         });
     }
     subprocess.unref();
@@ -83,7 +87,7 @@ const startAction = async (options, parentCmd) => {
     // We can poll status for a second
     const start = Date.now();
     // Increased timeout to allow for connection initialization
-    while (Date.now() - start < 10000) {
+    while (Date.now() - start < 30000) {
         // If child reported port conflict, check if daemon is actually running
         if (childFailed) {
             const stillRunning = await isPortInUse(port);
@@ -110,9 +114,9 @@ const startAction = async (options, parentCmd) => {
     console.log(chalk.yellow('Daemon started (async check timeout, but likely running).'));
     process.exit(0);
 };
-const stopAction = async (parentCmd) => {
+const stopAction = async (options) => {
     try {
-        const port = parseInt(parentCmd.opts().port || DAEMON_PORT);
+        const port = parseInt(options?.port || process.env.MCPS_PORT || DAEMON_PORT);
         await fetch(`http://localhost:${port}/stop`, { method: 'POST' });
         console.log(chalk.green('Daemon stopped successfully.'));
     }
@@ -120,31 +124,70 @@ const stopAction = async (parentCmd) => {
         console.error(chalk.red('Failed to stop daemon. Is it running?'));
     }
 };
-const statusAction = async (parentCmd) => {
+const statusAction = async (options) => {
     try {
-        const port = parseInt(parentCmd.opts().port || DAEMON_PORT);
+        const port = parseInt(options?.port || process.env.MCPS_PORT || DAEMON_PORT);
         const res = await fetch(`http://localhost:${port}/status`);
         const data = await res.json();
+        console.log('');
         console.log(chalk.green(`Daemon is running (v${data.version})`));
         if (data.connections && data.connections.length > 0) {
+            // Helper function to calculate display width (Chinese chars count as 2)
+            const getDisplayWidth = (str) => {
+                let width = 0;
+                for (const char of str) {
+                    if (char.charCodeAt(0) > 127) {
+                        width += 2;
+                    }
+                    else {
+                        width += 1;
+                    }
+                }
+                return width;
+            };
+            // Helper function to pad string considering Chinese characters
+            const padEndWidth = (str, targetWidth) => {
+                const displayWidth = getDisplayWidth(str);
+                const padding = Math.max(0, targetWidth - displayWidth);
+                return str + ' '.repeat(padding);
+            };
+            // Build table rows
+            const rows = data.connections.map((conn) => {
+                const statusText = conn.status === 'error' ? 'Error' : 'Connected';
+                const statusColor = conn.status === 'error' ? chalk.red : chalk.green;
+                const toolsCount = conn.toolsCount !== null ? conn.toolsCount : '-';
+                return {
+                    name: conn.name,
+                    status: statusColor(statusText),
+                    tools: toolsCount
+                };
+            });
+            // Calculate column widths
+            const nameWidth = Math.max(4, ...rows.map((r) => getDisplayWidth(r.name)));
+            const statusWidth = 10;
+            const toolsWidth = 6;
+            // Print table header
             console.log(chalk.bold('\nActive Connections:'));
-            data.connections.forEach((conn) => {
-                const count = conn.toolsCount !== null ? `(${conn.toolsCount} tools)` : (data.initializing ? '(initializing)' : '(error listing tools)');
-                const status = conn.status === 'error' ? chalk.red('[Error]') : '';
-                console.log(chalk.cyan(`- ${conn.name} ${chalk.gray(count)} ${status}`));
+            console.log(chalk.bold(`${'NAME'.padEnd(nameWidth)}  ${'STATUS'.padEnd(statusWidth)}  ${'TOOLS'}`));
+            console.log(chalk.cyan('─'.repeat(nameWidth) + '  ' + '─'.repeat(statusWidth) + '  ' + '─'.repeat(toolsWidth)));
+            // Print table rows
+            rows.forEach((row) => {
+                console.log(`${padEndWidth(row.name, nameWidth)}  ${String(row.status).padEnd(statusWidth)}  ${String(row.tools)}`);
             });
+            console.log(chalk.cyan(`Total: ${data.connections.length} connection(s)`));
         }
         else {
-            console.log(chalk.gray('No active connections.'));
+            console.log(chalk.yellow('\nNo active connections.'));
         }
+        console.log('');
     }
     catch (e) {
         console.error(chalk.red('Daemon is not running.'));
     }
 };
-const restartAction = async (serverName, parentCmd) => {
+const restartAction = async (serverName, options) => {
     try {
-        const port = parseInt(parentCmd.opts().port || DAEMON_PORT);
+        const port = parseInt(options?.port || process.env.MCPS_PORT || DAEMON_PORT);
         const res = await fetch(`http://localhost:${port}/restart`, {
             method: 'POST',
             body: JSON.stringify({ server: serverName })
@@ -161,19 +204,20 @@ export const registerDaemonCommand = (program) => {
     program.command('start')
         .description('Start the daemon')
         .option('-p, --port <number>', 'Daemon port', String(DAEMON_PORT))
-        .action((options) => startAction(options, program));
+        .option('-v, --verbose', 'Show detailed logs')
+        .action((options) => startAction(options));
     program.command('stop')
         .description('Stop the daemon')
         .option('-p, --port <number>', 'Daemon port', String(DAEMON_PORT))
-        .action(() => stopAction(program));
+        .action((options) => stopAction(options));
     program.command('status')
         .description('Check daemon status')
         .option('-p, --port <number>', 'Daemon port', String(DAEMON_PORT))
-        .action(() => statusAction(program));
+        .action((options) => statusAction(options));
     program.command('restart [server]')
         .description('Restart the daemon or a specific server connection')
         .option('-p, --port <number>', 'Daemon port', String(DAEMON_PORT))
-        .action((serverName) => restartAction(serverName, program));
+        .action((serverName, options) => restartAction(serverName, options));
     // ===== Legacy daemon subcommands (for backward compatibility) =====
     const daemonCmd = program.command('daemon')
         .description('Manage the mcps daemon (legacy, use top-level commands)')
@@ -181,16 +225,16 @@ export const registerDaemonCommand = (program) => {
         .option('-p, --port <number>', 'Daemon port', String(DAEMON_PORT));
     daemonCmd.command('start', { isDefault: true, hidden: true })
         .description('Start the daemon (default)')
-        .action((options) => startAction(options, daemonCmd));
+        .action((options) => startAction(options));
     daemonCmd.command('stop')
         .description('Stop the running daemon')
-        .action(() => stopAction(daemonCmd));
+        .action((options) => stopAction(options));
     daemonCmd.command('status')
         .description('Check daemon status')
-        .action(() => statusAction(daemonCmd));
+        .action((options) => statusAction(options));
     daemonCmd.command('restart [server]')
         .description('Restart the daemon or a specific server connection')
-        .action((serverName) => restartAction(serverName, daemonCmd));
+        .action((serverName, options) => restartAction(serverName, options));
 };
 const startDaemon = (port) => {
     const server = http.createServer(async (req, res) => {

package/dist/commands/server.js

@@ -8,19 +8,62 @@ export const registerServerCommands = (program) => {
             console.log(chalk.yellow('No servers configured.'));
             return;
         }
-        console.log(chalk.bold('\nConfigured Servers:'));
-        servers.forEach(s => {
-            console.log(`- ${chalk.cyan(s.name)} [${chalk.magenta(s.type)}]`);
-            if (s.type === 'stdio') {
-                console.log(`  Command: ${s.command} ${s.args.join(' ')}`);
-                if (s.env)
-                    console.log(`  Env: ${Object.keys(s.env).join(', ')}`);
+        // Helper function to calculate display width (Chinese chars count as 2)
+        const getDisplayWidth = (str) => {
+            let width = 0;
+            for (const char of str) {
+                if (char.charCodeAt(0) > 127) {
+                    width += 2;
+                }
+                else {
+                    width += 1;
+                }
+            }
+            return width;
+        };
+        // Helper function to pad string considering Chinese characters
+        const padEndWidth = (str, targetWidth) => {
+            const displayWidth = getDisplayWidth(str);
+            const padding = Math.max(0, targetWidth - displayWidth);
+            return str + ' '.repeat(padding);
+        };
+        // Build table rows
+        const rows = servers.map(server => {
+            const disabled = server.disabled === true;
+            const typeColor = server.type === '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(' ')}`;
             }
             else {
-                console.log(`  URL: ${s.url}`);
+                command = server.url || '';
             }
-            console.log('');
+            return {
+                name: server.name,
+                type: typeColor(server.type),
+                enabled: enabledMark,
+                command: command,
+                disabled
+            };
+        });
+        // Calculate column widths
+        const nameWidth = Math.max(4, ...rows.map(r => getDisplayWidth(r.name)));
+        const typeWidth = 6;
+        const enabledWidth = 7;
+        const commandWidth = Math.max(7, ...rows.map(r => getDisplayWidth(r.command)));
+        // Print table header
+        console.log('');
+        console.log(chalk.bold(`${'NAME'.padEnd(nameWidth)}  ${'TYPE'.padEnd(typeWidth)}  ${'ENABLED'.padEnd(enabledWidth)}  ${'COMMAND/URL'}`));
+        console.log(chalk.gray('─'.repeat(nameWidth) + '  ' + '─'.repeat(typeWidth) + '  ' + '─'.repeat(enabledWidth) + '  ' + '─'.repeat(commandWidth)));
+        // Print table rows
+        rows.forEach(row => {
+            console.log(`${padEndWidth(row.name, nameWidth)}  ${String(row.type).padEnd(typeWidth)}  ${String(row.enabled).padEnd(enabledWidth)}  ${row.command}`);
         });
+        console.log('');
+        console.log(chalk.cyan(`Total: ${servers.length} server(s)`));
+        console.log('');
     };
     const addServerAction = (name, options) => {
         try {

package/dist/core/pool.js

@@ -56,10 +56,11 @@ export class ConnectionPool {
         const servers = configManager.listServers();
         this.initializing = true;
         this.initialized = false;
+        const verbose = process.env.MCPS_VERBOSE === 'true';
         // 过滤掉 disabled 的服务器
         const enabledServers = servers.filter(server => {
             const disabled = server.disabled === true;
-            if (disabled) {
+            if (verbose && disabled) {
                 console.log(`[Daemon] Skipping disabled server: ${server.name}`);
             }
             return !disabled;
@@ -70,20 +71,38 @@ export class ConnectionPool {
             this.initialized = true;
             return;
         }
-        console.log(`[Daemon] Initializing ${enabledServers.length} connection(s)...`);
+        console.log(`[Daemon] Connecting to ${enabledServers.length} server(s)...`);
+        const results = [];
         for (const server of enabledServers) {
+            if (verbose) {
+                process.stdout.write(`[Daemon] - ${server.name}... `);
+            }
             try {
-                console.log(`[Daemon] Connecting to server: ${server.name}...`);
                 await this.getClient(server.name, { timeoutMs: 8000 });
-                console.log(`[Daemon] ✓ Connected to ${server.name}`);
+                results.push({ name: server.name, success: true });
+                if (verbose) {
+                    console.log('✓');
+                }
             }
             catch (error) {
-                console.error(`[Daemon] ✗ Failed to connect to ${server.name}:`, error.message);
+                results.push({ name: server.name, success: false, error: error.message });
+                if (verbose) {
+                    console.log('✗');
+                    console.error(`[Daemon] Error: ${error.message}`);
+                }
             }
         }
+        // Print summary
+        const successCount = results.filter(r => r.success).length;
+        const failed = results.filter(r => !r.success);
+        console.log(`[Daemon] Connected: ${successCount}/${enabledServers.length}`);
+        if (!verbose && failed.length > 0) {
+            failed.forEach(f => {
+                console.error(`[Daemon] ✗ ${f.name}: ${f.error}`);
+            });
+        }
         this.initializing = false;
         this.initialized = true;
-        console.log('[Daemon] Initialization complete.');
     }
     getInitStatus() {
         return { initializing: this.initializing, initialized: this.initialized };

package/package.json

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