@maplezzk/mcps 1.0.8 → 1.0.14

package/dist/commands/daemon.js

@@ -1,3 +1,4 @@
+import { spawn } from 'child_process';
 import http from 'http';
 import chalk from 'chalk';
 import { connectionPool } from '../core/pool.js';
@@ -7,13 +8,71 @@ const require = createRequire(import.meta.url);
 const pkg = require('../../package.json');
 export const registerDaemonCommand = (program) => {
     const daemonCmd = program.command('daemon')
-        .description('Manage the mcps daemon');
-    daemonCmd.command('start', { isDefault: true })
+        .description('Manage the mcps daemon')
+        .usage('start|stop|restart|status'); // Simplify usage display
+    daemonCmd.command('start', { isDefault: true, hidden: true }) // Hide default start from help but keep functionality
         .description('Start the daemon (default)')
         .option('-p, --port <number>', 'Port to listen on', String(DAEMON_PORT))
         .action(async (options) => {
         const port = parseInt(options.port);
-        startDaemon(port);
+        // Check if already running
+        try {
+            const res = await fetch(`http://localhost:${port}/status`);
+            if (res.ok) {
+                console.log(chalk.yellow(`Daemon is already running on port ${port}.`));
+                return;
+            }
+        }
+        catch {
+            // Not running, safe to start
+            // If we are already detached (indicated by env var), run the server
+            if (process.env.MCPS_DAEMON_DETACHED === 'true') {
+                startDaemon(port);
+                return;
+            }
+            // Otherwise, spawn a detached process
+            console.log(chalk.gray('Starting daemon in background...'));
+            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'],
+                env: {
+                    ...process.env,
+                    MCPS_DAEMON_DETACHED: 'true'
+                }
+            });
+            // Stream logs to current console while waiting for ready
+            if (subprocess.stdout) {
+                subprocess.stdout.on('data', (data) => {
+                    process.stdout.write(chalk.gray(`[Daemon] ${data}`));
+                });
+            }
+            if (subprocess.stderr) {
+                subprocess.stderr.on('data', (data) => {
+                    process.stderr.write(chalk.red(`[Daemon] ${data}`));
+                });
+            }
+            subprocess.unref();
+            // Wait briefly to ensure it started (optional but good UX)
+            // We can poll status for a second
+            const start = Date.now();
+            // Increased timeout to allow for connection initialization
+            while (Date.now() - start < 10000) {
+                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);
+                        }
+                    }
+                }
+                catch { }
+                await new Promise(r => setTimeout(r, 200));
+            }
+            console.log(chalk.yellow('Daemon started (async check timeout, but likely running).'));
+        }
     });
     daemonCmd.command('stop')
         .description('Stop the running daemon')
@@ -36,7 +95,7 @@ export const registerDaemonCommand = (program) => {
             if (data.connections && data.connections.length > 0) {
                 console.log(chalk.bold('\nActive Connections:'));
                 data.connections.forEach((conn) => {
-                    const count = conn.toolsCount !== null ? `(${conn.toolsCount} tools)` : '(error listing tools)';
+                    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}`));
                 });
@@ -67,7 +126,10 @@ export const registerDaemonCommand = (program) => {
 };
 const startDaemon = (port) => {
     const server = http.createServer(async (req, res) => {
-        // ... (middleware) ...
+        // Basic Error Handling
+        req.on('error', (err) => {
+            console.error('[Daemon] Request error:', err);
+        });
         res.setHeader('Access-Control-Allow-Origin', '*');
         res.setHeader('Access-Control-Allow-Methods', 'POST, GET, OPTIONS');
         res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
@@ -77,12 +139,14 @@ const startDaemon = (port) => {
             return;
         }
         if (req.method === 'GET' && req.url === '/status') {
-            const connections = await connectionPool.getActiveConnectionDetails();
+            const initStatus = connectionPool.getInitStatus();
+            const connections = await connectionPool.getActiveConnectionDetails(!initStatus.initializing);
             res.writeHead(200, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({
                 status: 'running',
                 version: pkg.version,
-                connections
+                connections,
+                ...initStatus
             }));
             return;
         }
@@ -157,9 +221,9 @@ const startDaemon = (port) => {
                         return;
                     }
                     const client = await connectionPool.getClient(serverName);
-                    const tools = await client.listTools();
+                    const toolsResult = await client.listTools();
                     res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ tools }));
+                    res.end(JSON.stringify(toolsResult));
                 }
                 catch (error) {
                     console.error(`[Daemon] Error listing tools:`, error);
@@ -172,14 +236,19 @@ const startDaemon = (port) => {
         res.writeHead(404);
         res.end();
     });
-    server.listen(port, () => {
-        console.log(chalk.green(`
-🚀 mcps Daemon started on port ${port}
------------------------------------
-- Keeps connections to MCP servers alive
-- Improves performance for frequent tool calls
-- Run 'mcps call ...' in another terminal to use it automatically
-        `));
+    server.listen(port, async () => {
+        // Initialize all connections eagerly
+        await connectionPool.initializeAll();
+    });
+    server.on('error', (e) => {
+        if (e.code === 'EADDRINUSE') {
+            console.log(chalk.yellow(`Port ${port} is already in use.`));
+            process.exit(0); // Exit gracefully if already running
+        }
+        else {
+            console.error('[Daemon] Server error:', e);
+            process.exit(1);
+        }
     });
     const shutdown = async () => {
         console.log('\n[Daemon] Shutting down...');

package/dist/commands/server.js

@@ -1,12 +1,7 @@
 import chalk from 'chalk';
 import { configManager } from '../core/config.js';
 export const registerServerCommands = (program) => {
-    const serverCmd = program.command('server')
-        .description('Manage MCP servers');
-    serverCmd.command('list')
-        .alias('ls')
-        .description('List all configured servers')
-        .action(() => {
+    const listServersAction = () => {
         const servers = configManager.listServers();
         if (servers.length === 0) {
             console.log(chalk.yellow('No servers configured.'));
@@ -25,7 +20,18 @@ export const registerServerCommands = (program) => {
             }
             console.log('');
         });
-    });
+    };
+    // Register top-level list command
+    program.command('list')
+        .alias('ls')
+        .description('List all configured servers')
+        .action(listServersAction);
+    const serverCmd = program.command('server')
+        .description('Manage MCP servers');
+    serverCmd.command('list')
+        .alias('ls')
+        .description('List all configured servers')
+        .action(listServersAction);
     serverCmd.command('add <name>')
         .description('Add a new MCP server')
         .option('--type <type>', 'Server type (stdio, sse, or http)', 'stdio')
@@ -86,12 +92,15 @@ export const registerServerCommands = (program) => {
     serverCmd.command('update <name>')
         .description('Update a server')
         .option('--command <command>', 'New command')
+        .option('--args [args...]', 'New arguments for the command')
         .option('--url <url>', 'New URL')
         .action((name, options) => {
         try {
             const updates = {};
             if (options.command)
                 updates.command = options.command;
+            if (options.args)
+                updates.args = options.args;
             if (options.url)
                 updates.url = options.url;
             if (Object.keys(updates).length === 0) {

package/dist/core/client.js

@@ -6,13 +6,39 @@ import { EventSource } from 'eventsource';
 // Required for SSEClientTransport in Node.js environment
 // @ts-ignore
 global.EventSource = EventSource;
+const resolveEnvPlaceholders = (input) => {
+    const missing = new Set();
+    const resolved = input.replace(/\$\{([A-Za-z0-9_]+)\}|\$([A-Za-z0-9_]+)/g, (match, braced, bare) => {
+        const key = braced || bare;
+        const val = process.env[key];
+        if (val === undefined) {
+            missing.add(key);
+            return match;
+        }
+        return val;
+    });
+    if (missing.size > 0) {
+        const list = Array.from(missing).join(', ');
+        throw new Error(`Missing environment variables: ${list}`);
+    }
+    return resolved;
+};
 export class McpClientService {
     client = null;
     transport = null;
     async connect(config) {
         try {
             if (config.type === 'stdio') {
-                const rawEnv = config.env ? { ...process.env, ...config.env } : process.env;
+                const resolvedConfigEnv = {};
+                if (config.env) {
+                    for (const key in config.env) {
+                        const val = config.env[key];
+                        if (typeof val === 'string') {
+                            resolvedConfigEnv[key] = resolveEnvPlaceholders(val);
+                        }
+                    }
+                }
+                const rawEnv = config.env ? { ...process.env, ...resolvedConfigEnv } : process.env;
                 const env = {};
                 for (const key in rawEnv) {
                     const val = rawEnv[key];
@@ -20,17 +46,20 @@ export class McpClientService {
                         env[key] = val;
                     }
                 }
+                const args = config.args ? config.args.map(arg => resolveEnvPlaceholders(arg)) : [];
                 this.transport = new StdioClientTransport({
                     command: config.command,
-                    args: config.args,
+                    args,
                     env: env,
                 });
             }
             else if (config.type === 'http') {
-                this.transport = new StreamableHTTPClientTransport(new URL(config.url));
+                const url = resolveEnvPlaceholders(config.url);
+                this.transport = new StreamableHTTPClientTransport(new URL(url));
             }
             else {
-                this.transport = new SSEClientTransport(new URL(config.url));
+                const url = resolveEnvPlaceholders(config.url);
+                this.transport = new SSEClientTransport(new URL(url));
             }
             this.client = new Client({
                 name: 'mcp-cli',

package/dist/core/daemon-client.js

@@ -61,6 +61,7 @@ export class DaemonClient {
             throw new Error(err.error || 'Daemon error');
         }
         const data = await response.json();
-        return data.tools;
+        // The daemon returns { tools: { tools: [...] } } because of ListToolsResult wrapping
+        return data.tools.tools || [];
     }
 }

package/dist/core/pool.js

@@ -2,7 +2,9 @@ import { McpClientService } from './client.js';
 import { configManager } from './config.js';
 export class ConnectionPool {
     clients = new Map();
-    async getClient(serverName) {
+    initializing = false;
+    initialized = false;
+    async getClient(serverName, options) {
         if (this.clients.has(serverName)) {
             return this.clients.get(serverName);
         }
@@ -10,9 +12,17 @@ export class ConnectionPool {
         if (!serverConfig) {
             throw new Error(`Server "${serverName}" not found in config.`);
         }
-        console.log(`[Daemon] Connecting to server: ${serverName}...`);
         const client = new McpClientService();
-        await client.connect(serverConfig);
+        const connectPromise = client.connect(serverConfig);
+        if (options?.timeoutMs) {
+            const timeoutPromise = new Promise((_, reject) => {
+                setTimeout(() => reject(new Error(`Connection timeout after ${options.timeoutMs}ms`)), options.timeoutMs);
+            });
+            await Promise.race([connectPromise, timeoutPromise]);
+        }
+        else {
+            await connectPromise;
+        }
         this.clients.set(serverName, client);
         return client;
     }
@@ -42,17 +52,55 @@ export class ConnectionPool {
         }
         this.clients.clear();
     }
-    async getActiveConnectionDetails() {
+    async initializeAll() {
+        const servers = configManager.listServers();
+        this.initializing = true;
+        this.initialized = false;
+        // 过滤掉 disabled 的服务器
+        const enabledServers = servers.filter(server => {
+            const disabled = server.disabled === true;
+            if (disabled) {
+                console.log(`[Daemon] Skipping disabled server: ${server.name}`);
+            }
+            return !disabled;
+        });
+        if (enabledServers.length === 0) {
+            console.log('[Daemon] No enabled servers to initialize.');
+            this.initializing = false;
+            this.initialized = true;
+            return;
+        }
+        console.log(`[Daemon] Initializing ${enabledServers.length} connection(s)...`);
+        for (const server of enabledServers) {
+            try {
+                console.log(`[Daemon] Connecting to server: ${server.name}...`);
+                await this.getClient(server.name, { timeoutMs: 8000 });
+                console.log(`[Daemon] ✓ Connected to ${server.name}`);
+            }
+            catch (error) {
+                console.error(`[Daemon] ✗ Failed to connect to ${server.name}:`, error.message);
+            }
+        }
+        this.initializing = false;
+        this.initialized = true;
+        console.log('[Daemon] Initialization complete.');
+    }
+    getInitStatus() {
+        return { initializing: this.initializing, initialized: this.initialized };
+    }
+    async getActiveConnectionDetails(includeTools = true) {
         const details = [];
         for (const [name, client] of this.clients) {
             let toolsCount = null;
             let status = 'connected';
-            try {
-                const result = await client.listTools();
-                toolsCount = result.tools.length;
-            }
-            catch (e) {
-                status = 'error';
+            if (includeTools) {
+                try {
+                    const result = await client.listTools();
+                    toolsCount = result.tools.length;
+                }
+                catch (e) {
+                    status = 'error';
+                }
             }
             details.push({ name, toolsCount, status });
         }

package/package.json

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