@agiflowai/one-mcp 0.3.12 → 0.3.14

package/dist/cli.cjs

@@ -1,192 +1,14 @@
 #!/usr/bin/env node
-const require_http = require('./http-B4_JfY6t.cjs');
+const require_src = require('./src-iTE9Cero.cjs');
 let node_fs_promises = require("node:fs/promises");
+let node_fs = require("node:fs");
+let node_crypto = require("node:crypto");
 let node_path = require("node:path");
 let liquidjs = require("liquidjs");
+let node_child_process = require("node:child_process");
 let commander = require("commander");
 let __agiflowai_aicode_utils = require("@agiflowai/aicode-utils");
-let node_child_process = require("node:child_process");
-
-//#region src/templates/mcp-config.yaml.liquid?raw
-var mcp_config_yaml_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\n# Remote Configuration Sources (OPTIONAL)\n# Fetch and merge configurations from remote URLs\n# Remote configs are merged with local configs based on merge strategy\n#\n# SECURITY: SSRF Protection is ENABLED by default\n# - Only HTTPS URLs are allowed (set security.enforceHttps: false to allow HTTP)\n# - Private IPs and localhost are blocked (set security.allowPrivateIPs: true for internal networks)\n# - Blocked ranges: 127.0.0.0/8, 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16, 169.254.0.0/16\nremoteConfigs:\n  # Example 1: Basic remote config with default security\n  # - url: ${AGIFLOW_URL}/api/v1/mcp-configs\n  #   headers:\n  #     Authorization: Bearer ${AGIFLOW_API_KEY}\n  #   mergeStrategy: local-priority  # Options: local-priority (default), remote-priority, merge-deep\n  #\n  # Example 2: Remote config with custom security settings (for internal networks)\n  # - url: ${INTERNAL_URL}/mcp-configs\n  #   headers:\n  #     Authorization: Bearer ${INTERNAL_TOKEN}\n  #   security:\n  #     allowPrivateIPs: true   # Allow internal IPs (default: false)\n  #     enforceHttps: false     # Allow HTTP (default: true, HTTPS only)\n  #   mergeStrategy: local-priority\n  #\n  # Example 3: Remote config with additional validation (OPTIONAL)\n  # - url: ${AGIFLOW_URL}/api/v1/mcp-configs\n  #   headers:\n  #     Authorization: Bearer ${AGIFLOW_API_KEY}\n  #     X-API-Key: ${AGIFLOW_API_KEY}\n  #   security:\n  #     enforceHttps: true      # Require HTTPS (default: true)\n  #     allowPrivateIPs: false  # Block private IPs (default: false)\n  #   validation:  # OPTIONAL: Additional regex validation on top of security checks\n  #     url: ^https://.*\\.agiflow\\.io/.*  # OPTIONAL: Regex pattern to validate URL format\n  #     headers:  # OPTIONAL: Regex patterns to validate header values\n  #       Authorization: ^Bearer [A-Za-z0-9_-]+$\n  #       X-API-Key: ^[A-Za-z0-9_-]{32,}$\n  #   mergeStrategy: local-priority\n\nmcpServers:\n{%- if mcpServers %}{% for server in mcpServers %}\n  {{ server.name }}:\n    command: {{ server.command }}\n    args:{% for arg in server.args %}\n      - '{{ arg }}'{% endfor %}\n    # env:\n    #   LOG_LEVEL: info\n    #   # API_KEY: ${MY_API_KEY}\n    # config:\n    #   instruction: Use this server for...\n    #   # toolBlacklist:\n    #   #   - tool_to_block\n    #   # omitToolDescription: true\n{% endfor %}\n  # Example MCP server using SSE transport\n  # remote-server:\n  #   url: https://example.com/mcp\n  #   type: sse\n  #   headers:\n  #     Authorization: Bearer ${API_KEY}\n  #   config:\n  #     instruction: This server provides tools for...\n{% else %}\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{% endif %}\n";
-
-//#endregion
-//#region src/templates/mcp-config.json?raw
-var mcp_config_default = "{\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\": [\"/path/to/mcp-server/build/index.js\"],\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 commander.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).option("--mcp-servers <json>", "JSON string of MCP servers to add to config (optional)").action(async (options) => {
-	try {
-		const outputPath = (0, node_path.resolve)(options.output);
-		const isYaml = !options.json && (outputPath.endsWith(".yaml") || outputPath.endsWith(".yml"));
-		let content;
-		if (isYaml) {
-			const liquid = new liquidjs.Liquid();
-			let mcpServersData = null;
-			if (options.mcpServers) try {
-				const serversObj = JSON.parse(options.mcpServers);
-				mcpServersData = Object.entries(serversObj).map(([name, config]) => ({
-					name,
-					command: config.command,
-					args: config.args
-				}));
-			} catch (parseError) {
-				__agiflowai_aicode_utils.log.error("Failed to parse --mcp-servers JSON:", parseError instanceof Error ? parseError.message : String(parseError));
-				process.exit(1);
-			}
-			content = await liquid.parseAndRender(mcp_config_yaml_default, { mcpServers: mcpServersData });
-		} else content = mcp_config_default;
-		try {
-			await (0, node_fs_promises.writeFile)(outputPath, content, {
-				encoding: "utf-8",
-				flag: options.force ? "w" : "wx"
-			});
-		} catch (error) {
-			if (error && typeof error === "object" && "code" in error && error.code === "EEXIST") {
-				__agiflowai_aicode_utils.log.error(`Config file already exists: ${outputPath}`);
-				__agiflowai_aicode_utils.log.info("Use --force to overwrite");
-				process.exit(1);
-			}
-			throw error;
-		}
-		__agiflowai_aicode_utils.log.info(`MCP configuration file created: ${outputPath}`);
-		__agiflowai_aicode_utils.log.info("Next steps:");
-		__agiflowai_aicode_utils.log.info("1. Edit the configuration file to add your MCP servers");
-		__agiflowai_aicode_utils.log.info(`2. Run: one-mcp mcp-serve --config ${outputPath}`);
-	} catch (error) {
-		__agiflowai_aicode_utils.log.error("Error executing init:", error instanceof Error ? error.message : String(error));
-		process.exit(1);
-	}
-});
-
-//#endregion
-//#region src/types/index.ts
-/**
-* Transport mode constants
-*/
-const TRANSPORT_MODE = {
-	STDIO: "stdio",
-	HTTP: "http",
-	SSE: "sse"
-};
-
-//#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
-*/
-/**
-* Type guard to validate transport type
-* @param type - The transport type string to validate
-* @returns True if the type is a valid transport type
-*/
-function isValidTransportType(type) {
-	return type === "stdio" || type === "http" || type === "sse";
-}
-function isValidProxyMode(mode) {
-	return mode === "meta" || mode === "flat" || mode === "search";
-}
-/**
-* Start MCP server with given transport handler
-* @param handler - The transport handler to start
-*/
-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 commander.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", "Disable configuration caching, always reload from config file").option("--definitions-cache <path>", "Path to prefetched tool/prompt/skill definitions cache file").option("--clear-definitions-cache", "Delete definitions cache before startup", false).option("--proxy-mode <mode>", "How one-mcp exposes downstream tools: meta, flat, or search", "meta").option("--id <id>", "Unique server identifier (overrides config file id, auto-generated if not provided)").action(async (options) => {
-	const transportType = options.type.toLowerCase();
-	if (!isValidTransportType(transportType)) {
-		console.error(`Unknown transport type: '${transportType}'. Valid options: stdio, http, sse`);
-		process.exit(1);
-	}
-	if (!isValidProxyMode(options.proxyMode)) {
-		console.error(`Unknown proxy mode: '${options.proxyMode}'. Valid options: meta, flat, search`);
-		process.exit(1);
-	}
-	try {
-		const serverOptions = {
-			configFilePath: options.config || require_http.findConfigFile() || void 0,
-			noCache: options.cache === false,
-			serverId: options.id,
-			definitionsCachePath: options.definitionsCache,
-			clearDefinitionsCache: options.clearDefinitionsCache,
-			proxyMode: options.proxyMode
-		};
-		if (transportType === "stdio") await startServer(new require_http.StdioTransportHandler(await require_http.createServer(serverOptions)));
-		else if (transportType === "http") await startServer(new require_http.HttpTransportHandler(await require_http.createServer(serverOptions), {
-			mode: TRANSPORT_MODE.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 require_http.SseTransportHandler(await require_http.createServer(serverOptions), {
-			mode: TRANSPORT_MODE.SSE,
-			port: options.port || Number(process.env.MCP_PORT) || 3e3,
-			host: options.host || process.env.MCP_HOST || "localhost"
-		}));
-	} catch (error) {
-		console.error(`Failed to start MCP server with transport '${transportType}' on ${options.host}:${options.port}:`, error);
-		process.exit(1);
-	}
-});
 
-//#endregion
 //#region src/services/PrefetchService/constants.ts
 /**
 * PrefetchService Constants
@@ -531,7 +353,7 @@ var PrefetchService = class {
 	* @returns Promise with success status and output
 	*/
 	runCommand(command, args) {
-		return new Promise((resolve$1) => {
+		return new Promise((resolve$2) => {
 			const proc = (0, node_child_process.spawn)(command, args, {
 				stdio: [
 					STDIO_IGNORE,
@@ -549,13 +371,13 @@ var PrefetchService = class {
 				stderr += data.toString();
 			});
 			proc.on("close", (code) => {
-				resolve$1({
+				resolve$2({
 					success: code === EXIT_CODE_SUCCESS,
 					output: stdout || stderr
 				});
 			});
 			proc.on("error", (error) => {
-				resolve$1({
+				resolve$2({
 					success: false,
 					output: error.message
 				});
@@ -564,6 +386,475 @@ var PrefetchService = class {
 	}
 };
 
+//#endregion
+//#region src/templates/mcp-config.yaml.liquid?raw
+var mcp_config_yaml_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\n# Remote Configuration Sources (OPTIONAL)\n# Fetch and merge configurations from remote URLs\n# Remote configs are merged with local configs based on merge strategy\n#\n# SECURITY: SSRF Protection is ENABLED by default\n# - Only HTTPS URLs are allowed (set security.enforceHttps: false to allow HTTP)\n# - Private IPs and localhost are blocked (set security.allowPrivateIPs: true for internal networks)\n# - Blocked ranges: 127.0.0.0/8, 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16, 169.254.0.0/16\nremoteConfigs:\n  # Example 1: Basic remote config with default security\n  # - url: ${AGIFLOW_URL}/api/v1/mcp-configs\n  #   headers:\n  #     Authorization: Bearer ${AGIFLOW_API_KEY}\n  #   mergeStrategy: local-priority  # Options: local-priority (default), remote-priority, merge-deep\n  #\n  # Example 2: Remote config with custom security settings (for internal networks)\n  # - url: ${INTERNAL_URL}/mcp-configs\n  #   headers:\n  #     Authorization: Bearer ${INTERNAL_TOKEN}\n  #   security:\n  #     allowPrivateIPs: true   # Allow internal IPs (default: false)\n  #     enforceHttps: false     # Allow HTTP (default: true, HTTPS only)\n  #   mergeStrategy: local-priority\n  #\n  # Example 3: Remote config with additional validation (OPTIONAL)\n  # - url: ${AGIFLOW_URL}/api/v1/mcp-configs\n  #   headers:\n  #     Authorization: Bearer ${AGIFLOW_API_KEY}\n  #     X-API-Key: ${AGIFLOW_API_KEY}\n  #   security:\n  #     enforceHttps: true      # Require HTTPS (default: true)\n  #     allowPrivateIPs: false  # Block private IPs (default: false)\n  #   validation:  # OPTIONAL: Additional regex validation on top of security checks\n  #     url: ^https://.*\\.agiflow\\.io/.*  # OPTIONAL: Regex pattern to validate URL format\n  #     headers:  # OPTIONAL: Regex patterns to validate header values\n  #       Authorization: ^Bearer [A-Za-z0-9_-]+$\n  #       X-API-Key: ^[A-Za-z0-9_-]{32,}$\n  #   mergeStrategy: local-priority\n\nmcpServers:\n{%- if mcpServers %}{% for server in mcpServers %}\n  {{ server.name }}:\n    command: {{ server.command }}\n    args:{% for arg in server.args %}\n      - '{{ arg }}'{% endfor %}\n    # env:\n    #   LOG_LEVEL: info\n    #   # API_KEY: ${MY_API_KEY}\n    # config:\n    #   instruction: Use this server for...\n    #   # toolBlacklist:\n    #   #   - tool_to_block\n    #   # omitToolDescription: true\n{% endfor %}\n  # Example MCP server using SSE transport\n  # remote-server:\n  #   url: https://example.com/mcp\n  #   type: sse\n  #   headers:\n  #     Authorization: Bearer ${API_KEY}\n  #   config:\n  #     instruction: This server provides tools for...\n{% else %}\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{% endif %}\n";
+
+//#endregion
+//#region src/templates/mcp-config.json?raw
+var mcp_config_default = "{\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\": [\"/path/to/mcp-server/build/index.js\"],\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 commander.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).option("--mcp-servers <json>", "JSON string of MCP servers to add to config (optional)").action(async (options) => {
+	try {
+		const outputPath = (0, node_path.resolve)(options.output);
+		const isYaml = !options.json && (outputPath.endsWith(".yaml") || outputPath.endsWith(".yml"));
+		let content;
+		if (isYaml) {
+			const liquid = new liquidjs.Liquid();
+			let mcpServersData = null;
+			if (options.mcpServers) try {
+				const serversObj = JSON.parse(options.mcpServers);
+				mcpServersData = Object.entries(serversObj).map(([name, config]) => ({
+					name,
+					command: config.command,
+					args: config.args
+				}));
+			} catch (parseError) {
+				__agiflowai_aicode_utils.log.error("Failed to parse --mcp-servers JSON:", parseError instanceof Error ? parseError.message : String(parseError));
+				process.exit(1);
+			}
+			content = await liquid.parseAndRender(mcp_config_yaml_default, { mcpServers: mcpServersData });
+		} else content = mcp_config_default;
+		try {
+			await (0, node_fs_promises.writeFile)(outputPath, content, {
+				encoding: "utf-8",
+				flag: options.force ? "w" : "wx"
+			});
+		} catch (error) {
+			if (error && typeof error === "object" && "code" in error && error.code === "EEXIST") {
+				__agiflowai_aicode_utils.log.error(`Config file already exists: ${outputPath}`);
+				__agiflowai_aicode_utils.log.info("Use --force to overwrite");
+				process.exit(1);
+			}
+			throw error;
+		}
+		__agiflowai_aicode_utils.log.info(`MCP configuration file created: ${outputPath}`);
+		__agiflowai_aicode_utils.log.info("Next steps:");
+		__agiflowai_aicode_utils.log.info("1. Edit the configuration file to add your MCP servers");
+		__agiflowai_aicode_utils.log.info(`2. Run: one-mcp mcp-serve --config ${outputPath}`);
+	} catch (error) {
+		__agiflowai_aicode_utils.log.error("Error executing init:", error instanceof Error ? error.message : String(error));
+		process.exit(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
+*/
+const CONFIG_FILE_NAMES = [
+	"mcp-config.yaml",
+	"mcp-config.yml",
+	"mcp-config.json"
+];
+const MCP_ENDPOINT_PATH = "/mcp";
+const DEFAULT_PORT = 3e3;
+const DEFAULT_HOST = "localhost";
+const TRANSPORT_TYPE_STDIO = "stdio";
+const TRANSPORT_TYPE_HTTP = "http";
+const TRANSPORT_TYPE_SSE = "sse";
+const TRANSPORT_TYPE_STDIO_HTTP = "stdio-http";
+const RUNTIME_TRANSPORT = TRANSPORT_TYPE_HTTP;
+const STDIO_HTTP_PROXY_STOP_LABEL = "Failed stopping stdio-http proxy";
+const INTERNAL_HTTP_STOP_LABEL = "Failed stopping internal HTTP transport";
+function toErrorMessage$6(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function isValidTransportType(type) {
+	return type === TRANSPORT_TYPE_STDIO || type === TRANSPORT_TYPE_HTTP || type === TRANSPORT_TYPE_SSE || type === TRANSPORT_TYPE_STDIO_HTTP;
+}
+function isValidProxyMode(mode) {
+	return mode === "meta" || mode === "flat" || mode === "search";
+}
+function isAddressInUseError(error) {
+	if (error instanceof Error && error.message.includes("EADDRINUSE")) return true;
+	if (typeof error !== "object" || error === null) return false;
+	if ("code" in error && error.code === "EADDRINUSE") return true;
+	if ("message" in error && typeof error.message === "string" && error.message.includes("EADDRINUSE")) return true;
+	return false;
+}
+async function pathExists(filePath) {
+	try {
+		await (0, node_fs_promises.access)(filePath, node_fs.constants.F_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function findConfigFileAsync() {
+	try {
+		const projectPath = process.env.PROJECT_PATH;
+		if (projectPath) for (const fileName of CONFIG_FILE_NAMES) {
+			const configPath = (0, node_path.resolve)(projectPath, fileName);
+			if (await pathExists(configPath)) return configPath;
+		}
+		const cwd = process.cwd();
+		for (const fileName of CONFIG_FILE_NAMES) {
+			const configPath = (0, node_path.join)(cwd, fileName);
+			if (await pathExists(configPath)) return configPath;
+		}
+		return null;
+	} catch (error) {
+		throw new Error(`Failed to discover MCP config file: ${toErrorMessage$6(error)}`);
+	}
+}
+async function resolveServerId(options, resolvedConfigPath) {
+	if (options.id) return options.id;
+	if (resolvedConfigPath) try {
+		const config = await new require_src.ConfigFetcherService({
+			configFilePath: resolvedConfigPath,
+			useCache: options.cache !== false
+		}).fetchConfiguration(options.cache === false);
+		if (config.id) return config.id;
+	} catch (error) {
+		throw new Error(`Failed to resolve server ID from config '${resolvedConfigPath}': ${toErrorMessage$6(error)}`);
+	}
+	return require_src.generateServerId();
+}
+function validateTransportType(type) {
+	if (!isValidTransportType(type)) throw new Error(`Unknown transport type: '${type}'. Valid options: ${TRANSPORT_TYPE_STDIO}, ${TRANSPORT_TYPE_HTTP}, ${TRANSPORT_TYPE_SSE}, ${TRANSPORT_TYPE_STDIO_HTTP}`);
+	return type;
+}
+function validateProxyMode(mode) {
+	if (!isValidProxyMode(mode)) throw new Error(`Unknown proxy mode: '${mode}'. Valid options: meta, flat, search`);
+}
+function createTransportConfig(options, mode) {
+	return {
+		mode,
+		port: options.port || Number(process.env.MCP_PORT) || DEFAULT_PORT,
+		host: options.host || process.env.MCP_HOST || DEFAULT_HOST
+	};
+}
+function createServerOptions(options, resolvedConfigPath, serverId) {
+	return {
+		configFilePath: resolvedConfigPath,
+		noCache: options.cache === false,
+		serverId,
+		definitionsCachePath: options.definitionsCache,
+		clearDefinitionsCache: options.clearDefinitionsCache,
+		proxyMode: options.proxyMode
+	};
+}
+function formatStartError(type, host, port, error) {
+	const startErrorMessage = toErrorMessage$6(error);
+	if (type === TRANSPORT_TYPE_STDIO) return `Failed to start MCP server with transport '${type}': ${startErrorMessage}`;
+	return `Failed to start MCP server with transport '${type}' on ${host}:${port}: ${startErrorMessage}`;
+}
+function createRuntimeRecord(serverId, config, shutdownToken, configPath) {
+	return {
+		serverId,
+		host: config.host ?? DEFAULT_HOST,
+		port: config.port ?? DEFAULT_PORT,
+		transport: RUNTIME_TRANSPORT,
+		shutdownToken,
+		startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		pid: process.pid,
+		configPath
+	};
+}
+function createHttpAdminOptions(serverId, shutdownToken, onShutdownRequested) {
+	return {
+		serverId,
+		shutdownToken,
+		onShutdownRequested
+	};
+}
+async function removeRuntimeRecord(runtimeStateService, serverId) {
+	try {
+		await runtimeStateService.remove(serverId);
+	} catch (error) {
+		throw new Error(`Failed to remove runtime state for '${serverId}': ${toErrorMessage$6(error)}`);
+	}
+}
+async function writeRuntimeRecord(runtimeStateService, record) {
+	try {
+		await runtimeStateService.write(record);
+	} catch (error) {
+		throw new Error(`Failed to persist runtime state for '${record.serverId}': ${toErrorMessage$6(error)}`);
+	}
+}
+async function stopOwnedHttpTransport(handler, runtimeStateService, serverId) {
+	try {
+		try {
+			await handler.stop();
+		} catch (error) {
+			throw new Error(`Failed to stop owned HTTP transport '${serverId}': ${toErrorMessage$6(error)}`);
+		}
+	} finally {
+		await removeRuntimeRecord(runtimeStateService, serverId);
+	}
+}
+async function cleanupFailedRuntimeStartup(handler, runtimeStateService, serverId) {
+	try {
+		try {
+			await handler.stop();
+		} catch (error) {
+			throw new Error(`Failed to stop HTTP transport during cleanup for '${serverId}': ${toErrorMessage$6(error)}`);
+		}
+	} finally {
+		await removeRuntimeRecord(runtimeStateService, serverId);
+	}
+}
+async function stopTransportWithContext(label, stopOperation) {
+	try {
+		await stopOperation();
+	} catch (error) {
+		throw new Error(`${label}: ${toErrorMessage$6(error)}`);
+	}
+}
+async function removeRuntimeRecordDuringStop(runtimeStateService, serverId) {
+	try {
+		await removeRuntimeRecord(runtimeStateService, serverId);
+	} catch (error) {
+		throw new Error(`Failed to remove runtime state during HTTP stop callback for '${serverId}': ${toErrorMessage$6(error)}`);
+	}
+}
+async function createStdioHttpInternalTransport(serverOptions, config, adminOptions) {
+	try {
+		return new require_src.HttpTransportHandler(await require_src.createServer(serverOptions), config, adminOptions);
+	} catch (error) {
+		throw new Error(`Failed to create internal HTTP transport for stdio-http proxy: ${toErrorMessage$6(error)}`);
+	}
+}
+/**
+* Start MCP server with given transport handler
+* @param handler - The transport handler to start
+* @param onStopped - Optional cleanup callback run after signal-based shutdown
+*/
+async function startServer(handler, onStopped) {
+	try {
+		await handler.start();
+	} catch (error) {
+		throw new Error(`Failed to start transport handler: ${toErrorMessage$6(error)}`);
+	}
+	const shutdown = async (signal) => {
+		console.error(`\nReceived ${signal}, shutting down gracefully...`);
+		try {
+			await handler.stop();
+			if (onStopped) await onStopped();
+			process.exit(0);
+		} catch (error) {
+			console.error(`Failed to gracefully stop transport during ${signal}: ${toErrorMessage$6(error)}`);
+			process.exit(1);
+		}
+	};
+	process.on("SIGINT", async () => await shutdown("SIGINT"));
+	process.on("SIGTERM", async () => await shutdown("SIGTERM"));
+}
+async function createAndStartHttpRuntime(serverOptions, config, resolvedConfigPath) {
+	const runtimeStateService = new require_src.RuntimeStateService();
+	const shutdownToken = (0, node_crypto.randomUUID)();
+	const runtimeRecord = createRuntimeRecord(serverOptions.serverId ?? require_src.generateServerId(), config, shutdownToken, resolvedConfigPath);
+	let handler;
+	let isStopping = false;
+	const stopHandler = async () => {
+		if (isStopping) return;
+		isStopping = true;
+		try {
+			await stopOwnedHttpTransport(handler, runtimeStateService, runtimeRecord.serverId);
+			process.exit(0);
+		} catch (error) {
+			throw new Error(`Failed to stop HTTP runtime '${runtimeRecord.serverId}' from admin shutdown: ${toErrorMessage$6(error)}`);
+		}
+	};
+	try {
+		handler = new require_src.HttpTransportHandler(await require_src.createServer(serverOptions), config, createHttpAdminOptions(runtimeRecord.serverId, shutdownToken, stopHandler));
+	} catch (error) {
+		throw new Error(`Failed to create HTTP runtime server: ${toErrorMessage$6(error)}`);
+	}
+	try {
+		await startServer(handler, async () => {
+			await removeRuntimeRecordDuringStop(runtimeStateService, runtimeRecord.serverId);
+		});
+		await writeRuntimeRecord(runtimeStateService, runtimeRecord);
+	} catch (error) {
+		await cleanupFailedRuntimeStartup(handler, runtimeStateService, runtimeRecord.serverId);
+		throw new Error(`Failed to start HTTP runtime '${runtimeRecord.serverId}': ${toErrorMessage$6(error)}`);
+	}
+	console.error(`Runtime state: http://${runtimeRecord.host}:${runtimeRecord.port} (${runtimeRecord.serverId})`);
+}
+async function stopInternalHttpTransport(stdioHttpHandler, httpHandler, ownsInternalHttpTransport) {
+	try {
+		const stopOperations = [stopTransportWithContext(STDIO_HTTP_PROXY_STOP_LABEL, async () => {
+			await stdioHttpHandler.stop();
+		})];
+		if (ownsInternalHttpTransport && httpHandler) stopOperations.push(stopTransportWithContext(INTERNAL_HTTP_STOP_LABEL, async () => {
+			await httpHandler.stop();
+		}));
+		await Promise.all(stopOperations);
+	} catch (error) {
+		throw new Error(`Failed to stop stdio-http transport: ${toErrorMessage$6(error)}`);
+	}
+}
+async function startStdioTransport(serverOptions) {
+	try {
+		await startServer(new require_src.StdioTransportHandler(await require_src.createServer(serverOptions)));
+	} catch (error) {
+		throw new Error(`Failed to start stdio transport: ${toErrorMessage$6(error)}`);
+	}
+}
+async function startSseTransport(serverOptions, config) {
+	try {
+		await startServer(new require_src.SseTransportHandler(await require_src.createServer(serverOptions), config));
+	} catch (error) {
+		throw new Error(`Failed to start SSE transport: ${toErrorMessage$6(error)}`);
+	}
+}
+async function startStdioHttpTransport(serverOptions, config, resolvedConfigPath) {
+	try {
+		const stdioHttpHandler = new require_src.StdioHttpTransportHandler({ endpoint: new URL(`http://${config.host}:${config.port}${MCP_ENDPOINT_PATH}`) });
+		const runtimeStateService = new require_src.RuntimeStateService();
+		const serverId = serverOptions.serverId ?? require_src.generateServerId();
+		const shutdownToken = (0, node_crypto.randomUUID)();
+		let httpHandler = null;
+		let ownsInternalHttpTransport = false;
+		let isStopping = false;
+		const stopOwnedRuntime = async () => {
+			if (isStopping) return;
+			isStopping = true;
+			try {
+				await Promise.all([stopInternalHttpTransport(stdioHttpHandler, httpHandler, ownsInternalHttpTransport), removeRuntimeRecord(runtimeStateService, serverId)]);
+				ownsInternalHttpTransport = false;
+				process.exit(0);
+			} catch (error) {
+				console.error(`Unexpected error during admin shutdown: ${toErrorMessage$6(error)}`);
+				process.exit(1);
+			}
+		};
+		const adminOptions = createHttpAdminOptions(serverId, shutdownToken, stopOwnedRuntime);
+		await startServer({
+			async start() {
+				let initialProxyConnectError;
+				try {
+					await stdioHttpHandler.start();
+					return;
+				} catch (error) {
+					initialProxyConnectError = error;
+				}
+				try {
+					httpHandler = await createStdioHttpInternalTransport(serverOptions, config, adminOptions);
+					await httpHandler.start();
+					ownsInternalHttpTransport = true;
+				} catch (error) {
+					if (!isAddressInUseError(error)) throw new Error(`Failed to start internal HTTP transport for stdio-http proxy: ${toErrorMessage$6(error)}`);
+				}
+				try {
+					await stdioHttpHandler.start();
+				} catch (error) {
+					let rollbackStopErrorMessage = "";
+					if (ownsInternalHttpTransport && httpHandler) {
+						try {
+							await httpHandler.stop();
+						} catch (stopError) {
+							rollbackStopErrorMessage = toErrorMessage$6(stopError);
+						}
+						ownsInternalHttpTransport = false;
+					}
+					const retryErrorMessage = toErrorMessage$6(error);
+					const initialErrorMessage = toErrorMessage$6(initialProxyConnectError);
+					const rollbackMessage = rollbackStopErrorMessage ? `; rollback stop failed: ${rollbackStopErrorMessage}` : "";
+					throw new Error(`Failed to start stdio-http proxy bridge: initial connect failed (${initialErrorMessage}); retry failed (${retryErrorMessage})${rollbackMessage}`);
+				}
+				if (ownsInternalHttpTransport) try {
+					await writeRuntimeRecord(runtimeStateService, createRuntimeRecord(serverId, config, shutdownToken, resolvedConfigPath));
+				} catch (error) {
+					throw new Error(`Failed to persist runtime state for stdio-http server '${serverId}': ${toErrorMessage$6(error)}`);
+				}
+			},
+			async stop() {
+				try {
+					await Promise.all([stopInternalHttpTransport(stdioHttpHandler, httpHandler, ownsInternalHttpTransport), removeRuntimeRecord(runtimeStateService, serverId)]);
+					ownsInternalHttpTransport = false;
+				} catch (error) {
+					ownsInternalHttpTransport = false;
+					throw new Error(`Failed during stdio-http shutdown for '${serverId}': ${toErrorMessage$6(error)}`);
+				}
+			}
+		});
+	} catch (error) {
+		throw new Error(`Failed to start stdio-http transport: ${toErrorMessage$6(error)}`);
+	}
+}
+async function startTransport(transportType, options, resolvedConfigPath, serverOptions) {
+	try {
+		if (transportType === TRANSPORT_TYPE_STDIO) {
+			await startStdioTransport(serverOptions);
+			return;
+		}
+		if (transportType === TRANSPORT_TYPE_HTTP) {
+			await createAndStartHttpRuntime(serverOptions, createTransportConfig(options, require_src.TRANSPORT_MODE.HTTP), resolvedConfigPath);
+			return;
+		}
+		if (transportType === TRANSPORT_TYPE_SSE) {
+			await startSseTransport(serverOptions, createTransportConfig(options, require_src.TRANSPORT_MODE.SSE));
+			return;
+		}
+		await startStdioHttpTransport(serverOptions, createTransportConfig(options, require_src.TRANSPORT_MODE.HTTP), resolvedConfigPath);
+	} catch (error) {
+		throw new Error(`Failed to start transport '${transportType}': ${toErrorMessage$6(error)}`);
+	}
+}
+/**
+* MCP Serve command
+*/
+const mcpServeCommand = new commander.Command("mcp-serve").description("Start MCP server with specified transport").option("-t, --type <type>", `Transport type: ${TRANSPORT_TYPE_STDIO}, ${TRANSPORT_TYPE_HTTP}, ${TRANSPORT_TYPE_SSE}, or ${TRANSPORT_TYPE_STDIO_HTTP}`, TRANSPORT_TYPE_STDIO).option("-p, --port <port>", "Port to listen on (http/sse/stdio-http internal HTTP)", (val) => parseInt(val, 10), DEFAULT_PORT).option("--host <host>", "Host to bind to (http/sse/stdio-http internal HTTP)", DEFAULT_HOST).option("-c, --config <path>", "Path to MCP server configuration file").option("--no-cache", "Disable configuration caching, always reload from config file").option("--definitions-cache <path>", "Path to prefetched tool/prompt/skill definitions cache file").option("--clear-definitions-cache", "Delete definitions cache before startup", false).option("--proxy-mode <mode>", "How one-mcp exposes downstream tools: meta, flat, or search", "meta").option("--id <id>", "Unique server identifier (overrides config file id, auto-generated if not provided)").action(async (options) => {
+	try {
+		const transportType = validateTransportType(options.type.toLowerCase());
+		validateProxyMode(options.proxyMode);
+		const resolvedConfigPath = options.config || await findConfigFileAsync() || void 0;
+		await startTransport(transportType, options, resolvedConfigPath, createServerOptions(options, resolvedConfigPath, await resolveServerId(options, resolvedConfigPath)));
+	} catch (error) {
+		const rawTransportType = options.type.toLowerCase();
+		const transportType = isValidTransportType(rawTransportType) ? rawTransportType : TRANSPORT_TYPE_STDIO;
+		console.error(formatStartError(transportType, options.host, options.port, error));
+		process.exit(1);
+	}
+});
+
 //#endregion
 //#region src/commands/list-tools.ts
 /**
@@ -587,7 +878,7 @@ var PrefetchService = class {
 * - Hardcoded values (use options or environment variables)
 * - Not exiting with appropriate exit codes on errors
 */
-function toErrorMessage$4(error) {
+function toErrorMessage$5(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 function printSearchResults(result) {
@@ -608,29 +899,29 @@ function printSearchResults(result) {
 }
 const searchToolsCommand = new commander.Command("search-tools").description("Search proxied MCP tools by capability or server").option("-c, --config <path>", "Path to MCP server configuration file").option("-s, --server <name>", "Filter by server name").option("--capability <name>", "Filter by capability tag, summary, tool name, or description").option("--definitions-cache <path>", "Path to definitions cache file").option("-j, --json", "Output as JSON", false).action(async (options) => {
 	try {
-		const configFilePath = options.config || require_http.findConfigFile();
+		const configFilePath = options.config || require_src.findConfigFile();
 		if (!configFilePath) throw new Error("No config file found. Use --config or create mcp-config.yaml");
-		const config = await new require_http.ConfigFetcherService({ configFilePath }).fetchConfiguration();
-		const clientManager = new require_http.McpClientManagerService();
+		const config = await new require_src.ConfigFetcherService({ configFilePath }).fetchConfiguration();
+		const clientManager = new require_src.McpClientManagerService();
 		clientManager.registerServerConfigs(config.mcpServers);
 		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}: ${toErrorMessage$4(error)}`);
+				if (!options.json) console.error(`✗ Failed to connect to ${serverName}: ${toErrorMessage$5(error)}`);
 			}
 		});
 		await Promise.all(connectionPromises);
 		if (clientManager.getAllClients().length === 0) throw new Error("No MCP servers connected");
-		const cachePath = options.definitionsCache || require_http.DefinitionsCacheService.getDefaultCachePath(configFilePath);
+		const cachePath = options.definitionsCache || require_src.DefinitionsCacheService.getDefaultCachePath(configFilePath);
 		let cacheData;
 		try {
-			cacheData = await require_http.DefinitionsCacheService.readFromFile(cachePath);
+			cacheData = await require_src.DefinitionsCacheService.readFromFile(cachePath);
 		} catch {
 			cacheData = void 0;
 		}
-		const textBlock = (await new require_http.SearchListToolsTool(clientManager, new require_http.DefinitionsCacheService(clientManager, void 0, { cacheData })).execute({
+		const textBlock = (await new require_src.SearchListToolsTool(clientManager, new require_src.DefinitionsCacheService(clientManager, void 0, { cacheData })).execute({
 			capability: options.capability,
 			serverName: options.server
 		})).content.find((content) => content.type === "text");
@@ -642,7 +933,7 @@ const searchToolsCommand = new commander.Command("search-tools").description("Se
 		}
 		await clientManager.disconnectAll();
 	} catch (error) {
-		console.error(`Error executing search-tools: ${toErrorMessage$4(error)}`);
+		console.error(`Error executing search-tools: ${toErrorMessage$5(error)}`);
 		process.exit(1);
 	}
 });
@@ -675,13 +966,13 @@ const searchToolsCommand = new commander.Command("search-tools").description("Se
 */
 const describeToolsCommand = new commander.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 {
-		const configFilePath = options.config || require_http.findConfigFile();
+		const configFilePath = options.config || require_src.findConfigFile();
 		if (!configFilePath) {
 			console.error("Error: No config file found. Use --config or create mcp-config.yaml");
 			process.exit(1);
 		}
-		const config = await new require_http.ConfigFetcherService({ configFilePath }).fetchConfiguration();
-		const clientManager = new require_http.McpClientManagerService();
+		const config = await new require_src.ConfigFetcherService({ configFilePath }).fetchConfiguration();
+		const clientManager = new require_src.McpClientManagerService();
 		const connectionPromises = Object.entries(config.mcpServers).map(async ([serverName, serverConfig]) => {
 			try {
 				await clientManager.connectToServer(serverName, serverConfig);
@@ -698,7 +989,7 @@ const describeToolsCommand = new commander.Command("describe-tools").description
 		}
 		const cwd = process.env.PROJECT_PATH || process.cwd();
 		const skillPaths = config.skills?.paths || [];
-		const skillService = skillPaths.length > 0 ? new require_http.SkillService(cwd, skillPaths) : void 0;
+		const skillService = skillPaths.length > 0 ? new require_src.SkillService(cwd, skillPaths) : void 0;
 		const foundTools = [];
 		const foundSkills = [];
 		const notFoundTools = [...toolNames];
@@ -833,7 +1124,7 @@ const describeToolsCommand = new commander.Command("describe-tools").description
 */
 const useToolCommand = new commander.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 {
-		const configFilePath = options.config || require_http.findConfigFile();
+		const configFilePath = options.config || require_src.findConfigFile();
 		if (!configFilePath) {
 			console.error("Error: No config file found. Use --config or create mcp-config.yaml");
 			process.exit(1);
@@ -845,8 +1136,8 @@ const useToolCommand = new commander.Command("use-tool").description("Execute an
 			console.error("Error: Invalid JSON in --args");
 			process.exit(1);
 		}
-		const config = await new require_http.ConfigFetcherService({ configFilePath }).fetchConfiguration();
-		const clientManager = new require_http.McpClientManagerService();
+		const config = await new require_src.ConfigFetcherService({ configFilePath }).fetchConfiguration();
+		const clientManager = new require_src.McpClientManagerService();
 		const connectionPromises = Object.entries(config.mcpServers).map(async ([serverName, serverConfig]) => {
 			try {
 				await clientManager.connectToServer(serverName, serverConfig);
@@ -916,7 +1207,7 @@ const useToolCommand = new commander.Command("use-tool").description("Execute an
 			const cwd = process.env.PROJECT_PATH || process.cwd();
 			const skillPaths = config.skills?.paths || [];
 			if (skillPaths.length > 0) try {
-				const skillService = new require_http.SkillService(cwd, skillPaths);
+				const skillService = new require_src.SkillService(cwd, skillPaths);
 				const skillName = toolName.startsWith("skill__") ? toolName.slice(7) : toolName;
 				const skill = await skillService.getSkill(skillName);
 				if (skill) {
@@ -1001,7 +1292,7 @@ const useToolCommand = new commander.Command("use-tool").description("Execute an
 * - Hardcoded values (use options or environment variables)
 * - Not exiting with appropriate exit codes on errors
 */
-function toErrorMessage$3(error) {
+function toErrorMessage$4(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 /**
@@ -1009,16 +1300,16 @@ function toErrorMessage$3(error) {
 */
 const listResourcesCommand = new commander.Command("list-resources").description("List all available resources 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 {
-		const configFilePath = options.config || require_http.findConfigFile();
+		const configFilePath = options.config || require_src.findConfigFile();
 		if (!configFilePath) throw new Error("No config file found. Use --config or create mcp-config.yaml");
-		const config = await new require_http.ConfigFetcherService({ configFilePath }).fetchConfiguration();
-		const clientManager = new require_http.McpClientManagerService();
+		const config = await new require_src.ConfigFetcherService({ configFilePath }).fetchConfiguration();
+		const clientManager = new require_src.McpClientManagerService();
 		await Promise.all(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}: ${toErrorMessage$3(error)}`);
+				if (!options.json) console.error(`✗ Failed to connect to ${serverName}: ${toErrorMessage$4(error)}`);
 			}
 		}));
 		const clients = options.server ? [clientManager.getClient(options.server)].filter((c) => c !== void 0) : clientManager.getAllClients();
@@ -1041,7 +1332,7 @@ const listResourcesCommand = new commander.Command("list-resources").description
 			}
 		}));
 		for (const { serverName, resources, error } of resourceResults) {
-			if (error && !options.json) console.error(`Failed to list resources from ${serverName}: ${toErrorMessage$3(error)}`);
+			if (error && !options.json) console.error(`Failed to list resources from ${serverName}: ${toErrorMessage$4(error)}`);
 			resourcesByServer[serverName] = resources;
 		}
 		if (options.json) console.log(JSON.stringify(resourcesByServer, null, 2));
@@ -1055,7 +1346,7 @@ const listResourcesCommand = new commander.Command("list-resources").description
 		}
 		await clientManager.disconnectAll();
 	} catch (error) {
-		console.error(`Error executing list-resources: ${toErrorMessage$3(error)}`);
+		console.error(`Error executing list-resources: ${toErrorMessage$4(error)}`);
 		process.exit(1);
 	}
 });
@@ -1083,7 +1374,7 @@ const listResourcesCommand = new commander.Command("list-resources").description
 * - Hardcoded values (use options or environment variables)
 * - Not exiting with appropriate exit codes on errors
 */
-function toErrorMessage$2(error) {
+function toErrorMessage$3(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 /**
@@ -1091,16 +1382,16 @@ function toErrorMessage$2(error) {
 */
 const readResourceCommand = new commander.Command("read-resource").description("Read a resource by URI from a connected MCP server").argument("<uri>", "Resource URI to read").option("-c, --config <path>", "Path to MCP server configuration file").option("-s, --server <name>", "Server name (required if resource exists on multiple servers)").option("-j, --json", "Output as JSON", false).action(async (uri, options) => {
 	try {
-		const configFilePath = options.config || require_http.findConfigFile();
+		const configFilePath = options.config || require_src.findConfigFile();
 		if (!configFilePath) throw new Error("No config file found. Use --config or create mcp-config.yaml");
-		const config = await new require_http.ConfigFetcherService({ configFilePath }).fetchConfiguration();
-		const clientManager = new require_http.McpClientManagerService();
+		const config = await new require_src.ConfigFetcherService({ configFilePath }).fetchConfiguration();
+		const clientManager = new require_src.McpClientManagerService();
 		await Promise.all(Object.entries(config.mcpServers).map(async ([serverName, serverConfig]) => {
 			try {
 				await clientManager.connectToServer(serverName, serverConfig);
 				if (!options.json) console.error(`✓ Connected to ${serverName}`);
 			} catch (error) {
-				console.error(`✗ Failed to connect to ${serverName}: ${toErrorMessage$2(error)}`);
+				console.error(`✗ Failed to connect to ${serverName}: ${toErrorMessage$3(error)}`);
 			}
 		}));
 		const clients = clientManager.getAllClients();
@@ -1135,7 +1426,7 @@ const readResourceCommand = new commander.Command("read-resource").description("
 		const matchingServers = [];
 		for (const { serverName, hasResource, error } of searchResults) {
 			if (error) {
-				console.error(`Failed to list resources from ${serverName}: ${toErrorMessage$2(error)}`);
+				console.error(`Failed to list resources from ${serverName}: ${toErrorMessage$3(error)}`);
 				continue;
 			}
 			if (hasResource) matchingServers.push(serverName);
@@ -1152,28 +1443,28 @@ const readResourceCommand = new commander.Command("read-resource").description("
 		else console.log(JSON.stringify(content, null, 2));
 		await clientManager.disconnectAll();
 	} catch (error) {
-		console.error(`Error executing read-resource: ${toErrorMessage$2(error)}`);
+		console.error(`Error executing read-resource: ${toErrorMessage$3(error)}`);
 		process.exit(1);
 	}
 });
 
 //#endregion
 //#region src/commands/list-prompts.ts
-function toErrorMessage$1(error) {
+function toErrorMessage$2(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 const listPromptsCommand = new commander.Command("list-prompts").description("List all available prompts 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 {
-		const configFilePath = options.config || require_http.findConfigFile();
+		const configFilePath = options.config || require_src.findConfigFile();
 		if (!configFilePath) throw new Error("No config file found. Use --config or create mcp-config.yaml");
-		const config = await new require_http.ConfigFetcherService({ configFilePath }).fetchConfiguration();
-		const clientManager = new require_http.McpClientManagerService();
+		const config = await new require_src.ConfigFetcherService({ configFilePath }).fetchConfiguration();
+		const clientManager = new require_src.McpClientManagerService();
 		await Promise.all(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}: ${toErrorMessage$1(error)}`);
+				if (!options.json) console.error(`✗ Failed to connect to ${serverName}: ${toErrorMessage$2(error)}`);
 			}
 		}));
 		const clients = options.server ? [clientManager.getClient(options.server)].filter((client) => client !== void 0) : clientManager.getAllClients();
@@ -1184,7 +1475,7 @@ const listPromptsCommand = new commander.Command("list-prompts").description("Li
 				promptsByServer[client.serverName] = await client.listPrompts();
 			} catch (error) {
 				promptsByServer[client.serverName] = [];
-				if (!options.json) console.error(`Failed to list prompts from ${client.serverName}: ${toErrorMessage$1(error)}`);
+				if (!options.json) console.error(`Failed to list prompts from ${client.serverName}: ${toErrorMessage$2(error)}`);
 			}
 		}));
 		if (options.json) console.log(JSON.stringify(promptsByServer, null, 2));
@@ -1204,19 +1495,19 @@ const listPromptsCommand = new commander.Command("list-prompts").description("Li
 		}
 		await clientManager.disconnectAll();
 	} catch (error) {
-		console.error(`Error executing list-prompts: ${toErrorMessage$1(error)}`);
+		console.error(`Error executing list-prompts: ${toErrorMessage$2(error)}`);
 		process.exit(1);
 	}
 });
 
 //#endregion
 //#region src/commands/get-prompt.ts
-function toErrorMessage(error) {
+function toErrorMessage$1(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 const getPromptCommand = new commander.Command("get-prompt").description("Get a prompt by name from a connected MCP server").argument("<promptName>", "Prompt name to fetch").option("-c, --config <path>", "Path to MCP server configuration file").option("-s, --server <name>", "Server name (required if prompt exists on multiple servers)").option("-a, --args <json>", "Prompt arguments as JSON string", "{}").option("-j, --json", "Output as JSON", false).action(async (promptName, options) => {
 	try {
-		const configFilePath = options.config || require_http.findConfigFile();
+		const configFilePath = options.config || require_src.findConfigFile();
 		if (!configFilePath) throw new Error("No config file found. Use --config or create mcp-config.yaml");
 		let promptArgs = {};
 		try {
@@ -1224,14 +1515,14 @@ const getPromptCommand = new commander.Command("get-prompt").description("Get a
 		} catch {
 			throw new Error("Invalid JSON in --args");
 		}
-		const config = await new require_http.ConfigFetcherService({ configFilePath }).fetchConfiguration();
-		const clientManager = new require_http.McpClientManagerService();
+		const config = await new require_src.ConfigFetcherService({ configFilePath }).fetchConfiguration();
+		const clientManager = new require_src.McpClientManagerService();
 		await Promise.all(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}: ${toErrorMessage(error)}`);
+				if (!options.json) console.error(`✗ Failed to connect to ${serverName}: ${toErrorMessage$1(error)}`);
 			}
 		}));
 		const clients = clientManager.getAllClients();
@@ -1254,7 +1545,7 @@ const getPromptCommand = new commander.Command("get-prompt").description("Get a
 			try {
 				if ((await client$1.listPrompts()).some((prompt$1) => prompt$1.name === promptName)) matchingServers.push(client$1.serverName);
 			} catch (error) {
-				if (!options.json) console.error(`Failed to list prompts from ${client$1.serverName}: ${toErrorMessage(error)}`);
+				if (!options.json) console.error(`Failed to list prompts from ${client$1.serverName}: ${toErrorMessage$1(error)}`);
 			}
 		}));
 		if (matchingServers.length === 0) throw new Error(`Prompt "${promptName}" not found on any connected server`);
@@ -1270,7 +1561,7 @@ const getPromptCommand = new commander.Command("get-prompt").description("Get a
 		}
 		await clientManager.disconnectAll();
 	} catch (error) {
-		console.error(`Error executing get-prompt: ${toErrorMessage(error)}`);
+		console.error(`Error executing get-prompt: ${toErrorMessage$1(error)}`);
 		process.exit(1);
 	}
 });
@@ -1303,20 +1594,20 @@ const getPromptCommand = new commander.Command("get-prompt").description("Get a
 */
 const prefetchCommand = new commander.Command("prefetch").description("Pre-download packages used by MCP servers (npx, pnpx, uvx, uv)").option("-c, --config <path>", "Path to MCP server configuration file").option("-p, --parallel", "Run prefetch commands in parallel", false).option("-d, --dry-run", "Show what would be prefetched without executing", false).option("-f, --filter <type>", "Filter by package manager type: npx, pnpx, uvx, or uv").option("--definitions-out <path>", "Write discovered definitions to a JSON or YAML cache file").option("--skip-packages", "Skip package prefetch and only build definitions cache", false).option("--clear-definitions-cache", "Delete the definitions cache file before continuing", false).action(async (options) => {
 	try {
-		const configFilePath = options.config || require_http.findConfigFile();
+		const configFilePath = options.config || require_src.findConfigFile();
 		if (!configFilePath) {
 			__agiflowai_aicode_utils.print.error("No MCP configuration file found.");
 			__agiflowai_aicode_utils.print.info("Use --config <path> to specify a config file, or run \"one-mcp init\" to create one.");
 			process.exit(1);
 		}
 		__agiflowai_aicode_utils.print.info(`Loading configuration from: ${configFilePath}`);
-		const mcpConfig = await new require_http.ConfigFetcherService({
+		const mcpConfig = await new require_src.ConfigFetcherService({
 			configFilePath,
 			useCache: false
 		}).fetchConfiguration(true);
-		const serverId = mcpConfig.id || require_http.generateServerId();
-		const configHash = require_http.DefinitionsCacheService.generateConfigHash(mcpConfig);
-		const effectiveDefinitionsPath = options.definitionsOut || require_http.DefinitionsCacheService.getDefaultCachePath(configFilePath);
+		const serverId = mcpConfig.id || require_src.generateServerId();
+		const configHash = require_src.DefinitionsCacheService.generateConfigHash(mcpConfig);
+		const effectiveDefinitionsPath = options.definitionsOut || require_src.DefinitionsCacheService.getDefaultCachePath(configFilePath);
 		const prefetchService = new PrefetchService({
 			mcpConfig,
 			filter: options.filter,
@@ -1327,7 +1618,7 @@ const prefetchCommand = new commander.Command("prefetch").description("Pre-downl
 		const shouldWriteDefinitions = Boolean(options.definitionsOut);
 		if (options.clearDefinitionsCache) if (options.dryRun) __agiflowai_aicode_utils.print.info(`Would clear definitions cache: ${effectiveDefinitionsPath}`);
 		else {
-			await require_http.DefinitionsCacheService.clearFile(effectiveDefinitionsPath);
+			await require_src.DefinitionsCacheService.clearFile(effectiveDefinitionsPath);
 			__agiflowai_aicode_utils.print.success(`Cleared definitions cache: ${effectiveDefinitionsPath}`);
 		}
 		if (shouldPrefetchPackages) if (packages.length === 0) {
@@ -1371,9 +1662,9 @@ const prefetchCommand = new commander.Command("prefetch").description("Pre-downl
 		if (shouldWriteDefinitions) {
 			__agiflowai_aicode_utils.print.newline();
 			__agiflowai_aicode_utils.print.info("Collecting definitions cache...");
-			const clientManager = new require_http.McpClientManagerService();
+			const clientManager = new require_src.McpClientManagerService();
 			const skillPaths = mcpConfig.skills?.paths || [];
-			const definitionsCacheService = new require_http.DefinitionsCacheService(clientManager, skillPaths.length > 0 ? new require_http.SkillService(process.cwd(), skillPaths) : void 0);
+			const definitionsCacheService = new require_src.DefinitionsCacheService(clientManager, skillPaths.length > 0 ? new require_src.SkillService(process.cwd(), skillPaths) : void 0);
 			await Promise.all(Object.entries(mcpConfig.mcpServers).map(async ([serverName, serverConfig]) => {
 				try {
 					await clientManager.connectToServer(serverName, serverConfig);
@@ -1385,10 +1676,10 @@ const prefetchCommand = new commander.Command("prefetch").description("Pre-downl
 			const definitionsCache = await definitionsCacheService.collectForCache({
 				configPath: configFilePath,
 				configHash,
-				oneMcpVersion: require_http.version,
+				oneMcpVersion: require_src.version,
 				serverId
 			});
-			await require_http.DefinitionsCacheService.writeToFile(effectiveDefinitionsPath, definitionsCache);
+			await require_src.DefinitionsCacheService.writeToFile(effectiveDefinitionsPath, definitionsCache);
 			__agiflowai_aicode_utils.print.success(`Definitions cache written: ${effectiveDefinitionsPath} (${Object.keys(definitionsCache.servers).length} servers, ${definitionsCache.skills.length} skills)`);
 			if (definitionsCache.failures.length > 0) __agiflowai_aicode_utils.print.warning(`Definitions cache completed with ${definitionsCache.failures.length} server failure(s)`);
 			await clientManager.disconnectAll();
@@ -1400,6 +1691,52 @@ const prefetchCommand = new commander.Command("prefetch").description("Pre-downl
 	}
 });
 
+//#endregion
+//#region src/commands/stop.ts
+/**
+* Stop Command
+*
+* Stops a running HTTP one-mcp server using the authenticated admin endpoint
+* and the persisted runtime registry.
+*/
+function toErrorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function printStopResult(result) {
+	console.log(`Stopped one-mcp server '${result.serverId}'.`);
+	console.log(`Endpoint: http://${result.host}:${result.port}`);
+	console.log(`Result: ${result.message}`);
+}
+/**
+* Stop a running HTTP one-mcp server.
+*/
+const stopCommand = new commander.Command("stop").description("Stop a running HTTP one-mcp server").option("--id <id>", "Target server ID from the runtime registry").option("--host <host>", "Target runtime host").option("--port <port>", "Target runtime port", (value) => Number.parseInt(value, 10)).option("-c, --config <path>", "Reserved for future config-based targeting support").option("--token <token>", "Override the persisted shutdown token").option("--force", "Skip server ID verification against the /health response", false).option("-j, --json", "Output as JSON", false).option("--timeout <ms>", "Maximum time to wait for shutdown completion", (value) => Number.parseInt(value, 10), 5e3).action(async (options) => {
+	try {
+		if (options.config) console.error("Warning: --config is not used yet; runtime resolution uses the persisted registry.");
+		const result = await new require_src.StopServerService().stop({
+			serverId: options.id,
+			host: options.host,
+			port: options.port,
+			token: options.token,
+			force: options.force,
+			timeoutMs: options.timeout
+		});
+		if (options.json) {
+			console.log(JSON.stringify(result, null, 2));
+			return;
+		}
+		printStopResult(result);
+	} catch (error) {
+		const errorMessage = `Error executing stop: ${toErrorMessage(error)}`;
+		if (options.json) console.log(JSON.stringify({
+			ok: false,
+			error: errorMessage
+		}, null, 2));
+		else console.error(errorMessage);
+		process.exit(1);
+	}
+});
+
 //#endregion
 //#region src/cli.ts
 /**
@@ -1426,7 +1763,7 @@ const prefetchCommand = new commander.Command("prefetch").description("Pre-downl
 async function main() {
 	try {
 		const program = new commander.Command();
-		program.name("one-mcp").description("One MCP server package").version(require_http.version);
+		program.name("one-mcp").description("One MCP server package").version(require_src.version);
 		program.addCommand(initCommand);
 		program.addCommand(mcpServeCommand);
 		program.addCommand(searchToolsCommand);
@@ -1437,6 +1774,7 @@ async function main() {
 		program.addCommand(listPromptsCommand);
 		program.addCommand(getPromptCommand);
 		program.addCommand(prefetchCommand);
+		program.addCommand(stopCommand);
 		await program.parseAsync(process.argv);
 	} catch (error) {
 		console.error(`CLI execution failed: ${error instanceof Error ? error.message : error}`);