@agiflowai/one-mcp 0.2.0

package/dist/cli.mjs

@@ -0,0 +1,498 @@
+#!/usr/bin/env node
+import { a as McpClientManagerService, i as createServer, n as SseTransportHandler, o as ConfigFetcherService, r as StdioTransportHandler, t as HttpTransportHandler } from "./http-B1EDyxR_.mjs";
+import { writeFile } from "node:fs/promises";
+import { Command } from "commander";
+import { resolve } from "node:path";
+import { log } from "@agiflowai/aicode-utils";
+
+//#region src/types/index.ts
+/**
+* Transport mode types
+*/
+let TransportMode = /* @__PURE__ */ function(TransportMode$1) {
+	TransportMode$1["STDIO"] = "stdio";
+	TransportMode$1["HTTP"] = "http";
+	TransportMode$1["SSE"] = "sse";
+	return TransportMode$1;
+}({});
+
+//#endregion
+//#region src/commands/mcp-serve.ts
+/**
+* MCP Serve Command
+*
+* DESIGN PATTERNS:
+* - Command pattern with Commander for CLI argument parsing
+* - Transport abstraction pattern for flexible deployment (stdio, HTTP, SSE)
+* - Factory pattern for creating transport handlers
+* - Graceful shutdown pattern with signal handling
+*
+* CODING STANDARDS:
+* - Use async/await for asynchronous operations
+* - Implement proper error handling with try-catch blocks
+* - Handle process signals for graceful shutdown
+* - Provide clear CLI options and help messages
+*
+* AVOID:
+* - Hardcoded configuration values (use CLI options or environment variables)
+* - Missing error handling for transport startup
+* - Not cleaning up resources on shutdown
+*/
+/**
+* Start MCP server with given transport handler
+*/
+async function startServer(handler) {
+	await handler.start();
+	const shutdown = async (signal) => {
+		console.error(`\nReceived ${signal}, shutting down gracefully...`);
+		try {
+			await handler.stop();
+			process.exit(0);
+		} catch (error) {
+			console.error("Error during shutdown:", error);
+			process.exit(1);
+		}
+	};
+	process.on("SIGINT", () => shutdown("SIGINT"));
+	process.on("SIGTERM", () => shutdown("SIGTERM"));
+}
+/**
+* MCP Serve command
+*/
+const mcpServeCommand = new Command("mcp-serve").description("Start MCP server with specified transport").option("-t, --type <type>", "Transport type: stdio, http, or sse", "stdio").option("-p, --port <port>", "Port to listen on (http/sse only)", (val) => parseInt(val, 10), 3e3).option("--host <host>", "Host to bind to (http/sse only)", "localhost").option("-c, --config <path>", "Path to MCP server configuration file").option("--no-cache", "Force reload configuration from source, bypassing cache").action(async (options) => {
+	try {
+		const transportType = options.type.toLowerCase();
+		const serverOptions = {
+			configFilePath: options.config,
+			noCache: options.cache === false
+		};
+		if (transportType === "stdio") await startServer(new StdioTransportHandler(await createServer(serverOptions)));
+		else if (transportType === "http") await startServer(new HttpTransportHandler(await createServer(serverOptions), {
+			mode: TransportMode.HTTP,
+			port: options.port || Number(process.env.MCP_PORT) || 3e3,
+			host: options.host || process.env.MCP_HOST || "localhost"
+		}));
+		else if (transportType === "sse") await startServer(new SseTransportHandler(await createServer(serverOptions), {
+			mode: TransportMode.SSE,
+			port: options.port || Number(process.env.MCP_PORT) || 3e3,
+			host: options.host || process.env.MCP_HOST || "localhost"
+		}));
+		else {
+			console.error(`Unknown transport type: ${transportType}. Use: stdio, http, or sse`);
+			process.exit(1);
+		}
+	} catch (error) {
+		console.error("Failed to start MCP server:", error);
+		process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/commands/list-tools.ts
+/**
+* List Tools Command
+*
+* DESIGN PATTERNS:
+* - Command pattern with Commander for CLI argument parsing
+* - Async/await pattern for asynchronous operations
+* - Error handling pattern with try-catch and proper exit codes
+*
+* CODING STANDARDS:
+* - Use async action handlers for asynchronous operations
+* - Provide clear option descriptions and default values
+* - Handle errors gracefully with process.exit()
+* - Log progress and errors to console
+* - Use Commander's .option() and .argument() for inputs
+*
+* AVOID:
+* - Synchronous blocking operations in action handlers
+* - Missing error handling (always use try-catch)
+* - Hardcoded values (use options or environment variables)
+* - Not exiting with appropriate exit codes on errors
+*/
+/**
+* List all available tools from connected MCP servers
+*/
+const listToolsCommand = new Command("list-tools").description("List all available tools from connected MCP servers").option("-c, --config <path>", "Path to MCP server configuration file").option("-s, --server <name>", "Filter by server name").option("-j, --json", "Output as JSON", false).action(async (options) => {
+	try {
+		if (!options.config) {
+			console.error("Error: --config is required");
+			process.exit(1);
+		}
+		const config = await new ConfigFetcherService({ configFilePath: options.config }).fetchConfiguration();
+		const clientManager = new McpClientManagerService();
+		const connectionPromises = Object.entries(config.mcpServers).map(async ([serverName, serverConfig]) => {
+			try {
+				await clientManager.connectToServer(serverName, serverConfig);
+				if (!options.json) console.error(`✓ Connected to ${serverName}`);
+			} catch (error) {
+				if (!options.json) console.error(`✗ Failed to connect to ${serverName}:`, error);
+			}
+		});
+		await Promise.all(connectionPromises);
+		const clients = options.server ? [clientManager.getClient(options.server)].filter((c) => c !== void 0) : clientManager.getAllClients();
+		if (clients.length === 0) {
+			console.error("No MCP servers connected");
+			process.exit(1);
+		}
+		const toolsByServer = {};
+		for (const client of clients) try {
+			const tools = await client.listTools();
+			const blacklist = new Set(client.toolBlacklist || []);
+			const filteredTools = tools.filter((t) => !blacklist.has(t.name));
+			toolsByServer[client.serverName] = filteredTools;
+		} catch (error) {
+			if (!options.json) console.error(`Failed to list tools from ${client.serverName}:`, error);
+			toolsByServer[client.serverName] = [];
+		}
+		if (options.json) console.log(JSON.stringify(toolsByServer, null, 2));
+		else for (const [serverName, tools] of Object.entries(toolsByServer)) {
+			const omitDescription = clients.find((c) => c.serverName === serverName)?.omitToolDescription || false;
+			console.log(`\n${serverName}:`);
+			if (tools.length === 0) console.log("  No tools available");
+			else if (omitDescription) {
+				const toolNames = tools.map((t) => t.name).join(", ");
+				console.log(`  ${toolNames}`);
+			} else for (const tool of tools) console.log(`  - ${tool.name}: ${tool.description || "No description"}`);
+		}
+		await clientManager.disconnectAll();
+	} catch (error) {
+		console.error("Error executing list-tools:", error);
+		process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/commands/describe-tools.ts
+/**
+* Describe Tools Command
+*
+* DESIGN PATTERNS:
+* - Command pattern with Commander for CLI argument parsing
+* - Async/await pattern for asynchronous operations
+* - Error handling pattern with try-catch and proper exit codes
+*
+* CODING STANDARDS:
+* - Use async action handlers for asynchronous operations
+* - Provide clear option descriptions and default values
+* - Handle errors gracefully with process.exit()
+* - Log progress and errors to console
+* - Use Commander's .option() and .argument() for inputs
+*
+* AVOID:
+* - Synchronous blocking operations in action handlers
+* - Missing error handling (always use try-catch)
+* - Hardcoded values (use options or environment variables)
+* - Not exiting with appropriate exit codes on errors
+*/
+/**
+* Describe specific MCP tools
+*/
+const describeToolsCommand = new Command("describe-tools").description("Describe specific MCP tools").argument("<toolNames...>", "Tool names to describe").option("-c, --config <path>", "Path to MCP server configuration file").option("-s, --server <name>", "Filter by server name").option("-j, --json", "Output as JSON", false).action(async (toolNames, options) => {
+	try {
+		if (!options.config) {
+			console.error("Error: --config is required");
+			process.exit(1);
+		}
+		const config = await new ConfigFetcherService({ configFilePath: options.config }).fetchConfiguration();
+		const clientManager = new McpClientManagerService();
+		const connectionPromises = Object.entries(config.mcpServers).map(async ([serverName, serverConfig]) => {
+			try {
+				await clientManager.connectToServer(serverName, serverConfig);
+				if (!options.json) console.error(`✓ Connected to ${serverName}`);
+			} catch (error) {
+				if (!options.json) console.error(`✗ Failed to connect to ${serverName}:`, error);
+			}
+		});
+		await Promise.all(connectionPromises);
+		const clients = clientManager.getAllClients();
+		if (clients.length === 0) {
+			console.error("No MCP servers connected");
+			process.exit(1);
+		}
+		const foundTools = [];
+		const notFoundTools = [...toolNames];
+		for (const client of clients) {
+			if (options.server && client.serverName !== options.server) continue;
+			try {
+				const tools = await client.listTools();
+				for (const toolName of toolNames) {
+					const tool = tools.find((t) => t.name === toolName);
+					if (tool) {
+						foundTools.push({
+							server: client.serverName,
+							name: tool.name,
+							description: tool.description,
+							inputSchema: tool.inputSchema
+						});
+						const idx = notFoundTools.indexOf(toolName);
+						if (idx > -1) notFoundTools.splice(idx, 1);
+					}
+				}
+			} catch (error) {
+				if (!options.json) console.error(`Failed to list tools from ${client.serverName}:`, error);
+			}
+		}
+		if (options.json) {
+			const result = { tools: foundTools };
+			if (notFoundTools.length > 0) result.notFound = notFoundTools;
+			console.log(JSON.stringify(result, null, 2));
+		} else {
+			if (foundTools.length > 0) {
+				console.log("\nFound tools:\n");
+				for (const tool of foundTools) {
+					console.log(`Server: ${tool.server}`);
+					console.log(`Tool: ${tool.name}`);
+					console.log(`Description: ${tool.description || "No description"}`);
+					console.log(`Input Schema:`);
+					console.log(JSON.stringify(tool.inputSchema, null, 2));
+					console.log("");
+				}
+			}
+			if (notFoundTools.length > 0) console.error(`\nTools not found: ${notFoundTools.join(", ")}`);
+			if (foundTools.length === 0) {
+				console.error("No tools found");
+				process.exit(1);
+			}
+		}
+		await clientManager.disconnectAll();
+	} catch (error) {
+		console.error("Error executing describe-tools:", error);
+		process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/commands/use-tool.ts
+/**
+* Use Tool Command
+*
+* DESIGN PATTERNS:
+* - Command pattern with Commander for CLI argument parsing
+* - Async/await pattern for asynchronous operations
+* - Error handling pattern with try-catch and proper exit codes
+*
+* CODING STANDARDS:
+* - Use async action handlers for asynchronous operations
+* - Provide clear option descriptions and default values
+* - Handle errors gracefully with process.exit()
+* - Log progress and errors to console
+* - Use Commander's .option() and .argument() for inputs
+*
+* AVOID:
+* - Synchronous blocking operations in action handlers
+* - Missing error handling (always use try-catch)
+* - Hardcoded values (use options or environment variables)
+* - Not exiting with appropriate exit codes on errors
+*/
+/**
+* Execute an MCP tool with arguments
+*/
+const useToolCommand = new Command("use-tool").description("Execute an MCP tool with arguments").argument("<toolName>", "Tool name to execute").option("-c, --config <path>", "Path to MCP server configuration file").option("-s, --server <name>", "Server name (required if tool exists on multiple servers)").option("-a, --args <json>", "Tool arguments as JSON string", "{}").option("-j, --json", "Output as JSON", false).action(async (toolName, options) => {
+	try {
+		if (!options.config) {
+			console.error("Error: --config is required");
+			process.exit(1);
+		}
+		let toolArgs = {};
+		try {
+			toolArgs = JSON.parse(options.args);
+		} catch (error) {
+			console.error("Error: Invalid JSON in --args");
+			process.exit(1);
+		}
+		const config = await new ConfigFetcherService({ configFilePath: options.config }).fetchConfiguration();
+		const clientManager = new McpClientManagerService();
+		const connectionPromises = Object.entries(config.mcpServers).map(async ([serverName, serverConfig]) => {
+			try {
+				await clientManager.connectToServer(serverName, serverConfig);
+				if (!options.json) console.error(`✓ Connected to ${serverName}`);
+			} catch (error) {
+				if (!options.json) console.error(`✗ Failed to connect to ${serverName}:`, error);
+			}
+		});
+		await Promise.all(connectionPromises);
+		const clients = clientManager.getAllClients();
+		if (clients.length === 0) {
+			console.error("No MCP servers connected");
+			process.exit(1);
+		}
+		if (options.server) {
+			const client$1 = clientManager.getClient(options.server);
+			if (!client$1) {
+				console.error(`Server "${options.server}" not found`);
+				process.exit(1);
+			}
+			try {
+				if (!options.json) console.error(`Executing ${toolName} on ${options.server}...`);
+				const result = await client$1.callTool(toolName, toolArgs);
+				if (options.json) console.log(JSON.stringify(result, null, 2));
+				else {
+					console.log("\nResult:");
+					if (result.content) for (const content of result.content) if (content.type === "text") console.log(content.text);
+					else console.log(JSON.stringify(content, null, 2));
+					if (result.isError) {
+						console.error("\n⚠️  Tool execution returned an error");
+						process.exit(1);
+					}
+				}
+				await clientManager.disconnectAll();
+				return;
+			} catch (error) {
+				console.error(`Failed to execute tool "${toolName}":`, error);
+				await clientManager.disconnectAll();
+				process.exit(1);
+			}
+		}
+		const matchingServers = [];
+		for (const client$1 of clients) try {
+			if ((await client$1.listTools()).some((t) => t.name === toolName)) matchingServers.push(client$1.serverName);
+		} catch (error) {
+			if (!options.json) console.error(`Failed to list tools from ${client$1.serverName}:`, error);
+		}
+		if (matchingServers.length === 0) {
+			console.error(`Tool "${toolName}" not found on any connected server`);
+			await clientManager.disconnectAll();
+			process.exit(1);
+		}
+		if (matchingServers.length > 1) {
+			console.error(`Tool "${toolName}" found on multiple servers: ${matchingServers.join(", ")}`);
+			console.error("Please specify --server to disambiguate");
+			await clientManager.disconnectAll();
+			process.exit(1);
+		}
+		const targetServer = matchingServers[0];
+		const client = clientManager.getClient(targetServer);
+		if (!client) {
+			console.error(`Internal error: Server "${targetServer}" not connected`);
+			await clientManager.disconnectAll();
+			process.exit(1);
+		}
+		try {
+			if (!options.json) console.error(`Executing ${toolName} on ${targetServer}...`);
+			const result = await client.callTool(toolName, toolArgs);
+			if (options.json) console.log(JSON.stringify(result, null, 2));
+			else {
+				console.log("\nResult:");
+				if (result.content) for (const content of result.content) if (content.type === "text") console.log(content.text);
+				else console.log(JSON.stringify(content, null, 2));
+				if (result.isError) {
+					console.error("\n⚠️  Tool execution returned an error");
+					await clientManager.disconnectAll();
+					process.exit(1);
+				}
+			}
+			await clientManager.disconnectAll();
+		} catch (error) {
+			console.error(`Failed to execute tool "${toolName}":`, error);
+			await clientManager.disconnectAll();
+			process.exit(1);
+		}
+	} catch (error) {
+		console.error("Error executing use-tool:", error);
+		process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/templates/mcp-config.yaml?raw
+var mcp_config_default = "# MCP Server Configuration\n# This file configures the MCP servers that one-mcp will connect to\n#\n# Environment Variable Interpolation:\n# Use ${VAR_NAME} syntax to reference environment variables\n# Example: ${HOME}, ${API_KEY}, ${DATABASE_URL}\n#\n# Instructions:\n# - config.instruction: Server's default instruction (from server documentation)\n# - instruction: User override (optional, takes precedence over config.instruction)\n# - config.toolBlacklist: Array of tool names to hide/block from this server\n# - config.omitToolDescription: Boolean to show only tool names without descriptions (saves tokens)\n\nmcpServers:\n  # Example MCP server using stdio transport\n  example-server:\n    command: node\n    args:\n      - /path/to/mcp-server/build/index.js\n    env:\n      # Environment variables for the MCP server\n      LOG_LEVEL: info\n      # You can use environment variable interpolation:\n      # DATABASE_URL: ${DATABASE_URL}\n      # API_KEY: ${MY_API_KEY}\n    config:\n      # Server's default instruction (from server documentation)\n      instruction: Use this server for...\n      # Optional: Block specific tools from being listed or executed\n      # toolBlacklist:\n      #   - dangerous_tool_name\n      #   - another_blocked_tool\n      # Optional: Omit tool descriptions to save tokens (default: false)\n      # omitToolDescription: true\n    # instruction: Optional user override - takes precedence over config.instruction\n\n  # Example MCP server using SSE transport with environment variables\n  # remote-server:\n  #   url: https://example.com/mcp\n  #   type: sse\n  #   headers:\n  #     # Use ${VAR_NAME} to interpolate environment variables\n  #     Authorization: Bearer ${API_KEY}\n  #   config:\n  #     instruction: This server provides tools for...\n  #     # Optional: Block specific tools from being listed or executed\n  #     # toolBlacklist:\n  #     #   - tool_to_block\n  #     # Optional: Omit tool descriptions to save tokens (default: false)\n  #     # omitToolDescription: true\n  #   # instruction: Optional user override\n";
+
+//#endregion
+//#region src/templates/mcp-config.json?raw
+var mcp_config_default$1 = "{\n  \"_comment\": \"MCP Server Configuration - Use ${VAR_NAME} syntax for environment variable interpolation\",\n  \"_instructions\": \"config.instruction: Server's default instruction | instruction: User override (takes precedence)\",\n  \"mcpServers\": {\n    \"example-server\": {\n      \"command\": \"node\",\n      \"args\": [\n        \"/path/to/mcp-server/build/index.js\"\n      ],\n      \"env\": {\n        \"LOG_LEVEL\": \"info\",\n        \"_comment\": \"You can use environment variable interpolation:\",\n        \"_example_DATABASE_URL\": \"${DATABASE_URL}\",\n        \"_example_API_KEY\": \"${MY_API_KEY}\"\n      },\n      \"config\": {\n        \"instruction\": \"Use this server for...\"\n      },\n      \"_instruction_override\": \"Optional user override - takes precedence over config.instruction\"\n    }\n  }\n}\n";
+
+//#endregion
+//#region src/commands/init.ts
+/**
+* Init Command
+*
+* DESIGN PATTERNS:
+* - Command pattern with Commander for CLI argument parsing
+* - Async/await pattern for asynchronous operations
+* - Error handling pattern with try-catch and proper exit codes
+*
+* CODING STANDARDS:
+* - Use async action handlers for asynchronous operations
+* - Provide clear option descriptions and default values
+* - Handle errors gracefully with process.exit()
+* - Log progress and errors to console
+* - Use Commander's .option() and .argument() for inputs
+*
+* AVOID:
+* - Synchronous blocking operations in action handlers
+* - Missing error handling (always use try-catch)
+* - Hardcoded values (use options or environment variables)
+* - Not exiting with appropriate exit codes on errors
+*/
+/**
+* Initialize MCP configuration file
+*/
+const initCommand = new Command("init").description("Initialize MCP configuration file").option("-o, --output <path>", "Output file path", "mcp-config.yaml").option("--json", "Generate JSON config instead of YAML", false).option("-f, --force", "Overwrite existing config file", false).action(async (options) => {
+	try {
+		const outputPath = resolve(options.output);
+		const template = !options.json && (outputPath.endsWith(".yaml") || outputPath.endsWith(".yml")) ? mcp_config_default : mcp_config_default$1;
+		try {
+			await writeFile(outputPath, template, {
+				encoding: "utf-8",
+				flag: options.force ? "w" : "wx"
+			});
+		} catch (error) {
+			if (error && typeof error === "object" && "code" in error && error.code === "EEXIST") {
+				log.error(`Config file already exists: ${outputPath}`);
+				log.info("Use --force to overwrite");
+				process.exit(1);
+			}
+			throw error;
+		}
+		log.info(`MCP configuration file created: ${outputPath}`);
+		log.info("Next steps:");
+		log.info("1. Edit the configuration file to add your MCP servers");
+		log.info(`2. Run: one-mcp mcp-serve --config ${outputPath}`);
+	} catch (error) {
+		log.error("Error executing init:", error instanceof Error ? error.message : String(error));
+		process.exit(1);
+	}
+});
+
+//#endregion
+//#region package.json
+var version = "0.1.0";
+
+//#endregion
+//#region src/cli.ts
+/**
+* MCP Server Entry Point
+*
+* DESIGN PATTERNS:
+* - CLI pattern with Commander for argument parsing
+* - Command pattern for organizing CLI commands
+* - Transport abstraction for multiple communication methods
+*
+* CODING STANDARDS:
+* - Use async/await for asynchronous operations
+* - Handle errors gracefully with try-catch
+* - Log important events for debugging
+* - Register all commands in main entry point
+*
+* AVOID:
+* - Hardcoding command logic in index.ts (use separate command files)
+* - Missing error handling for command execution
+*/
+/**
+* Main entry point
+*/
+async function main() {
+	const program = new Command();
+	program.name("one-mcp").description("One MCP server package").version(version);
+	program.addCommand(initCommand);
+	program.addCommand(mcpServeCommand);
+	program.addCommand(listToolsCommand);
+	program.addCommand(describeToolsCommand);
+	program.addCommand(useToolCommand);
+	await program.parseAsync(process.argv);
+}
+main();
+
+//#endregion
+export {  };