@agiflowai/one-mcp 0.2.7 → 0.2.8

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-DeUYygKb.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), {
@@ -146,14 +148,27 @@ const listToolsCommand = new Command("list-tools").description("List all availab
 			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] = [];
+		const toolResults = await Promise.all(clients.map(async (client) => {
+			try {
+				const tools = await client.listTools();
+				const blacklist = new Set(client.toolBlacklist || []);
+				const filteredTools = tools.filter((t) => !blacklist.has(t.name));
+				return {
+					serverName: client.serverName,
+					tools: filteredTools,
+					error: null
+				};
+			} catch (error) {
+				return {
+					serverName: client.serverName,
+					tools: [],
+					error
+				};
+			}
+		}));
+		for (const { serverName, tools, error } of toolResults) {
+			if (error && !options.json) console.error(`Failed to list tools from ${serverName}:`, error);
+			toolsByServer[serverName] = tools;
 		}
 		if (options.json) console.log(JSON.stringify(toolsByServer, null, 2));
 		else for (const [serverName, tools] of Object.entries(toolsByServer)) {
@@ -227,43 +242,60 @@ const describeToolsCommand = new Command("describe-tools").description("Describe
 		const foundTools = [];
 		const foundSkills = [];
 		const notFoundTools = [...toolNames];
-		for (const client of clients) {
-			if (options.server && client.serverName !== options.server) continue;
+		const filteredClients = clients.filter((client) => !options.server || client.serverName === options.server);
+		const toolResults = await Promise.all(filteredClients.map(async (client) => {
 			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);
-					}
-				}
+				return {
+					client,
+					tools: await client.listTools(),
+					error: null
+				};
 			} catch (error) {
+				return {
+					client,
+					tools: [],
+					error
+				};
+			}
+		}));
+		for (const { client, tools, error } of toolResults) {
+			if (error) {
 				if (!options.json) console.error(`Failed to list tools from ${client.serverName}:`, error);
+				continue;
 			}
-		}
-		if (skillService && notFoundTools.length > 0) {
-			const skillsToCheck = [...notFoundTools];
-			for (const toolName of skillsToCheck) {
-				const skillName = toolName.startsWith("skill__") ? toolName.slice(7) : toolName;
-				const skill = await skillService.getSkill(skillName);
-				if (skill) {
-					foundSkills.push({
-						name: skill.name,
-						location: skill.basePath,
-						instructions: skill.content
+			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);
 				}
 			}
 		}
+		if (skillService && notFoundTools.length > 0) {
+			const skillsToCheck = [...notFoundTools];
+			const skillResults = await Promise.all(skillsToCheck.map(async (toolName) => {
+				const skillName = toolName.startsWith("skill__") ? toolName.slice(7) : toolName;
+				return {
+					toolName,
+					skill: await skillService.getSkill(skillName)
+				};
+			}));
+			for (const { toolName, skill } of skillResults) if (skill) {
+				foundSkills.push({
+					name: skill.name,
+					location: skill.basePath,
+					instructions: skill.content
+				});
+				const idx = notFoundTools.indexOf(toolName);
+				if (idx > -1) notFoundTools.splice(idx, 1);
+			}
+		}
 		const nextSteps = [];
 		if (foundTools.length > 0) nextSteps.push("For MCP tools: Use the use_tool function with toolName and toolArgs based on the inputSchema above.");
 		if (foundSkills.length > 0) nextSteps.push(`For skill, just follow skill's description to continue.`);
@@ -396,11 +428,29 @@ const useToolCommand = new Command("use-tool").description("Execute an MCP tool
 				process.exit(1);
 			}
 		}
+		const searchResults = await Promise.all(clients.map(async (client$1) => {
+			try {
+				const hasTool = (await client$1.listTools()).some((t) => t.name === toolName);
+				return {
+					serverName: client$1.serverName,
+					hasTool,
+					error: null
+				};
+			} catch (error) {
+				return {
+					serverName: client$1.serverName,
+					hasTool: false,
+					error
+				};
+			}
+		}));
 		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);
+		for (const { serverName, hasTool, error } of searchResults) {
+			if (error) {
+				if (!options.json) console.error(`Failed to list tools from ${serverName}:`, error);
+				continue;
+			}
+			if (hasTool) matchingServers.push(serverName);
 		}
 		if (matchingServers.length === 0) {
 			const cwd = process.env.PROJECT_PATH || process.cwd();
@@ -546,9 +596,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.2";
 
 //#endregion
 //#region src/cli.ts
@@ -574,16 +1077,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 {  };