@maplezzk/mcps 1.1.3 → 1.1.5

package/dist/commands/daemon.js

@@ -7,6 +7,42 @@ import { createRequire } from 'module';
 import { DAEMON_PORT } from '../core/constants.js';
 const require = createRequire(import.meta.url);
 const pkg = require('../../package.json');
+// Helper function to make HTTP requests to daemon (bypassing proxy)
+function daemonRequest(method, path, body) {
+    return new Promise((resolve, reject) => {
+        const port = parseInt(process.env.MCPS_PORT || String(DAEMON_PORT));
+        const options = {
+            method,
+            hostname: '127.0.0.1',
+            port,
+            path,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        };
+        const req = http.request(options, (res) => {
+            let data = '';
+            res.on('data', chunk => { data += chunk; });
+            res.on('end', () => {
+                try {
+                    resolve({
+                        status: res.statusCode || 500,
+                        ok: (res.statusCode || 500) >= 200 && (res.statusCode || 500) < 300,
+                        data: data ? JSON.parse(data) : {},
+                    });
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+        });
+        req.on('error', reject);
+        if (body) {
+            req.write(body);
+        }
+        req.end();
+    });
+}
 // Check if a port is in use
 function isPortInUse(port) {
     return new Promise((resolve) => {
@@ -39,8 +75,8 @@ const startAction = async (options) => {
     if (portInUse) {
         // Try to check if it's our daemon via HTTP
         try {
-            const res = await fetch(`http://localhost:${port}/status`);
-            if (res.ok) {
+            const { ok } = await daemonRequest('GET', '/status');
+            if (ok) {
                 console.log(chalk.yellow(`Daemon is already running on port ${port}.`));
                 process.exit(0);
                 return;
@@ -61,40 +97,41 @@ const startAction = async (options) => {
     // Otherwise, spawn a detached process
     console.log(chalk.cyan('Starting daemon in background...'));
     let childFailed = false;
+    // Create log file paths
+    const logDir = '/tmp/mcps-daemon';
+    const stdoutLog = `${logDir}/stdout.log`;
+    const stderrLog = `${logDir}/stderr.log`;
+    // Ensure log directory exists
+    const fs = await import('fs');
+    if (!fs.existsSync(logDir)) {
+        fs.mkdirSync(logDir, { recursive: true });
+    }
+    // Clear old log files for fresh start
+    if (fs.existsSync(stdoutLog)) {
+        fs.truncateSync(stdoutLog, 0);
+    }
+    if (fs.existsSync(stderrLog)) {
+        fs.truncateSync(stderrLog, 0);
+    }
+    // Open file descriptors for stdout and stderr
+    const stdoutFd = fs.openSync(stdoutLog, 'a');
+    const stderrFd = fs.openSync(stderrLog, 'a');
     const subprocess = spawn(process.execPath, [process.argv[1], 'daemon', 'start'], {
         detached: true,
-        // Pipe stdout/stderr so we can see initialization logs
-        stdio: ['ignore', 'pipe', 'pipe'],
+        // Pipe stdout/stderr to log files
+        stdio: ['ignore', stdoutFd, stderrFd],
         env: {
             ...process.env,
             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(`${data}`);
-        });
-    }
-    if (subprocess.stderr) {
-        subprocess.stderr.on('data', (data) => {
-            const msg = data.toString();
-            // 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();
     // Wait briefly to ensure it started (optional but good UX)
     // We can poll status for a second
     const start = Date.now();
     // Use timeout from option/env (convert to ms)
+    let lastLogSize = 0; // Track last read position to avoid duplicate logs
     while (Date.now() - start < timeout * 1000) {
         // If child reported port conflict, check if daemon is actually running
         if (childFailed) {
@@ -106,27 +143,98 @@ const startAction = async (options) => {
                 return;
             }
         }
+        // Show only new logs (avoid duplicates)
         try {
-            const res = await fetch(`http://localhost:${port}/status`);
-            if (res.ok) {
-                const data = await res.json();
-                if (data.initialized) {
-                    console.log(chalk.green(`Daemon started successfully on port ${port}.`));
-                    process.exit(0);
+            if (fs.existsSync(stdoutLog)) {
+                const { size } = fs.statSync(stdoutLog);
+                if (size > lastLogSize) {
+                    // Read new logs only
+                    const buffer = Buffer.alloc(size - lastLogSize);
+                    const fd = fs.openSync(stdoutLog, 'r');
+                    fs.readSync(fd, buffer, 0, size - lastLogSize, lastLogSize);
+                    fs.closeSync(fd);
+                    const newLogs = buffer.toString('utf-8');
+                    newLogs.split('\n').forEach(line => {
+                        if (line.trim())
+                            process.stdout.write(line + '\n');
+                    });
+                    lastLogSize = size;
                 }
             }
         }
+        catch (e) {
+            // Ignore log read errors
+        }
+        try {
+            const { ok, data } = await daemonRequest('GET', '/status');
+            if (ok && data.initialized) {
+                console.log(chalk.green(`Daemon started successfully on port ${port}.`));
+                console.log(chalk.gray(`Logs: ${stdoutLog}`));
+                process.exit(0);
+            }
+        }
         catch { }
         await new Promise(r => setTimeout(r, 200));
     }
     console.log(chalk.yellow('Daemon started (async check timeout, but likely running).'));
+    console.log(chalk.gray(`Logs: ${stdoutLog}`));
     process.exit(0);
 };
 const stopAction = async (options) => {
     try {
-        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.'));
+        const logPath = '/tmp/mcps-daemon/stdout.log';
+        const fs = await import('fs');
+        // 发送 stop 请求并显示日志
+        const requestPromise = daemonRequest('POST', '/stop');
+        // 显示关闭日志
+        const showLogs = async () => {
+            try {
+                if (!fs.existsSync(logPath)) {
+                    return;
+                }
+                let lastSize = fs.statSync(logPath).size;
+                const startTime = Date.now();
+                const timeout = 5000; // 5秒超时
+                while (Date.now() - startTime < timeout) {
+                    await new Promise(r => setTimeout(r, 200));
+                    try {
+                        const { size: currentSize } = fs.statSync(logPath);
+                        if (currentSize > lastSize) {
+                            const buffer = Buffer.alloc(currentSize - lastSize);
+                            const fd = fs.openSync(logPath, 'r');
+                            fs.readSync(fd, buffer, 0, currentSize - lastSize, lastSize);
+                            fs.closeSync(fd);
+                            const newLogs = buffer.toString('utf-8');
+                            const relevantLogs = newLogs.split('\n').filter(line => {
+                                return line.includes('Closing connection to') ||
+                                    line.includes('Shutting down');
+                            });
+                            if (relevantLogs.length > 0) {
+                                relevantLogs.forEach(log => {
+                                    if (log.trim()) {
+                                        console.log(chalk.yellow(log));
+                                    }
+                                });
+                                lastSize = currentSize;
+                            }
+                        }
+                    }
+                    catch (e) {
+                        // 忽略读取错误
+                    }
+                }
+            }
+            catch (e) {
+                // 忽略日志显示错误
+            }
+        };
+        const [{ ok }] = await Promise.all([
+            requestPromise,
+            showLogs()
+        ]);
+        if (ok) {
+            console.log(chalk.green('Daemon stopped successfully.'));
+        }
     }
     catch (e) {
         console.error(chalk.red('Failed to stop daemon. Is it running?'));
@@ -134,9 +242,7 @@ const stopAction = async (options) => {
 };
 const statusAction = async (options) => {
     try {
-        const port = parseInt(options?.port || process.env.MCPS_PORT || DAEMON_PORT);
-        const res = await fetch(`http://localhost:${port}/status`);
-        const data = await res.json();
+        const { data } = await daemonRequest('GET', '/status');
         console.log('');
         console.log(chalk.green(`Daemon is running (v${data.version})`));
         if (data.connections && data.connections.length > 0) {
@@ -195,16 +301,98 @@ const statusAction = async (options) => {
 };
 const restartAction = async (serverName, options) => {
     try {
-        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 })
-        });
-        const data = await res.json();
-        console.log(chalk.green(data.message));
+        const body = serverName ? JSON.stringify({ server: serverName }) : JSON.stringify({});
+        // 启动日志显示（在后台读取守护进程日志）
+        const logPath = '/tmp/mcps-daemon/stdout.log';
+        const fs = await import('fs');
+        // 发送 restart 请求
+        const requestPromise = daemonRequest('POST', '/restart', body);
+        // 在后台显示日志
+        const showLogs = async () => {
+            try {
+                if (!fs.existsSync(logPath)) {
+                    return;
+                }
+                // 获取当前日志文件大小
+                let lastSize = fs.statSync(logPath).size;
+                // 等待请求完成，同时显示新日志
+                const startTime = Date.now();
+                const timeout = 30000; // 30秒超时
+                while (Date.now() - startTime < timeout) {
+                    await new Promise(r => setTimeout(r, 200)); // 每200ms检查一次
+                    try {
+                        const { size: currentSize } = fs.statSync(logPath);
+                        if (currentSize > lastSize) {
+                            // 读取新增的日志内容
+                            const buffer = Buffer.alloc(currentSize - lastSize);
+                            const fd = fs.openSync(logPath, 'r');
+                            fs.readSync(fd, buffer, 0, currentSize - lastSize, lastSize);
+                            fs.closeSync(fd);
+                            const newLogs = buffer.toString('utf-8');
+                            // 只显示关闭和重启相关的日志
+                            const relevantLogs = newLogs.split('\n').filter(line => {
+                                return line.includes('Closing connection to') ||
+                                    line.includes('Connected ✓') ||
+                                    line.includes('Connecting to') ||
+                                    line.includes('Connected: ') ||
+                                    line.trim().startsWith('- '); // 包含服务名行
+                            });
+                            if (relevantLogs.length > 0) {
+                                // 检查是否已经完成
+                                const hasCompletion = newLogs.includes('All servers reinitialized successfully');
+                                relevantLogs.forEach(log => {
+                                    if (log.trim()) {
+                                        if (log.includes('Closing')) {
+                                            console.log(chalk.yellow(log));
+                                        }
+                                        else if (log.includes('Connected ✓')) {
+                                            console.log(chalk.green(log));
+                                        }
+                                        else if (log.includes('Connected:')) {
+                                            // 最终连接统计
+                                            console.log(chalk.green(log));
+                                        }
+                                        else {
+                                            console.log(log);
+                                        }
+                                    }
+                                });
+                                if (hasCompletion) {
+                                    break; // 完成后退出
+                                }
+                                // 更新起始位置
+                                lastSize = currentSize;
+                            }
+                        }
+                    }
+                    catch (e) {
+                        // 忽略读取错误
+                    }
+                }
+            }
+            catch (e) {
+                // 忽略日志显示错误
+            }
+        };
+        // 同时执行请求和日志显示
+        const [{ status, ok, data }] = await Promise.all([
+            requestPromise,
+            showLogs()
+        ]);
+        if (ok) {
+            console.log(chalk.green(data.message));
+        }
+        else if (status === 404) {
+            console.error(chalk.yellow(data.error || 'Server not found'));
+        }
+        else {
+            console.error(chalk.red(data.error || 'Failed to restart'));
+        }
     }
     catch (e) {
-        console.error(chalk.red('Failed to restart. Is the daemon running?'));
+        console.error(chalk.red('Failed to restart.'));
+        console.error(chalk.red(`Error: ${e.message}`));
+        console.error(chalk.gray(`Stack: ${e.stack}`));
     }
 };
 export const registerDaemonCommand = (program) => {
@@ -279,18 +467,57 @@ const startDaemon = (port) => {
             req.on('end', async () => {
                 try {
                     const { server: serverName } = JSON.parse(body || '{}');
+                    const verbose = process.env.MCPS_VERBOSE === 'true';
+                    if (verbose) {
+                        console.log(`[Daemon] Received restart request for: ${serverName || 'all servers'}`);
+                    }
                     if (serverName) {
+                        // Restart specific server connection
+                        if (verbose) {
+                            console.log(`[Daemon] Closing server: ${serverName}`);
+                        }
                         const closed = await connectionPool.closeClient(serverName);
-                        res.writeHead(200, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ message: `Server "${serverName}" connection closed. It will be reconnected on next call.`, closed }));
+                        if (closed) {
+                            // Reconnect to the specific server
+                            try {
+                                if (verbose) {
+                                    console.log(`[Daemon] Reconnecting to: ${serverName}`);
+                                }
+                                await connectionPool.getClient(serverName);
+                                if (verbose) {
+                                    console.log(`[Daemon] Successfully restarted: ${serverName}`);
+                                }
+                                res.writeHead(200, { 'Content-Type': 'application/json' });
+                                res.end(JSON.stringify({ message: `Server "${serverName}" restarted successfully.` }));
+                            }
+                            catch (error) {
+                                console.error(`[Daemon] Failed to reconnect to ${serverName}:`, error);
+                                res.writeHead(500, { 'Content-Type': 'application/json' });
+                                res.end(JSON.stringify({ error: `Failed to reconnect to "${serverName}": ${error.message}` }));
+                            }
+                        }
+                        else {
+                            if (verbose) {
+                                console.log(`[Daemon] Server not found: ${serverName}`);
+                            }
+                            res.writeHead(404, { 'Content-Type': 'application/json' });
+                            res.end(JSON.stringify({ error: `Server "${serverName}" not found or not connected.` }));
+                        }
                     }
                     else {
+                        // Restart all connections
+                        console.log('Closing all connections...');
                         await connectionPool.closeAll();
+                        console.log('All connections closed. Reinitializing...');
+                        // Reinitialize all servers
+                        await connectionPool.initializeAll();
+                        console.log('All servers reinitialized successfully');
                         res.writeHead(200, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ message: 'All connections closed.' }));
+                        res.end(JSON.stringify({ message: 'All servers restarted successfully.' }));
                     }
                 }
                 catch (error) {
+                    console.error('[Daemon] Error during restart:', error);
                     res.writeHead(500, { 'Content-Type': 'application/json' });
                     res.end(JSON.stringify({ error: error.message }));
                 }

package/dist/commands/server.js

@@ -1,7 +1,45 @@
 import chalk from 'chalk';
+import http from 'http';
 import { configManager } from '../core/config.js';
 import { DaemonClient } from '../core/daemon-client.js';
 import { detectServerType } from '../types/config.js';
+import { DAEMON_PORT } from '../core/constants.js';
+// Helper function to make HTTP requests to daemon (bypassing proxy)
+function daemonRequest(method, path, body) {
+    return new Promise((resolve, reject) => {
+        const port = parseInt(process.env.MCPS_PORT || String(DAEMON_PORT));
+        const options = {
+            method,
+            hostname: '127.0.0.1',
+            port,
+            path,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        };
+        const req = http.request(options, (res) => {
+            let data = '';
+            res.on('data', chunk => { data += chunk; });
+            res.on('end', () => {
+                try {
+                    resolve({
+                        status: res.statusCode || 500,
+                        ok: (res.statusCode || 500) >= 200 && (res.statusCode || 500) < 300,
+                        data: data ? JSON.parse(data) : {},
+                    });
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+        });
+        req.on('error', reject);
+        if (body) {
+            req.write(body);
+        }
+        req.end();
+    });
+}
 export const registerServerCommands = (program) => {
     const listServersAction = () => {
         const servers = configManager.listServers();
@@ -116,24 +154,17 @@ export const registerServerCommands = (program) => {
         if (!name) {
             try {
                 await DaemonClient.ensureDaemon();
-                // Call daemon restart API to refresh all connections
-                const port = parseInt(process.env.MCPS_PORT || '4100');
-                const res = await fetch(`http://localhost:${port}/restart`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({})
-                });
-                if (res.ok) {
-                    const data = await res.json();
+                // Call daemon restart API to restart all connections
+                const { ok, data } = await daemonRequest('POST', '/restart', JSON.stringify({}));
+                if (ok) {
                     console.log(chalk.green(data.message));
-                    console.log(chalk.gray('All servers will be reconnected on next use.'));
                 }
                 else {
-                    throw new Error('Failed to refresh connections');
+                    throw new Error(data.error || 'Failed to restart connections');
                 }
             }
             catch (error) {
-                console.error(chalk.red(`Failed to refresh all servers: ${error.message}`));
+                console.error(chalk.red(`Failed to restart all servers: ${error.message}`));
                 console.error(chalk.yellow('Make sure the daemon is running (use: mcps start)'));
             }
             return;

package/dist/core/client.js

@@ -112,7 +112,7 @@ export class McpClientService {
             });
             await this.client.connect(this.transport);
             // 连接成功后，立即查找并保存子进程 PID
-            if (config.type === 'stdio') {
+            if ('command' in config) {
                 await this.recordChildPids();
             }
         }
@@ -160,6 +160,10 @@ export class McpClientService {
             McpClientService.globalPidsBeforeConnection = afterSnapshot;
             // 过滤出匹配我们命令的进程
             const commandBaseName = this.serverCommand.split('/').pop() || this.serverCommand;
+            const verbose = process.env.MCPS_VERBOSE === 'true';
+            if (verbose) {
+                log(`[Daemon] ${this.serverName}: Found ${newPids.size} new PIDs: [${Array.from(newPids).join(', ')}]`);
+            }
             for (const pid of newPids) {
                 try {
                     const { stdout: cmdOutput } = await execAsync(`ps -p ${pid} -o command=`);
@@ -173,13 +177,18 @@ export class McpClientService {
                         }));
                     if (isMatch) {
                         this.childPids.add(pid);
-                        // 调试日志已移除
+                        if (verbose) {
+                            log(`[Daemon] ${this.serverName}: Added PID ${pid} to childPids (cmd: ${cmdLine.substring(0, 50)}...)`);
+                        }
                     }
                 }
                 catch {
                     // 进程可能已经不存在了
                 }
             }
+            if (verbose) {
+                log(`[Daemon] ${this.serverName}: Total childPids after collection: ${this.childPids.size}`);
+            }
         }
         catch (e) {
             // 记录失败，不影响主流程
@@ -200,23 +209,44 @@ export class McpClientService {
         });
     }
     close() {
+        const verbose = process.env.MCPS_VERBOSE === 'true';
         // 对于 stdio 类型的服务器，先杀掉子进程（在关闭 transport 之前）
         if (this.serverType === 'stdio' && this.childPids.size > 0) {
-            log(`[Daemon] Closing ${this.serverName}, killing ${this.childPids.size} child process(es)...`);
+            const pidList = Array.from(this.childPids).join(', ');
+            if (verbose) {
+                log(`[Daemon] Closing ${this.serverName}, killing PIDs: [${pidList}]`);
+            }
+            else {
+                // 简短版本，始终显示
+                log(`[Daemon] Closing ${this.serverName} (${this.childPids.size} process(es))`);
+            }
             // 直接使用 SIGKILL，确保进程被终止
             for (const pid of this.childPids) {
                 try {
                     process.kill(pid, 'SIGKILL');
-                    log(`[Daemon] SIGKILLED child process ${pid} (${this.serverName})`);
+                    if (verbose) {
+                        log(`[Daemon] SIGKILLED child process ${pid} (${this.serverName})`);
+                    }
                 }
                 catch (e) {
-                    log(`[Daemon] Failed to kill ${pid}: ${e}`);
+                    if (verbose) {
+                        log(`[Daemon] Failed to kill ${pid}: ${e.message}`);
+                    }
                 }
             }
             this.childPids.clear();
-            log(`[Daemon] All child processes cleared for ${this.serverName}`);
+            if (verbose) {
+                log(`[Daemon] All child processes cleared for ${this.serverName}`);
+            }
+        }
+        else {
+            if (verbose) {
+                log(`[Daemon] No child PIDs to kill for ${this.serverName} (childPids.size: ${this.childPids.size})`);
+            }
         }
         // 暂时不关闭 transport，避免卡住
-        log(`[Daemon] ${this.serverName} close() completed`);
+        if (verbose) {
+            log(`[Daemon] ${this.serverName} close() completed`);
+        }
     }
 }

package/dist/core/pool.js

@@ -55,17 +55,24 @@ export class ConnectionPool {
         return false;
     }
     async closeAll() {
+        const verbose = process.env.MCPS_VERBOSE === 'true';
+        if (verbose) {
+            console.log('closeAll() called');
+        }
         for (const [name, client] of this.clients) {
-            console.log(`[Daemon] Closing connection to ${name}...`);
+            console.log(`Closing connection to ${name}...`);
             try {
-                client.close(); // 同步调用，不使用 await
+                client.close();
             }
             catch (e) {
-                console.error(`[Daemon] Error closing ${name}:`, e);
+                console.error(`Error closing ${name}:`, e);
             }
         }
         this.clients.clear();
         this.toolsCache.clear();
+        if (verbose) {
+            console.log('Connection pools cleared');
+        }
     }
     async initializeAll() {
         const servers = configManager.listServers();
@@ -76,20 +83,20 @@ export class ConnectionPool {
         const enabledServers = servers.filter(server => {
             const disabled = server.disabled === true;
             if (verbose && disabled) {
-                console.log(`[Daemon] Skipping disabled server: ${server.name}`);
+                console.log(`Skipping disabled server: ${server.name}`);
             }
             return !disabled;
         });
         if (enabledServers.length === 0) {
-            console.log('[Daemon] No enabled servers to initialize.');
+            console.log('No enabled servers to initialize.');
             this.initializing = false;
             this.initialized = true;
             return;
         }
-        console.log(`[Daemon] Connecting to ${enabledServers.length} server(s)...`);
+        console.log(`Connecting to ${enabledServers.length} server(s)...`);
         const results = [];
         for (const server of enabledServers) {
-            process.stdout.write(`[Daemon] - ${server.name}... `);
+            process.stdout.write(`- ${server.name}... `);
             try {
                 await this.getClient(server.name, { timeoutMs: 8000 });
                 results.push({ name: server.name, success: true });
@@ -111,16 +118,16 @@ export class ConnectionPool {
                 results.push({ name: server.name, success: false, error: errorMsg });
                 console.log('Failed ✗');
                 if (verbose) {
-                    console.error(`[Daemon] Error: ${errorMsg}`);
+                    console.error(`Error: ${errorMsg}`);
                 }
             }
         }
         // Print summary
         const successCount = results.filter(r => r.success).length;
         const failed = results.filter(r => !r.success);
-        console.log(`[Daemon] Connected: ${successCount}/${enabledServers.length}`);
+        console.log(`Connected: ${successCount}/${enabledServers.length}`);
         if (failed.length > 0) {
-            console.log('[Daemon] Failed connections:');
+            console.log('Failed connections:');
             failed.forEach(f => {
                 console.log(`  ✗ ${f.name}: ${f.error}`);
             });

package/package.json

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