@maplezzk/mcps 1.1.2 → 1.1.4

package/README.md

@@ -308,6 +308,275 @@ mcps 通过以下方式优化性能：
 - 查看状态：~200ms
 - 调用工具：~50-100ms
 
+## 开发工作流
+
+欢迎贡献代码！以下是参与项目开发的完整流程。
+
+### 环境准备
+
+**前置要求：**
+- Node.js >= 20
+- npm >= 9
+- Git
+
+**克隆项目：**
+```bash
+git clone https://github.com/a13835614623/mcps.git
+cd mcps
+```
+
+**安装依赖：**
+```bash
+npm install
+```
+
+### 本地开发
+
+**开发模式（使用 ts-node 直接运行）：**
+```bash
+npm run dev -- <command>
+# 例如
+npm run dev -- ls
+npm run dev -- start
+```
+
+**构建项目：**
+```bash
+npm run build
+```
+
+**运行构建后的版本：**
+```bash
+npm start -- <command>
+# 或者
+node dist/index.js <command>
+```
+
+### 测试
+
+**运行测试：**
+```bash
+# 运行所有测试
+npm test
+
+# 监听模式（开发时推荐）
+npm run test:watch
+
+# 启动测试 UI 界面
+npm run test:ui
+
+# 生成测试覆盖率报告
+npm run test:coverage
+```
+
+**测试要求：**
+- 所有测试必须通过
+- 新功能需要添加相应的测试
+- 保持测试覆盖率在合理水平
+
+### 提交规范
+
+**提交信息格式：**
+```
+<type>: <description>
+
+[optional body]
+
+Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
+```
+
+**提交类型（type）：**
+- `feat`: 新功能
+- `fix`: 修复 bug
+- `chore`: 构建过程或辅助工具的变动
+- `docs`: 文档更新
+- `refactor`: 重构（既不是新增功能，也不是修复 bug）
+- `style`: 代码格式调整（不影响代码运行的变动）
+- `test`: 增加测试
+- `perf`: 性能优化
+
+**示例：**
+```bash
+feat: 支持可配置的 daemon 启动超时时间
+
+新增功能：
+- 支持通过命令行参数 --timeout/-t 设置超时
+- 支持通过环境变量 MCPS_DAEMON_TIMEOUT 设置超时
+- 支持通过配置文件 daemonTimeout 字段设置超时
+
+Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
+```
+
+### PR 流程
+
+**1. 创建功能分支：**
+```bash
+git checkout -b feature/your-feature-name
+# 或
+git checkout -b fix/your-bug-fix
+```
+
+**分支命名规范：**
+- `feature/` - 新功能
+- `fix/` - bug 修复
+- `refactor/` - 重构
+- `docs/` - 文档更新
+- `chore/` - 构建/工具更新
+
+**2. 开发并提交：**
+```bash
+# 进行开发...
+npm run build  # 确保构建成功
+npm test       # 确保测试通过
+
+# 提交代码
+git add .
+git commit -m "feat: 你的功能描述"
+```
+
+**3. 更新版本号（如需要）：**
+```bash
+# Patch 版本（bug 修复）
+npm version patch
+
+# Minor 版本（新功能）
+npm version minor
+
+# Major 版本（破坏性变更）
+npm version major
+```
+
+**4. 推送并创建 PR：**
+```bash
+git push origin feature/your-feature-name
+```
+
+然后访问 GitHub 创建 Pull Request，或在命令行使用：
+```bash
+gh pr create --title "feat: 功能标题" --body "PR 描述"
+```
+
+**5. PR 检查清单：**
+- ✅ CI 测试通过（GitHub Actions）
+- ✅ 代码通过所有测试
+- ✅ 新功能有对应的测试
+- ✅ 提交信息符合规范
+- ✅ PR 描述清晰说明了变更内容
+- ✅ 版本号已正确更新（如需要）
+
+**6. 解决冲突（如有）：**
+```bash
+# 如果 main 分支有更新，先合并最新代码
+git fetch origin
+git merge origin/main
+
+# 解决冲突后
+git add .
+git commit -m "chore: merge main and resolve conflicts"
+git push origin feature/your-feature-name
+```
+
+### 发布流程
+
+项目采用**自动化发布**流程：
+
+**1. 版本管理：**
+- 修改 `package.json` 中的版本号
+- 或使用 `npm version` 命令
+
+**2. 发布触发：**
+- 当 PR 合并到 `main` 分支时
+- 如果版本号发生变化
+- GitHub Actions 自动发布到 npm
+
+**3. 版本号规则：**
+- `1.0.0` → `1.0.1` (Patch): bug 修复
+- `1.0.1` → `1.1.0` (Minor): 新功能
+- `1.1.0` → `2.0.0` (Major): 破坏性变更
+
+**4. 预发布版本（可选）：**
+```bash
+npm version prerelease --preid beta
+# 生成 1.0.0-beta.0
+```
+
+预发布版本会发布到 npm 的 `beta` tag。
+
+**5. 跳过发布：**
+如果 PR 不需要发布，在标题中添加 `[skip release]`：
+```
+[skip release] chore: 更新文档
+```
+
+### CI/CD
+
+**CI 检查（.github/workflows/ci.yml）：**
+- 每次 PR 和 push 都会触发
+- 运行测试套件
+- 构建项目
+- 确保代码质量
+
+**Release 自动化（.github/workflows/release.yml）：**
+- PR 合并后触发
+- 检测版本号变化
+- 自动发布到 npm
+- 创建 GitHub Release
+
+### 代码规范
+
+**TypeScript：**
+- 使用 TypeScript 进行类型检查
+- 运行 `npm run build` 检查类型错误
+
+**代码风格：**
+- 遵循项目现有代码风格
+- 使用有意义的变量和函数名
+- 添加必要的注释
+
+**项目结构：**
+```
+mcps/
+├── src/
+│   ├── commands/      # 命令实现
+│   ├── core/          # 核心功能
+│   ├── types/         # 类型定义
+│   └── index.ts       # 入口文件
+├── test/              # 测试文件
+├── dist/              # 构建输出
+└── package.json
+```
+
+### 常见问题（开发）
+
+**Q: 如何调试代码？**
+```bash
+# 使用开发模式运行
+npm run dev -- start --verbose
+
+# 或构建后直接运行
+npm run build
+node --inspect dist/index.js <command>
+```
+
+**Q: 测试失败了怎么办？**
+```bash
+# 运行特定测试文件
+npm test -- <test-file>
+
+# 查看详细输出
+npm test -- --reporter=verbose
+```
+
+**Q: 如何本地测试 npm 包？**
+```bash
+# 在项目根目录
+npm link
+
+# 在其他项目中使用
+npm link @maplezzk/mcps
+mcps ls
+```
+
 ## 常见问题
 
 **Q: 如何查看所有服务器的运行状态？**

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,26 +143,46 @@ 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' });
+        await daemonRequest('POST', '/stop');
         console.log(chalk.green('Daemon stopped successfully.'));
     }
     catch (e) {
@@ -134,9 +191,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 +250,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 +416,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 }));
                 }
@@ -342,6 +518,14 @@ const startDaemon = (port) => {
                         res.end(JSON.stringify({ error: 'Missing server name' }));
                         return;
                     }
+                    // Try to use cached tools first
+                    const cachedTools = connectionPool.getCachedTools(serverName);
+                    if (cachedTools !== null) {
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ tools: cachedTools }));
+                        return;
+                    }
+                    // Fallback: fetch from client if not cached
                     const client = await connectionPool.getClient(serverName);
                     const toolsResult = await client.listTools();
                     res.writeHead(200, { 'Content-Type': 'application/json' });

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

@@ -2,7 +2,7 @@ import { McpClientService } from './client.js';
 import { configManager } from './config.js';
 export class ConnectionPool {
     clients = new Map();
-    toolsCache = new Map();
+    toolsCache = new Map(); // Cache full tools result
     initializing = false;
     initialized = false;
     async getClient(serverName, options) {
@@ -25,17 +25,20 @@ export class ConnectionPool {
             await connectPromise;
         }
         this.clients.set(serverName, client);
-        // Cache tools count after connection
+        // Cache full tools result after connection
         try {
             const result = await client.listTools();
-            this.toolsCache.set(serverName, result.tools.length);
+            this.toolsCache.set(serverName, result.tools || []);
         }
         catch (e) {
-            // Connection succeeded but listTools failed, cache as 0
-            this.toolsCache.set(serverName, 0);
+            // Connection succeeded but listTools failed, cache as empty array
+            this.toolsCache.set(serverName, []);
         }
         return client;
     }
+    getCachedTools(serverName) {
+        return this.toolsCache.has(serverName) ? this.toolsCache.get(serverName) : null;
+    }
     async closeClient(serverName) {
         if (this.clients.has(serverName)) {
             console.log(`[Daemon] Closing connection to ${serverName}...`);
@@ -52,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();
@@ -73,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 });
@@ -108,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}`);
             });
@@ -136,14 +146,14 @@ export class ConnectionPool {
             if (includeTools) {
                 // Use cached tools count instead of calling listTools again
                 if (this.toolsCache.has(name)) {
-                    toolsCount = this.toolsCache.get(name);
+                    toolsCount = this.toolsCache.get(name).length;
                 }
                 else {
                     // Fallback: if not cached, fetch it now
                     try {
                         const result = await client.listTools();
                         toolsCount = result.tools.length;
-                        this.toolsCache.set(name, toolsCount);
+                        this.toolsCache.set(name, result.tools || []);
                     }
                     catch (e) {
                         status = 'error';

package/package.json

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