@maplezzk/mcps 1.0.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,121 @@
+# mcps - MCP CLI Manager
+
+[English](./README_EN.md) | [简体中文](./README.md)
+
+一个用于管理和交互 [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) 服务的强大命令行工具。
+
+## 功能特性
+
+- 🔌 **服务管理**：轻松添加、移除、查看和更新 MCP 服务（支持 Stdio 和 SSE 模式）。
+- 🛠️ **工具发现**：查看已配置服务中所有可用的工具。
+- 🚀 **工具执行**：直接在命令行调用工具，支持参数自动解析。
+- 🔄 **持久化存储**：配置自动保存至 `~/.mcps/mcp.json`。
+
+## 安装
+
+```bash
+npm install -g @maplezzk/mcps
+```
+
+## 使用指南
+
+### 1. 守护进程 (Daemon Mode)
+
+mcps 支持守护进程模式，可以保持与 MCP 服务的长连接，显著提高频繁调用的性能。
+
+**启动守护进程：**
+```bash
+mcps daemon
+```
+或者
+```bash
+mcps daemon start
+```
+
+**重启连接：**
+如果修改了配置文件，或者服务出现异常，可以使用重启命令刷新连接：
+
+```bash
+# 重置所有连接
+mcps daemon restart
+
+# 仅重置特定服务的连接
+mcps daemon restart my-server
+```
+
+**停止守护进程：**
+```bash
+mcps daemon stop
+```
+
+### 2. 服务管理 (Server Management)
+
+**查看所有服务：**
+```bash
+mcps server list
+```
+
+**添加 Stdio 服务：**
+```bash
+# 添加本地 Node.js 服务
+mcps server add my-server --command node --args ./build/index.js
+
+# 使用 npx/uvx 添加服务
+mcps server add fetch --command uvx --args mcp-server-fetch
+```
+
+**添加 SSE 服务：**
+```bash
+mcps server add remote-server --type sse --url http://localhost:8000/sse
+```
+
+**添加 Streamable HTTP 服务：**
+```bash
+mcps server add my-http-server --type http --url http://localhost:8000/mcp
+```
+
+**移除服务：**
+```bash
+mcps server remove my-server
+```
+
+### 2. 工具交互 (Tool Interaction)
+
+**查看服务下的可用工具：**
+```bash
+mcps tools fetch
+```
+
+**调用工具：**
+
+语法：
+```bash
+mcps call <server_name> <tool_name> [arguments...]
+```
+
+- `<server_name>`: 已配置的 MCP 服务名称
+- `<tool_name>`: 要调用的工具名称
+- `[arguments...]`: 以 `key=value` 形式传递的参数。CLI 会尝试自动将值解析为 JSON（数字、布尔值、对象）。
+
+示例：
+```bash
+# 简单的字符串参数
+mcps call fetch fetch url="https://example.com"
+
+# JSON 对象参数
+mcps call my-server createUser user='{"name": "Alice", "age": 30}'
+
+# 布尔值/数字参数
+mcps call my-server config debug=true timeout=5000
+```
+
+## 配置文件
+
+默认情况下，配置文件存储在：
+`~/.mcps/mcp.json`
+
+您可以通过设置 `MCP_CONFIG_DIR` 环境变量来更改存储位置。
+
+## 许可证
+
+ISC

package/dist/commands/call.js

@@ -0,0 +1,115 @@
+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;
+    }
+}
+function printResult(result) {
+    if (result.content) {
+        result.content.forEach((item) => {
+            if (item.type === 'text') {
+                console.log(item.text);
+            }
+            else if (item.type === 'image') {
+                console.log(`[Image: ${item.mimeType}]`);
+            }
+            else if (item.type === 'resource') {
+                console.log(`[Resource: ${item.resource.uri}]`);
+            }
+        });
+    }
+    else {
+        console.log(JSON.stringify(result, null, 2));
+    }
+}
+export const registerCallCommand = (program) => {
+    program.command('call <server> <tool> [args...]')
+        .description('Call a tool on a server. Arguments format: key=value')
+        .addHelpText('after', `
+Examples:
+  $ mcps call my-server echo message="Hello World"
+  $ mcps call my-server add a=10 b=20
+  $ mcps call my-server config debug=true
+  $ mcps call my-server createUser user='{"name":"Alice","age":30}'
+
+Notes:
+  - Arguments are parsed as key=value pairs.
+  - Values are automatically parsed as JSON if possible (numbers, booleans, objects).
+  - If JSON parsing fails, the value is treated as a string.
+  - For strings with spaces, wrap the value in quotes (e.g., msg="hello world").
+`)
+        .action(async (serverName, toolName, args) => {
+        const params = {};
+        if (args) {
+            args.forEach((arg) => {
+                const eqIndex = arg.indexOf('=');
+                if (eqIndex > 0) {
+                    const key = arg.slice(0, eqIndex);
+                    const valStr = arg.slice(eqIndex + 1);
+                    try {
+                        params[key] = JSON.parse(valStr);
+                    }
+                    catch {
+                        params[key] = valStr;
+                    }
+                }
+            });
+        }
+        // 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
+        const serverConfig = configManager.getServer(serverName);
+        if (!serverConfig) {
+            console.error(chalk.red(`Server "${serverName}" not found.`));
+            process.exit(1);
+        }
+        const client = new McpClientService();
+        try {
+            await client.connect(serverConfig);
+            const result = await client.callTool(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();
+        }
+    });
+};

package/dist/commands/config.js

@@ -0,0 +1,83 @@
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { configManager } from '../core/config.js';
+export const registerConfigCommand = (program) => {
+    const configCmd = program.command('config')
+        .description('Manage configuration');
+    configCmd.command('import <file>')
+        .description('Import servers from a JSON configuration file (e.g., mcporter.json)')
+        .option('-f, --force', 'Overwrite existing servers with the same name', false)
+        .action((file, options) => {
+        try {
+            const absolutePath = path.resolve(file);
+            if (!fs.existsSync(absolutePath)) {
+                console.error(chalk.red(`File not found: ${absolutePath}`));
+                process.exit(1);
+            }
+            const content = fs.readFileSync(absolutePath, 'utf-8');
+            let json;
+            try {
+                json = JSON.parse(content);
+            }
+            catch (e) {
+                console.error(chalk.red('Invalid JSON file.'));
+                process.exit(1);
+            }
+            let importedCount = 0;
+            let skippedCount = 0;
+            // Support standard MCP config format (mcpServers object)
+            const serversMap = json.mcpServers || {};
+            Object.entries(serversMap).forEach(([name, config]) => {
+                // Skip disabled servers
+                if (config.disabled === true) {
+                    skippedCount++;
+                    return;
+                }
+                const serverName = name;
+                let newServer;
+                if (config.command) {
+                    newServer = {
+                        name: serverName,
+                        type: 'stdio',
+                        command: config.command,
+                        args: config.args || [],
+                        env: config.env,
+                    };
+                }
+                else if (config.url) {
+                    newServer = {
+                        name: serverName,
+                        type: 'sse',
+                        url: config.url
+                    };
+                }
+                else {
+                    console.warn(chalk.yellow(`Skipping invalid server config for "${serverName}": missing command or url`));
+                    return;
+                }
+                const existing = configManager.getServer(serverName);
+                if (existing) {
+                    if (options.force) {
+                        configManager.updateServer(serverName, newServer);
+                        console.log(chalk.gray(`Updated existing server: ${serverName}`));
+                        importedCount++;
+                    }
+                    else {
+                        console.log(chalk.yellow(`Skipping existing server: ${serverName} (use --force to overwrite)`));
+                        skippedCount++;
+                    }
+                }
+                else {
+                    configManager.addServer(newServer);
+                    console.log(chalk.green(`Imported server: ${serverName}`));
+                    importedCount++;
+                }
+            });
+            console.log(chalk.bold(`\nImport complete. Imported: ${importedCount}, Skipped: ${skippedCount}`));
+        }
+        catch (error) {
+            console.error(chalk.red(`Import failed: ${error.message}`));
+        }
+    });
+};

package/dist/commands/daemon.js

@@ -0,0 +1,141 @@
+import http from 'http';
+import chalk from 'chalk';
+import { connectionPool } from '../core/pool.js';
+const PORT = 4100;
+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))
+        .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' });
+            console.log(chalk.green('Daemon stopped successfully.'));
+        }
+        catch (e) {
+            console.error(chalk.red('Failed to stop daemon. Is it 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`, {
+                method: 'POST',
+                body: JSON.stringify({ server: serverName })
+            });
+            const data = await res.json();
+            console.log(chalk.green(data.message));
+        }
+        catch (e) {
+            console.error(chalk.red('Failed to restart. Is the daemon running?'));
+        }
+    });
+};
+const startDaemon = (port) => {
+    const server = http.createServer(async (req, res) => {
+        // ... (middleware) ...
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'POST, GET, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+        if (req.method === 'OPTIONS') {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        if (req.method === 'GET' && req.url === '/status') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ status: 'running', version: '1.0.0' }));
+            return;
+        }
+        // ... (restart/stop/call handlers) ...
+        if (req.method === 'POST' && req.url === '/restart') {
+            let body = '';
+            req.on('data', chunk => { body += chunk.toString(); });
+            req.on('end', async () => {
+                try {
+                    const { server: serverName } = JSON.parse(body || '{}');
+                    if (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 }));
+                    }
+                    else {
+                        await connectionPool.closeAll();
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ message: 'All connections closed.' }));
+                    }
+                }
+                catch (error) {
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: error.message }));
+                }
+            });
+            return;
+        }
+        if (req.method === 'POST' && req.url === '/stop') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ message: 'Daemon shutting down...' }));
+            setTimeout(() => {
+                server.close();
+                connectionPool.closeAll();
+                process.exit(0);
+            }, 100);
+            return;
+        }
+        if (req.method === 'POST' && req.url === '/call') {
+            let body = '';
+            req.on('data', chunk => { body += chunk.toString(); });
+            req.on('end', async () => {
+                try {
+                    const { server: serverName, tool, args } = JSON.parse(body);
+                    if (!serverName || !tool) {
+                        res.writeHead(400, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ error: 'Missing server or tool' }));
+                        return;
+                    }
+                    const client = await connectionPool.getClient(serverName);
+                    const result = await client.callTool(tool, args || {});
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ result }));
+                }
+                catch (error) {
+                    console.error(`[Daemon] Error executing tool:`, error);
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: error.message }));
+                }
+            });
+            return;
+        }
+        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
+        `));
+    });
+    const shutdown = async () => {
+        console.log('\n[Daemon] Shutting down...');
+        server.close();
+        await connectionPool.closeAll();
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+};

package/dist/commands/server.js

@@ -0,0 +1,108 @@
+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 servers = configManager.listServers();
+        if (servers.length === 0) {
+            console.log(chalk.yellow('No servers configured.'));
+            return;
+        }
+        console.log(chalk.bold('\nConfigured Servers:'));
+        servers.forEach(s => {
+            console.log(`- ${chalk.cyan(s.name)} [${chalk.magenta(s.type)}]`);
+            if (s.type === 'stdio') {
+                console.log(`  Command: ${s.command} ${s.args.join(' ')}`);
+                if (s.env)
+                    console.log(`  Env: ${Object.keys(s.env).join(', ')}`);
+            }
+            else {
+                console.log(`  URL: ${s.url}`);
+            }
+            console.log('');
+        });
+    });
+    serverCmd.command('add <name>')
+        .description('Add a new MCP server')
+        .option('--type <type>', 'Server type (stdio, sse, or http)', 'stdio')
+        .option('--command <command>', 'Command to execute (for stdio)')
+        .option('--args [args...]', 'Arguments for the command', [])
+        .option('--url <url>', 'URL for SSE/HTTP connection')
+        .option('--env <env...>', 'Environment variables (KEY=VALUE)', [])
+        .action((name, options) => {
+        try {
+            if (options.type === 'sse' || options.type === 'http') {
+                if (!options.url)
+                    throw new Error(`URL is required for ${options.type} servers`);
+                configManager.addServer({
+                    name,
+                    type: options.type,
+                    url: options.url,
+                });
+            }
+            else {
+                if (!options.command)
+                    throw new Error('Command is required for Stdio servers');
+                const env = {};
+                if (options.env) {
+                    options.env.forEach((e) => {
+                        const parts = e.split('=');
+                        const k = parts[0];
+                        const v = parts.slice(1).join('=');
+                        if (k && v)
+                            env[k] = v;
+                    });
+                }
+                configManager.addServer({
+                    name,
+                    type: 'stdio',
+                    command: options.command,
+                    args: options.args || [],
+                    env: Object.keys(env).length > 0 ? env : undefined,
+                });
+            }
+            console.log(chalk.green(`Server "${name}" added successfully.`));
+        }
+        catch (error) {
+            console.error(chalk.red(`Error adding server: ${error.message}`));
+        }
+    });
+    serverCmd.command('remove <name>')
+        .alias('rm')
+        .description('Remove a server')
+        .action((name) => {
+        try {
+            configManager.removeServer(name);
+            console.log(chalk.green(`Server "${name}" removed.`));
+        }
+        catch (error) {
+            console.error(chalk.red(error.message));
+        }
+    });
+    serverCmd.command('update <name>')
+        .description('Update a server')
+        .option('--command <command>', 'New command')
+        .option('--url <url>', 'New URL')
+        .action((name, options) => {
+        try {
+            const updates = {};
+            if (options.command)
+                updates.command = options.command;
+            if (options.url)
+                updates.url = options.url;
+            if (Object.keys(updates).length === 0) {
+                console.log(chalk.yellow('No updates provided.'));
+                return;
+            }
+            configManager.updateServer(name, updates);
+            console.log(chalk.green(`Server "${name}" updated.`));
+        }
+        catch (error) {
+            console.error(chalk.red(`Error updating server: ${error.message}`));
+        }
+    });
+};

package/dist/commands/tools.js

@@ -0,0 +1,49 @@
+import chalk from 'chalk';
+import { configManager } from '../core/config.js';
+import { McpClientService } from '../core/client.js';
+export const registerToolsCommand = (program) => {
+    program.command('tools <server>')
+        .description('List available tools on a server')
+        .action(async (serverName) => {
+        const serverConfig = configManager.getServer(serverName);
+        if (!serverConfig) {
+            console.error(chalk.red(`Server "${serverName}" not found.`));
+            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');
+                    }
+                });
+            }
+        }
+        catch (error) {
+            console.error(chalk.red(`Failed to list tools: ${error.message}`));
+        }
+        finally {
+            await client.close();
+        }
+    });
+};

package/dist/core/client.js

@@ -0,0 +1,66 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { EventSource } from 'eventsource';
+// Required for SSEClientTransport in Node.js environment
+// @ts-ignore
+global.EventSource = EventSource;
+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 env = {};
+                for (const key in rawEnv) {
+                    const val = rawEnv[key];
+                    if (typeof val === 'string') {
+                        env[key] = val;
+                    }
+                }
+                this.transport = new StdioClientTransport({
+                    command: config.command,
+                    args: config.args,
+                    env: env,
+                });
+            }
+            else if (config.type === 'http') {
+                this.transport = new StreamableHTTPClientTransport(new URL(config.url));
+            }
+            else {
+                this.transport = new SSEClientTransport(new URL(config.url));
+            }
+            this.client = new Client({
+                name: 'mcp-cli',
+                version: '1.0.0',
+            }, {
+                capabilities: {},
+            });
+            await this.client.connect(this.transport);
+        }
+        catch (error) {
+            console.error(`Failed to connect to server ${config.name}:`, error);
+            throw error;
+        }
+    }
+    async listTools() {
+        if (!this.client)
+            throw new Error('Client not connected');
+        return this.client.listTools();
+    }
+    async callTool(toolName, args) {
+        if (!this.client)
+            throw new Error('Client not connected');
+        return this.client.callTool({
+            name: toolName,
+            arguments: args,
+        });
+    }
+    async close() {
+        if (this.transport) {
+            await this.transport.close();
+        }
+    }
+}

package/dist/core/config.js

@@ -0,0 +1,89 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { ServerConfigSchema } from '../types/config.js';
+const CONFIG_DIR = process.env.MCP_CONFIG_DIR || path.join(os.homedir(), '.mcps');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'mcp.json');
+export class ConfigManager {
+    ensureConfigDir() {
+        if (!fs.existsSync(CONFIG_DIR)) {
+            fs.mkdirSync(CONFIG_DIR, { recursive: true });
+        }
+    }
+    loadConfig() {
+        this.ensureConfigDir();
+        if (!fs.existsSync(CONFIG_FILE)) {
+            return { servers: [] };
+        }
+        try {
+            const content = fs.readFileSync(CONFIG_FILE, 'utf-8');
+            const json = JSON.parse(content);
+            if (!json || typeof json !== 'object' || !Array.isArray(json.servers)) {
+                // If the root structure is invalid, we can't do much.
+                console.warn('Invalid config file structure. Expected { servers: [] }.');
+                return { servers: [] };
+            }
+            const validServers = [];
+            const servers = json.servers;
+            for (const server of servers) {
+                const result = ServerConfigSchema.safeParse(server);
+                if (result.success) {
+                    validServers.push(result.data);
+                }
+                else {
+                    console.warn(`Skipping invalid server config "${server?.name || 'unknown'}":`, result.error.errors[0]?.message);
+                }
+            }
+            return { servers: validServers };
+        }
+        catch (error) {
+            console.error('Failed to parse config file:', error);
+            return { servers: [] };
+        }
+    }
+    saveConfig(config) {
+        this.ensureConfigDir();
+        fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
+    }
+    listServers() {
+        return this.loadConfig().servers;
+    }
+    getServer(name) {
+        const config = this.loadConfig();
+        return config.servers.find(s => s.name === name);
+    }
+    addServer(server) {
+        const config = this.loadConfig();
+        if (config.servers.find(s => s.name === server.name)) {
+            throw new Error(`Server with name "${server.name}" already exists.`);
+        }
+        config.servers.push(server);
+        this.saveConfig(config);
+    }
+    removeServer(name) {
+        const config = this.loadConfig();
+        const initialLength = config.servers.length;
+        config.servers = config.servers.filter(s => s.name !== name);
+        if (config.servers.length === initialLength) {
+            throw new Error(`Server with name "${name}" not found.`);
+        }
+        this.saveConfig(config);
+    }
+    updateServer(name, updates) {
+        const config = this.loadConfig();
+        const index = config.servers.findIndex(s => s.name === name);
+        if (index === -1) {
+            throw new Error(`Server with name "${name}" not found.`);
+        }
+        const current = config.servers[index];
+        const updated = { ...current, ...updates };
+        // Validate the updated object matches the schema (especially type consistency)
+        const result = ServerConfigSchema.safeParse(updated);
+        if (!result.success) {
+            throw new Error(`Invalid update: ${result.error.message}`);
+        }
+        config.servers[index] = result.data;
+        this.saveConfig(config);
+    }
+}
+export const configManager = new ConfigManager();

package/dist/core/pool.js

@@ -0,0 +1,46 @@
+import { McpClientService } from './client.js';
+import { configManager } from './config.js';
+export class ConnectionPool {
+    clients = new Map();
+    async getClient(serverName) {
+        if (this.clients.has(serverName)) {
+            return this.clients.get(serverName);
+        }
+        const serverConfig = configManager.getServer(serverName);
+        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);
+        this.clients.set(serverName, client);
+        return client;
+    }
+    async closeClient(serverName) {
+        if (this.clients.has(serverName)) {
+            console.log(`[Daemon] Closing connection to ${serverName}...`);
+            try {
+                await this.clients.get(serverName).close();
+            }
+            catch (e) {
+                console.error(`[Daemon] Error closing ${serverName}:`, e);
+            }
+            this.clients.delete(serverName);
+            return true;
+        }
+        return false;
+    }
+    async closeAll() {
+        for (const [name, client] of this.clients) {
+            console.log(`[Daemon] Closing connection to ${name}...`);
+            try {
+                await client.close();
+            }
+            catch (e) {
+                console.error(`[Daemon] Error closing ${name}:`, e);
+            }
+        }
+        this.clients.clear();
+    }
+}
+export const connectionPool = new ConnectionPool();

package/dist/index.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { registerServerCommands } from './commands/server.js';
+import { registerToolsCommand } from './commands/tools.js';
+import { registerCallCommand } from './commands/call.js';
+import { registerDaemonCommand } from './commands/daemon.js';
+const program = new Command();
+program
+    .name('mcps')
+    .description('A CLI to manage and use MCP servers')
+    .version('1.0.0');
+registerServerCommands(program);
+registerToolsCommand(program);
+registerCallCommand(program);
+registerDaemonCommand(program);
+program.parse(process.argv);

package/dist/types/config.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+export const ServerConfigSchema = z.union([
+    z.object({
+        name: z.string(),
+        type: z.literal('stdio'),
+        command: z.string(),
+        args: z.array(z.string()).default([]),
+        env: z.record(z.string()).optional(),
+    }),
+    z.object({
+        name: z.string(),
+        type: z.literal('sse'),
+        url: z.string().url(),
+    }),
+    z.object({
+        name: z.string(),
+        type: z.literal('http'),
+        url: z.string().url(),
+    }),
+]);
+export const ConfigSchema = z.object({
+    servers: z.array(ServerConfigSchema).default([]),
+});

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@maplezzk/mcps",
+  "version": "1.0.1",
+  "description": "A CLI to manage and use MCP servers",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "dist/index.js",
+  "keywords": [
+    "mcp",
+    "cli",
+    "ai",
+    "tool"
+  ],
+  "author": "",
+  "license": "ISC",
+  "type": "module",
+  "bin": {
+    "mcps": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.25.3",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.2",
+    "conf": "^15.0.2",
+    "eventsource": "^4.1.0",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@types/eventsource": "^1.1.15",
+    "@types/node": "^22.10.7",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.7.3"
+  }
+}