@maplezzk/mcps 1.0.3 → 1.0.8

package/dist/commands/call.js

@@ -1,36 +1,6 @@
 import chalk from 'chalk';
 import { configManager } from '../core/config.js';
-import { McpClientService } from '../core/client.js';
-const DAEMON_PORT = 4100;
-async function tryCallDaemon(serverName, toolName, args) {
-    try {
-        const response = await fetch(`http://localhost:${DAEMON_PORT}/call`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ server: serverName, tool: toolName, args }),
-        });
-        if (!response.ok) {
-            // If daemon returns error, we might want to show it or fallback?
-            // Let's assume 500 means daemon tried and failed, so we shouldn't fallback to local spawn as it might fail same way.
-            // But if 404/Connection Refused, then daemon is not running.
-            // fetch throws on connection refused.
-            const err = await response.json();
-            throw new Error(err.error || 'Daemon error');
-        }
-        const data = await response.json();
-        console.log(chalk.green('Tool execution successful (via Daemon):'));
-        printResult(data.result);
-        return true;
-    }
-    catch (error) {
-        // If connection failed (daemon not running), return false to fallback
-        if (error.cause?.code === 'ECONNREFUSED' || error.message.includes('fetch failed')) {
-            return false;
-        }
-        // If daemon connected but returned error (e.g. tool failed), rethrow
-        throw error;
-    }
-}
+import { DaemonClient } from '../core/daemon-client.js';
 function printResult(result) {
     if (result.content) {
         result.content.forEach((item) => {
@@ -82,34 +52,23 @@ Notes:
                 }
             });
         }
-        // 1. Try Daemon first
-        try {
-            const handled = await tryCallDaemon(serverName, toolName, params);
-            if (handled)
-                return;
-        }
-        catch (error) {
-            console.error(chalk.red(`Daemon call failed: ${error.message}`));
-            process.exit(1);
-        }
-        // 2. Fallback to standalone execution
+        // Check if server exists in config first
         const serverConfig = configManager.getServer(serverName);
         if (!serverConfig) {
-            console.error(chalk.red(`Server "${serverName}" not found.`));
+            console.error(chalk.red(`Server "${serverName}" not found in config.`));
             process.exit(1);
         }
-        const client = new McpClientService();
         try {
-            await client.connect(serverConfig);
-            const result = await client.callTool(toolName, params);
+            // Auto-start daemon if needed
+            await DaemonClient.ensureDaemon();
+            // Execute via daemon
+            const result = await DaemonClient.executeTool(serverName, toolName, params);
             console.log(chalk.green('Tool execution successful:'));
             printResult(result);
         }
         catch (error) {
-            console.error(chalk.red(`Tool call failed: ${error.message}`));
-        }
-        finally {
-            await client.close();
+            console.error(chalk.red(`Execution failed: ${error.message}`));
+            process.exit(1);
         }
     });
 };

package/dist/commands/daemon.js

@@ -1,37 +1,59 @@
 import http from 'http';
 import chalk from 'chalk';
 import { connectionPool } from '../core/pool.js';
-const PORT = 4100;
+import { createRequire } from 'module';
+import { DAEMON_PORT } from '../core/constants.js';
+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('Start the daemon (default)')
-        .option('-p, --port <number>', 'Port to listen on', String(PORT))
+        .option('-p, --port <number>', 'Port to listen on', String(DAEMON_PORT))
         .action(async (options) => {
         const port = parseInt(options.port);
-        // ... (server logic) ...
-        // Need to move the server creation logic here or keep it in the main action if no subcommands match?
-        // Commander handling of default commands with subcommands can be tricky.
-        // Let's refactor to use separate actions.
         startDaemon(port);
     });
     daemonCmd.command('stop')
         .description('Stop the running daemon')
         .action(async () => {
         try {
-            await fetch(`http://localhost:${PORT}/stop`, { method: 'POST' });
+            await fetch(`http://localhost:${DAEMON_PORT}/stop`, { method: 'POST' });
             console.log(chalk.green('Daemon stopped successfully.'));
         }
         catch (e) {
             console.error(chalk.red('Failed to stop daemon. Is it running?'));
         }
     });
+    daemonCmd.command('status')
+        .description('Check daemon status')
+        .action(async () => {
+        try {
+            const res = await fetch(`http://localhost:${DAEMON_PORT}/status`);
+            const data = await res.json();
+            console.log(chalk.green(`Daemon is running (v${data.version})`));
+            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 status = conn.status === 'error' ? chalk.red('[Error]') : '';
+                    console.log(chalk.cyan(`- ${conn.name} ${chalk.gray(count)} ${status}`));
+                });
+            }
+            else {
+                console.log(chalk.gray('No active connections.'));
+            }
+        }
+        catch (e) {
+            console.error(chalk.red('Daemon is not running.'));
+        }
+    });
     daemonCmd.command('restart [server]')
         .description('Restart the daemon or a specific server connection')
         .action(async (serverName) => {
         try {
-            const res = await fetch(`http://localhost:${PORT}/restart`, {
+            const res = await fetch(`http://localhost:${DAEMON_PORT}/restart`, {
                 method: 'POST',
                 body: JSON.stringify({ server: serverName })
             });
@@ -55,8 +77,13 @@ const startDaemon = (port) => {
             return;
         }
         if (req.method === 'GET' && req.url === '/status') {
+            const connections = await connectionPool.getActiveConnectionDetails();
             res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ status: 'running', version: '1.0.0' }));
+            res.end(JSON.stringify({
+                status: 'running',
+                version: pkg.version,
+                connections
+            }));
             return;
         }
         // ... (restart/stop/call handlers) ...
@@ -118,6 +145,30 @@ const startDaemon = (port) => {
             });
             return;
         }
+        if (req.method === 'POST' && req.url === '/list') {
+            let body = '';
+            req.on('data', chunk => { body += chunk.toString(); });
+            req.on('end', async () => {
+                try {
+                    const { server: serverName } = JSON.parse(body);
+                    if (!serverName) {
+                        res.writeHead(400, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ error: 'Missing server name' }));
+                        return;
+                    }
+                    const client = await connectionPool.getClient(serverName);
+                    const tools = await client.listTools();
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ tools }));
+                }
+                catch (error) {
+                    console.error(`[Daemon] Error listing tools:`, error);
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: error.message }));
+                }
+            });
+            return;
+        }
         res.writeHead(404);
         res.end();
     });

package/dist/commands/tools.js

@@ -1,49 +1,51 @@
 import chalk from 'chalk';
 import { configManager } from '../core/config.js';
-import { McpClientService } from '../core/client.js';
+import { DaemonClient } from '../core/daemon-client.js';
+function printTools(serverName, tools) {
+    console.log(chalk.bold(`\nAvailable Tools for ${serverName}:`));
+    if (!tools || tools.length === 0) {
+        console.log(chalk.yellow('No tools found.'));
+    }
+    else {
+        tools.forEach((tool) => {
+            console.log(chalk.cyan(`\n- ${tool.name}`));
+            if (tool.description) {
+                console.log(`  ${tool.description}`);
+            }
+            console.log(chalk.gray('  Arguments:'));
+            const schema = tool.inputSchema;
+            if (schema.properties) {
+                Object.entries(schema.properties).forEach(([key, value]) => {
+                    const required = schema.required?.includes(key) ? chalk.red('*') : '';
+                    console.log(`    ${key}${required}: ${value.type || 'any'} ${value.description ? `(${value.description})` : ''}`);
+                });
+            }
+            else {
+                console.log('    None');
+            }
+        });
+    }
+}
 export const registerToolsCommand = (program) => {
     program.command('tools <server>')
         .description('List available tools on a server')
         .action(async (serverName) => {
+        // Check if server exists in config first
         const serverConfig = configManager.getServer(serverName);
         if (!serverConfig) {
-            console.error(chalk.red(`Server "${serverName}" not found.`));
+            console.error(chalk.red(`Server "${serverName}" not found in config.`));
             process.exit(1);
         }
-        const client = new McpClientService();
         try {
-            // console.log(chalk.gray(`Connecting to ${serverName}...`));
-            await client.connect(serverConfig);
-            const tools = await client.listTools();
-            console.log(chalk.bold(`\nAvailable Tools for ${serverName}:`));
-            if (tools.tools.length === 0) {
-                console.log(chalk.yellow('No tools found.'));
-            }
-            else {
-                tools.tools.forEach(tool => {
-                    console.log(chalk.cyan(`\n- ${tool.name}`));
-                    if (tool.description) {
-                        console.log(`  ${tool.description}`);
-                    }
-                    console.log(chalk.gray('  Arguments:'));
-                    const schema = tool.inputSchema;
-                    if (schema.properties) {
-                        Object.entries(schema.properties).forEach(([key, value]) => {
-                            const required = schema.required?.includes(key) ? chalk.red('*') : '';
-                            console.log(`    ${key}${required}: ${value.type || 'any'} ${value.description ? `(${value.description})` : ''}`);
-                        });
-                    }
-                    else {
-                        console.log('    None');
-                    }
-                });
-            }
+            // Auto-start daemon if needed
+            await DaemonClient.ensureDaemon();
+            // List via daemon
+            const tools = await DaemonClient.listTools(serverName);
+            printTools(serverName, tools);
         }
         catch (error) {
             console.error(chalk.red(`Failed to list tools: ${error.message}`));
-        }
-        finally {
-            await client.close();
+            process.exit(1);
         }
     });
 };

package/dist/core/constants.js

@@ -0,0 +1,2 @@
+export const DAEMON_PORT = 4100;
+export const DAEMON_BASE_URL = `http://localhost:${DAEMON_PORT}`;

package/dist/core/daemon-client.js

@@ -0,0 +1,66 @@
+import { spawn } from 'child_process';
+import chalk from 'chalk';
+import { DAEMON_BASE_URL } from './constants.js';
+export class DaemonClient {
+    static async isRunning() {
+        try {
+            const res = await fetch(`${DAEMON_BASE_URL}/status`);
+            return res.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    static async startDaemon() {
+        console.log(chalk.gray('Starting background daemon...'));
+        // Use process.argv[1] which points to the CLI entry point
+        // detached: true allows the child to keep running after parent exits
+        const subprocess = spawn(process.execPath, [process.argv[1], 'daemon', 'start'], {
+            detached: true,
+            stdio: 'ignore',
+            env: process.env
+        });
+        subprocess.unref();
+        // Wait for daemon to be ready
+        const start = Date.now();
+        while (Date.now() - start < 5000) { // 5s timeout
+            if (await this.isRunning()) {
+                return;
+            }
+            await new Promise(resolve => setTimeout(resolve, 200));
+        }
+        throw new Error('Daemon failed to start within timeout');
+    }
+    static async ensureDaemon() {
+        if (await this.isRunning()) {
+            return;
+        }
+        await this.startDaemon();
+    }
+    static async executeTool(serverName, toolName, args) {
+        const response = await fetch(`${DAEMON_BASE_URL}/call`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ server: serverName, tool: toolName, args }),
+        });
+        if (!response.ok) {
+            const err = await response.json();
+            throw new Error(err.error || 'Daemon error');
+        }
+        const data = await response.json();
+        return data.result;
+    }
+    static async listTools(serverName) {
+        const response = await fetch(`${DAEMON_BASE_URL}/list`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ server: serverName }),
+        });
+        if (!response.ok) {
+            const err = await response.json();
+            throw new Error(err.error || 'Daemon error');
+        }
+        const data = await response.json();
+        return data.tools;
+    }
+}

package/dist/core/pool.js

@@ -42,5 +42,21 @@ export class ConnectionPool {
         }
         this.clients.clear();
     }
+    async getActiveConnectionDetails() {
+        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';
+            }
+            details.push({ name, toolsCount, status });
+        }
+        return details;
+    }
 }
 export const connectionPool = new ConnectionPool();

package/dist/index.js

@@ -4,11 +4,14 @@ import { registerServerCommands } from './commands/server.js';
 import { registerToolsCommand } from './commands/tools.js';
 import { registerCallCommand } from './commands/call.js';
 import { registerDaemonCommand } from './commands/daemon.js';
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
 const program = new Command();
 program
     .name('mcps')
     .description('A CLI to manage and use MCP servers')
-    .version('1.0.0');
+    .version(pkg.version);
 registerServerCommands(program);
 registerToolsCommand(program);
 registerCallCommand(program);

package/package.json

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