@agiflowai/one-mcp 0.2.7 → 0.3.1

package/dist/cli.mjs

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
-import { a as SkillService, c as ConfigFetcherService, i as createServer, n as SseTransportHandler, o as findConfigFile, r as StdioTransportHandler, s as McpClientManagerService, t as HttpTransportHandler } from "./http-DSkkpGJU.mjs";
+import { a as SkillService, c as ConfigFetcherService, i as createServer, n as SseTransportHandler, o as findConfigFile, r as StdioTransportHandler, s as McpClientManagerService, t as HttpTransportHandler } from "./http-xi_ha63Y.mjs";
 import { writeFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import { Liquid } from "liquidjs";
 import { Command } from "commander";
-import { log } from "@agiflowai/aicode-utils";
+import { log, print } from "@agiflowai/aicode-utils";
+import { spawn } from "node:child_process";
 
 //#region src/types/index.ts
 /**
@@ -68,7 +69,7 @@ async function startServer(handler) {
 /**
 * 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", "Disable configuration caching, always reload from config file").action(async (options) => {
+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", "Disable configuration caching, always reload from config file").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`);
@@ -77,7 +78,8 @@ const mcpServeCommand = new Command("mcp-serve").description("Start MCP server w
 	try {
 		const serverOptions = {
 			configFilePath: options.config || findConfigFile() || void 0,
-			noCache: options.cache === false
+			noCache: options.cache === false,
+			serverId: options.id
 		};
 		if (transportType === "stdio") await startServer(new StdioTransportHandler(await createServer(serverOptions)));
 		else if (transportType === "http") await startServer(new HttpTransportHandler(await createServer(serverOptions), {
@@ -546,9 +548,462 @@ const initCommand = new Command("init").description("Initialize MCP configuratio
 	}
 });
 
+//#endregion
+//#region src/services/PrefetchService/constants.ts
+/**
+* PrefetchService Constants
+*
+* Constants for package manager commands and process configuration.
+*/
+/** Transport type for stdio-based MCP servers */
+const TRANSPORT_STDIO = "stdio";
+/** npx command name */
+const COMMAND_NPX = "npx";
+/** npm command name */
+const COMMAND_NPM = "npm";
+/** pnpx command name (pnpm's npx equivalent) */
+const COMMAND_PNPX = "pnpx";
+/** pnpm command name */
+const COMMAND_PNPM = "pnpm";
+/** uvx command name */
+const COMMAND_UVX = "uvx";
+/** uv command name */
+const COMMAND_UV = "uv";
+/** Path suffix for npx command */
+const COMMAND_NPX_SUFFIX = "/npx";
+/** Path suffix for pnpx command */
+const COMMAND_PNPX_SUFFIX = "/pnpx";
+/** Path suffix for uvx command */
+const COMMAND_UVX_SUFFIX = "/uvx";
+/** Path suffix for uv command */
+const COMMAND_UV_SUFFIX = "/uv";
+/** Run subcommand for uv */
+const ARG_RUN = "run";
+/** Tool subcommand for uv */
+const ARG_TOOL = "tool";
+/** Install subcommand for uv tool and npm/pnpm */
+const ARG_INSTALL = "install";
+/** Add subcommand for pnpm */
+const ARG_ADD = "add";
+/** Global flag for npm/pnpm install */
+const ARG_GLOBAL = "-g";
+/** Flag prefix for command arguments */
+const FLAG_PREFIX = "-";
+/** npx --package flag (long form) */
+const FLAG_PACKAGE_LONG = "--package";
+/** npx -p flag (short form) */
+const FLAG_PACKAGE_SHORT = "-p";
+/** Equals delimiter used in flag=value patterns */
+const EQUALS_DELIMITER = "=";
+/**
+* Regex pattern for valid package names (npm, pnpm, uvx, uv)
+* Allows: @scope/package-name@version, package-name, package_name
+* Prevents shell metacharacters that could enable command injection
+* @example
+* // Valid: '@scope/package@1.0.0', 'my-package', 'my_package', '@org/pkg'
+* // Invalid: 'pkg; rm -rf /', 'pkg$(cmd)', 'pkg`whoami`', 'pkg|cat /etc/passwd'
+*/
+const VALID_PACKAGE_NAME_PATTERN = /^(@[a-zA-Z0-9_-]+\/)?[a-zA-Z0-9._-]+(@[a-zA-Z0-9._-]+)?$/;
+/** Windows platform identifier */
+const PLATFORM_WIN32 = "win32";
+/** Success exit code */
+const EXIT_CODE_SUCCESS = 0;
+/** Stdio option to ignore stream */
+const STDIO_IGNORE = "ignore";
+/** Stdio option to pipe stream */
+const STDIO_PIPE = "pipe";
+
+//#endregion
+//#region src/services/PrefetchService/PrefetchService.ts
+/**
+* PrefetchService
+*
+* DESIGN PATTERNS:
+* - Service pattern for business logic encapsulation
+* - Single responsibility principle
+*
+* CODING STANDARDS:
+* - Use async/await for asynchronous operations
+* - Throw descriptive errors for error cases
+* - Keep methods focused and well-named
+* - Document complex logic with comments
+*
+* AVOID:
+* - Mixing concerns (keep focused on single domain)
+* - Direct tool implementation (services should be tool-agnostic)
+*/
+/**
+* Type guard to check if a config object is an McpStdioConfig
+* @param config - Config object to check
+* @returns True if config has required McpStdioConfig properties
+*/
+function isMcpStdioConfig(config) {
+	return typeof config === "object" && config !== null && "command" in config;
+}
+/**
+* PrefetchService handles pre-downloading packages used by MCP servers.
+* Supports npx (Node.js), uvx (Python/uv), and uv run commands.
+*
+* @example
+* ```typescript
+* const service = new PrefetchService({
+*   mcpConfig: await configFetcher.fetchConfiguration(),
+*   parallel: true,
+* });
+* const packages = service.extractPackages();
+* const summary = await service.prefetch();
+* ```
+*/
+var PrefetchService = class {
+	config;
+	/**
+	* Creates a new PrefetchService instance
+	* @param config - Service configuration options
+	*/
+	constructor(config) {
+		this.config = config;
+	}
+	/**
+	* Extract all prefetchable packages from the MCP configuration
+	* @returns Array of package info objects
+	*/
+	extractPackages() {
+		const packages = [];
+		const { mcpConfig, filter } = this.config;
+		for (const [serverName, serverConfig] of Object.entries(mcpConfig.mcpServers)) {
+			if (serverConfig.disabled) continue;
+			if (serverConfig.transport !== TRANSPORT_STDIO) continue;
+			if (!isMcpStdioConfig(serverConfig.config)) continue;
+			const packageInfo = this.extractPackageInfo(serverName, serverConfig.config);
+			if (packageInfo) {
+				if (filter && packageInfo.packageManager !== filter) continue;
+				packages.push(packageInfo);
+			}
+		}
+		return packages;
+	}
+	/**
+	* Prefetch all packages from the configuration
+	* @returns Summary of prefetch results
+	* @throws Error if prefetch operation fails unexpectedly
+	*/
+	async prefetch() {
+		try {
+			const packages = this.extractPackages();
+			const results = [];
+			if (packages.length === 0) return {
+				totalPackages: 0,
+				successful: 0,
+				failed: 0,
+				results: []
+			};
+			if (this.config.parallel) {
+				const promises = packages.map(async (pkg) => this.prefetchPackage(pkg));
+				results.push(...await Promise.all(promises));
+			} else for (const pkg of packages) {
+				const result = await this.prefetchPackage(pkg);
+				results.push(result);
+			}
+			const successful = results.filter((r) => r.success).length;
+			const failed = results.filter((r) => !r.success).length;
+			return {
+				totalPackages: packages.length,
+				successful,
+				failed,
+				results
+			};
+		} catch (error) {
+			throw new Error(`Failed to prefetch packages: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	/**
+	* Prefetch a single package
+	* @param pkg - Package info to prefetch
+	* @returns Result of the prefetch operation
+	*/
+	async prefetchPackage(pkg) {
+		try {
+			const [command, ...args] = pkg.fullCommand;
+			const result = await this.runCommand(command, args);
+			return {
+				package: pkg,
+				success: result.success,
+				output: result.output
+			};
+		} catch (error) {
+			return {
+				package: pkg,
+				success: false,
+				output: error instanceof Error ? error.message : String(error)
+			};
+		}
+	}
+	/**
+	* Validate package name to prevent command injection
+	* @param packageName - Package name to validate
+	* @returns True if package name is safe, false otherwise
+	* @remarks Rejects package names containing shell metacharacters
+	* @example
+	* isValidPackageName('@scope/package') // true
+	* isValidPackageName('my-package@1.0.0') // true
+	* isValidPackageName('pkg; rm -rf /') // false (shell injection)
+	* isValidPackageName('pkg$(whoami)') // false (command substitution)
+	*/
+	isValidPackageName(packageName) {
+		return VALID_PACKAGE_NAME_PATTERN.test(packageName);
+	}
+	/**
+	* Extract package info from a server's stdio config
+	* @param serverName - Name of the MCP server
+	* @param config - Stdio configuration for the server
+	* @returns Package info if extractable, null otherwise
+	*/
+	extractPackageInfo(serverName, config) {
+		const command = config.command.toLowerCase();
+		const args = config.args || [];
+		if (command === COMMAND_NPX || command.endsWith(COMMAND_NPX_SUFFIX)) {
+			const packageName = this.extractNpxPackage(args);
+			if (packageName && this.isValidPackageName(packageName)) return {
+				serverName,
+				packageManager: COMMAND_NPX,
+				packageName,
+				fullCommand: [
+					COMMAND_NPM,
+					ARG_INSTALL,
+					ARG_GLOBAL,
+					packageName
+				]
+			};
+		}
+		if (command === COMMAND_PNPX || command.endsWith(COMMAND_PNPX_SUFFIX)) {
+			const packageName = this.extractNpxPackage(args);
+			if (packageName && this.isValidPackageName(packageName)) return {
+				serverName,
+				packageManager: COMMAND_PNPX,
+				packageName,
+				fullCommand: [
+					COMMAND_PNPM,
+					ARG_ADD,
+					ARG_GLOBAL,
+					packageName
+				]
+			};
+		}
+		if (command === COMMAND_UVX || command.endsWith(COMMAND_UVX_SUFFIX)) {
+			const packageName = this.extractUvxPackage(args);
+			if (packageName && this.isValidPackageName(packageName)) return {
+				serverName,
+				packageManager: COMMAND_UVX,
+				packageName,
+				fullCommand: [COMMAND_UVX, packageName]
+			};
+		}
+		if ((command === COMMAND_UV || command.endsWith(COMMAND_UV_SUFFIX)) && args.includes(ARG_RUN)) {
+			const packageName = this.extractUvRunPackage(args);
+			if (packageName && this.isValidPackageName(packageName)) return {
+				serverName,
+				packageManager: COMMAND_UV,
+				packageName,
+				fullCommand: [
+					COMMAND_UV,
+					ARG_TOOL,
+					ARG_INSTALL,
+					packageName
+				]
+			};
+		}
+		return null;
+	}
+	/**
+	* Extract package name from npx command args
+	* @param args - Command arguments
+	* @returns Package name or null
+	* @remarks Handles --package=value, --package value, -p value patterns.
+	*          Falls back to first non-flag argument if no --package/-p flag found.
+	*          Returns null if flag has no value or is followed by another flag.
+	*          When multiple --package flags exist, returns the first valid one.
+	* @example
+	* extractNpxPackage(['--package=@scope/pkg']) // returns '@scope/pkg'
+	* extractNpxPackage(['--package', 'pkg-name']) // returns 'pkg-name'
+	* extractNpxPackage(['-p', 'pkg']) // returns 'pkg'
+	* extractNpxPackage(['-y', 'pkg-name', '--flag']) // returns 'pkg-name' (fallback)
+	* extractNpxPackage(['--package=']) // returns null (empty value)
+	*/
+	extractNpxPackage(args) {
+		for (let i = 0; i < args.length; i++) {
+			const arg = args[i];
+			if (arg.startsWith(FLAG_PACKAGE_LONG + EQUALS_DELIMITER)) return arg.slice(FLAG_PACKAGE_LONG.length + EQUALS_DELIMITER.length) || null;
+			if (arg === FLAG_PACKAGE_LONG && i + 1 < args.length) {
+				const nextArg = args[i + 1];
+				if (!nextArg.startsWith(FLAG_PREFIX)) return nextArg;
+			}
+			if (arg === FLAG_PACKAGE_SHORT && i + 1 < args.length) {
+				const nextArg = args[i + 1];
+				if (!nextArg.startsWith(FLAG_PREFIX)) return nextArg;
+			}
+		}
+		for (const arg of args) {
+			if (arg.startsWith(FLAG_PREFIX)) continue;
+			return arg;
+		}
+		return null;
+	}
+	/**
+	* Extract package name from uvx command args
+	* @param args - Command arguments
+	* @returns Package name or null
+	* @remarks Assumes the first non-flag argument is the package name.
+	*          Handles both single (-) and double (--) dash flags.
+	* @example
+	* extractUvxPackage(['mcp-server-fetch']) // returns 'mcp-server-fetch'
+	* extractUvxPackage(['--quiet', 'pkg-name']) // returns 'pkg-name'
+	*/
+	extractUvxPackage(args) {
+		for (const arg of args) {
+			if (arg.startsWith(FLAG_PREFIX)) continue;
+			return arg;
+		}
+		return null;
+	}
+	/**
+	* Extract package name from uv run command args
+	* @param args - Command arguments
+	* @returns Package name or null
+	* @remarks Looks for the first non-flag argument after the 'run' subcommand.
+	*          Returns null if 'run' is not found in args.
+	* @example
+	* extractUvRunPackage(['run', 'mcp-server']) // returns 'mcp-server'
+	* extractUvRunPackage(['run', '--verbose', 'pkg']) // returns 'pkg'
+	* extractUvRunPackage(['install', 'pkg']) // returns null (no 'run')
+	*/
+	extractUvRunPackage(args) {
+		const runIndex = args.indexOf(ARG_RUN);
+		if (runIndex === -1) return null;
+		for (let i = runIndex + 1; i < args.length; i++) {
+			const arg = args[i];
+			if (arg.startsWith(FLAG_PREFIX)) continue;
+			return arg;
+		}
+		return null;
+	}
+	/**
+	* Run a shell command and capture output
+	* @param command - Command to run
+	* @param args - Command arguments
+	* @returns Promise with success status and output
+	*/
+	runCommand(command, args) {
+		return new Promise((resolve$1) => {
+			const proc = spawn(command, args, {
+				stdio: [
+					STDIO_IGNORE,
+					STDIO_PIPE,
+					STDIO_PIPE
+				],
+				shell: process.platform === PLATFORM_WIN32
+			});
+			let stdout = "";
+			let stderr = "";
+			proc.stdout?.on("data", (data) => {
+				stdout += data.toString();
+			});
+			proc.stderr?.on("data", (data) => {
+				stderr += data.toString();
+			});
+			proc.on("close", (code) => {
+				resolve$1({
+					success: code === EXIT_CODE_SUCCESS,
+					output: stdout || stderr
+				});
+			});
+			proc.on("error", (error) => {
+				resolve$1({
+					success: false,
+					output: error.message
+				});
+			});
+		});
+	}
+};
+
+//#endregion
+//#region src/commands/prefetch.ts
+/**
+* Prefetch 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
+*/
+/**
+* Pre-download packages used by MCP servers (npx, pnpx, uvx, uv)
+*/
+const prefetchCommand = new 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").action(async (options) => {
+	try {
+		const configFilePath = options.config || findConfigFile();
+		if (!configFilePath) {
+			print.error("No MCP configuration file found.");
+			print.info("Use --config <path> to specify a config file, or run \"one-mcp init\" to create one.");
+			process.exit(1);
+		}
+		print.info(`Loading configuration from: ${configFilePath}`);
+		const prefetchService = new PrefetchService({
+			mcpConfig: await new ConfigFetcherService({
+				configFilePath,
+				useCache: false
+			}).fetchConfiguration(true),
+			filter: options.filter,
+			parallel: options.parallel
+		});
+		const packages = prefetchService.extractPackages();
+		if (packages.length === 0) {
+			print.warning("No packages found to prefetch.");
+			print.info("Prefetch supports: npx, pnpx, uvx, and uv run commands");
+			return;
+		}
+		print.info(`Found ${packages.length} package(s) to prefetch:`);
+		for (const pkg of packages) print.item(`${pkg.serverName}: ${pkg.packageManager} ${pkg.packageName}`);
+		if (options.dryRun) {
+			print.newline();
+			print.header("Dry run mode - commands that would be executed:");
+			for (const pkg of packages) print.indent(pkg.fullCommand.join(" "));
+			return;
+		}
+		print.newline();
+		print.info("Prefetching packages...");
+		const summary = await prefetchService.prefetch();
+		print.newline();
+		if (summary.failed === 0) print.success(`Prefetch complete: ${summary.successful} succeeded, ${summary.failed} failed`);
+		else print.warning(`Prefetch complete: ${summary.successful} succeeded, ${summary.failed} failed`);
+		if (summary.failed > 0) {
+			print.newline();
+			print.error("Failed packages:");
+			for (const result of summary.results.filter((r) => !r.success)) print.item(`${result.package.serverName} (${result.package.packageName}): ${result.output.trim()}`);
+			process.exit(1);
+		}
+	} catch (error) {
+		print.error("Error executing prefetch:", error instanceof Error ? error.message : String(error));
+		process.exit(1);
+	}
+});
+
 //#endregion
 //#region package.json
-var version = "0.2.6";
+var version = "0.3.0";
 
 //#endregion
 //#region src/cli.ts
@@ -574,16 +1029,25 @@ var version = "0.2.6";
 * 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);
+	try {
+		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);
+		program.addCommand(prefetchCommand);
+		await program.parseAsync(process.argv);
+	} catch (error) {
+		console.error(`CLI execution failed: ${error instanceof Error ? error.message : error}`);
+		process.exit(1);
+	}
 }
-main();
+main().catch((error) => {
+	console.error(`Fatal error: ${error instanceof Error ? error.message : error}`);
+	process.exit(1);
+});
 
 //#endregion
 export {  };