padrone 1.4.0 → 1.5.0

package/dist/index.mjs

@@ -1,116 +1,8 @@
-import { a as parsePositionalConfig, i as extractSchemaMetadata, n as coerceArgs, o as parseStdinConfig, r as detectUnknownArgs, s as preprocessArgs } from "./args-CVDbyyzG.mjs";
-import { C as getVersion, S as resolveStdin, _ as thenMaybe, a as commandSymbol, b as REPL_SIGINT, c as hasInteractiveConfig, d as mergeCommands, f as noop, g as suggestSimilar, h as runPluginChain, i as buildReplCompleter, l as isAsyncBranded, m as repathCommandTree, o as findCommandByName, p as outputValue, r as asyncSchema, s as getCommandRuntime, t as generateHelp, u as makeThenable, v as warnIfUnexpectedAsync, x as createTerminalReplSession, y as wrapWithLifecycle } from "./help-CcBe91bV.mjs";
-//#region src/errors.ts
-/**
-* Base error class for all Padrone errors.
-* Carries structured metadata for user-friendly formatting and programmatic handling.
-*
-* @example
-* ```ts
-* throw new PadroneError('Something went wrong', {
-*   exitCode: 1,
-*   suggestions: ['Try --help for usage information'],
-* });
-* ```
-*/
-var PadroneError = class extends Error {
-	exitCode;
-	suggestions;
-	command;
-	phase;
-	constructor(message, options) {
-		super(message, options?.cause ? { cause: options.cause } : void 0);
-		this.name = "PadroneError";
-		this.exitCode = options?.exitCode ?? 1;
-		this.suggestions = options?.suggestions ?? [];
-		this.command = options?.command;
-		this.phase = options?.phase;
-	}
-	/**
-	* Returns a serializable representation of the error,
-	* suitable for non-terminal runtimes (web UIs, APIs, etc.).
-	*/
-	toJSON() {
-		return {
-			name: this.name,
-			message: this.message,
-			exitCode: this.exitCode,
-			suggestions: this.suggestions,
-			command: this.command,
-			phase: this.phase
-		};
-	}
-};
-/**
-* Thrown when command routing fails — unknown command, unexpected arguments, etc.
-*/
-var RoutingError = class extends PadroneError {
-	constructor(message, options) {
-		super(message, {
-			phase: "parse",
-			...options
-		});
-		this.name = "RoutingError";
-	}
-};
-/**
-* Thrown when argument or schema validation fails.
-* Carries the structured issues from the schema validator.
-*/
-var ValidationError = class extends PadroneError {
-	issues;
-	constructor(message, issues, options) {
-		super(message, {
-			phase: "validate",
-			...options
-		});
-		this.name = "ValidationError";
-		this.issues = issues;
-	}
-	toJSON() {
-		return {
-			...super.toJSON(),
-			issues: this.issues.map((i) => ({
-				path: i.path?.map(String),
-				message: i.message
-			}))
-		};
-	}
-};
-/**
-* Thrown when config file loading or validation fails.
-*/
-var ConfigError = class extends PadroneError {
-	constructor(message, options) {
-		super(message, {
-			phase: "config",
-			...options
-		});
-		this.name = "ConfigError";
-	}
-};
-/**
-* Thrown from user action handlers to surface structured errors with exit codes and suggestions.
-* This is the primary error class users should throw from their command actions.
-*
-* @example
-* ```ts
-* throw new ActionError('Missing environment', {
-*   exitCode: 1,
-*   suggestions: ['Use --env production or --env staging'],
-* });
-* ```
-*/
-var ActionError = class extends PadroneError {
-	constructor(message, options) {
-		super(message, {
-			phase: "execute",
-			...options
-		});
-		this.name = "ActionError";
-	}
-};
-//#endregion
+import { r as colorThemes, t as generateHelp } from "./help-bbmu9-qd.mjs";
+import { r as createStdinStream, t as asyncStream } from "./stream-BcC146Ud.mjs";
+import { a as extractSchemaMetadata, c as parsePositionalConfig, i as detectUnknownArgs, l as parseStdinConfig, o as isArrayField, r as coerceArgs, s as isAsyncStreamField, t as JSON_SCHEMA_OPTS, u as preprocessArgs } from "./args-D5PNDyNu.mjs";
+import { A as withDrain, C as resolveCommand, D as suggestSimilar, F as resolveStdin, I as resolveStdinAlways, M as wrapWithLifecycle, N as REPL_SIGINT, O as thenMaybe, P as createTerminalReplSession, R as getVersion, S as resolveAllCommands, T as runPluginChain, _ as mergeCommands, a as commandSymbol, b as outputValue, c as createProgress, f as getCommandRuntime, g as makeThenable, h as lazyResolver, j as withPromiseDrain, k as warnIfUnexpectedAsync, l as errorResult, m as isAsyncBranded, p as hasInteractiveConfig, r as buildReplCompleter, s as createLazyIndicator, t as asyncSchema, u as findCommandByName, v as noop, w as resolveProgressMessage, x as repathCommandTree, y as noopIndicator } from "./command-utils-B1D-HqCd.mjs";
+import { a as ValidationError, i as RoutingError, n as ConfigError, r as PadroneError, t as ActionError } from "./errors-BiVrBgi6.mjs";
 //#region src/interactive.ts
 /**
 * Auto-detect the prompt type for a field based on its JSON schema property definition.
@@ -162,6 +54,34 @@ function detectPromptConfig(name, propSchema, description) {
 	};
 }
 /**
+* Prompt a single field and validate it against the command's schema.
+* Re-prompts with a warning until the user provides a valid value.
+*/
+async function promptWithValidation(field, config, currentData, command, runtime) {
+	let promptConfig = config;
+	while (true) {
+		const value = await runtime.prompt(promptConfig);
+		if (!command.argsSchema) return value;
+		const testData = {
+			...currentData,
+			[field]: value
+		};
+		const validated = await command.argsSchema["~standard"].validate(testData);
+		if (!validated.issues) return value;
+		const fieldIssues = validated.issues.filter((issue) => {
+			const rootKey = issue.path?.[0];
+			return rootKey !== void 0 && String(rootKey) === field;
+		});
+		if (fieldIssues.length === 0) return value;
+		const messages = fieldIssues.map((i) => i.message).join("; ");
+		runtime.error(`Invalid value for "${field}": ${messages}`);
+		promptConfig = {
+			...config,
+			default: value
+		};
+	}
+}
+/**
 * Prompt for missing interactive fields.
 * Runs after env/config preprocessing and before schema validation.
 *
@@ -177,7 +97,7 @@ async function promptInteractiveFields(data, command, runtime, force) {
 	let jsonProperties = {};
 	let requiredFields = /* @__PURE__ */ new Set();
 	if (command.argsSchema) try {
-		const jsonSchema = command.argsSchema["~standard"].jsonSchema.input({ target: "draft-2020-12" });
+		const jsonSchema = command.argsSchema["~standard"].jsonSchema.input(JSON_SCHEMA_OPTS);
 		if (jsonSchema.type === "object" && jsonSchema.properties) jsonProperties = jsonSchema.properties;
 		if (Array.isArray(jsonSchema.required)) requiredFields = new Set(jsonSchema.required);
 	} catch {}
@@ -194,7 +114,7 @@ async function promptInteractiveFields(data, command, runtime, force) {
 	for (const field of fieldsToPrompt) {
 		const config = detectPromptConfig(field, jsonProperties[field], fieldDescriptions[field]);
 		if (force && result[field] !== void 0) config.default = result[field];
-		result[field] = await runtime.prompt(config);
+		result[field] = await promptWithValidation(field, config, result, command, runtime);
 	}
 	let optionalFields = [];
 	if (optionalInteractiveConfig === true) if (force) optionalFields = Object.keys(jsonProperties).filter((name) => !requiredFields.has(name));
@@ -218,7 +138,7 @@ async function promptInteractiveFields(data, command, runtime, force) {
 		if (Array.isArray(selected)) for (const field of selected) {
 			const config = detectPromptConfig(field, jsonProperties[field], fieldDescriptions[field]);
 			if (force && result[field] !== void 0) config.default = result[field];
-			result[field] = await runtime.prompt(config);
+			result[field] = await promptWithValidation(field, config, result, command, runtime);
 		}
 	}
 	return result;
@@ -607,7 +527,10 @@ function createReplIterator(deps, options) {
 				const scopedInput = scopePath ? evalInput ? `${scopePath} ${evalInput}` : scopePath : evalInput;
 				try {
 					const result = await evalCommand(scopedInput, options?.autoOutput === false ? { autoOutput: false } : void 0);
-					if (result.argsResult?.issues) {
+					if (result.error) {
+						const msg = result.error instanceof Error ? result.error.message : String(result.error);
+						runtime.error(prefixLines ? prefixLines(msg) : msg);
+					} else if (result.argsResult?.issues) {
 						const msg = `Validation error:\n${result.argsResult.issues.map((i) => `  - ${i.path?.join(".") || "root"}: ${i.message}`).join("\n")}`;
 						runtime.error(prefixLines ? prefixLines(msg) : msg);
 					}
@@ -625,7 +548,17 @@ function createReplIterator(deps, options) {
 			session?.close();
 		}
 	}
-	return replIterator();
+	const iterable = replIterator();
+	iterable.drain = async () => {
+		try {
+			const results = [];
+			for await (const result of iterable) results.push(result);
+			return { value: results };
+		} catch (err) {
+			return { error: err };
+		}
+	};
+	return iterable;
 }
 //#endregion
 //#region src/wrap.ts
@@ -672,30 +605,30 @@ function createWrapHandler(config, commandArguments, commandPositional) {
 		};
 		const regularArgs = argsToCliArgs(validationResult instanceof Promise ? await validationResult.then(processResult) : processResult(validationResult), positional);
 		const allArgs = [...fixedArgs, ...regularArgs];
-		const proc = Bun.spawn([command, ...allArgs], {
-			stdout: inheritStdio ? "inherit" : "pipe",
-			stderr: inheritStdio ? "inherit" : "pipe",
-			stdin: inheritStdio ? "inherit" : "ignore"
-		});
-		const exitCode = await proc.exited;
-		let stdout;
-		let stderr;
-		if (!inheritStdio) {
-			if (proc.stdout) {
-				const stdoutBuffer = await new Response(proc.stdout).arrayBuffer();
-				stdout = new TextDecoder().decode(stdoutBuffer);
+		const { spawn } = await import("node:child_process");
+		return new Promise((resolve, reject) => {
+			const proc = spawn(command, allArgs, { stdio: inheritStdio ? "inherit" : [
+				"ignore",
+				"pipe",
+				"pipe"
+			] });
+			const stdoutChunks = [];
+			const stderrChunks = [];
+			if (!inheritStdio) {
+				proc.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
+				proc.stderr.on("data", (chunk) => stderrChunks.push(chunk));
 			}
-			if (proc.stderr) {
-				const stderrBuffer = await new Response(proc.stderr).arrayBuffer();
-				stderr = new TextDecoder().decode(stderrBuffer);
-			}
-		}
-		return {
-			exitCode,
-			stdout,
-			stderr,
-			success: exitCode === 0
-		};
+			proc.on("error", reject);
+			proc.on("close", (code) => {
+				const exitCode = code ?? 1;
+				resolve({
+					exitCode,
+					stdout: inheritStdio ? void 0 : Buffer.concat(stdoutChunks).toString(),
+					stderr: inheritStdio ? void 0 : Buffer.concat(stderrChunks).toString(),
+					success: exitCode === 0
+				});
+			});
+		});
 	};
 }
 //#endregion
@@ -716,11 +649,14 @@ function createPadroneBuilder(inputCommand) {
 		} : c)
 	} : inputCommand;
 	/** Creates the action context passed to command handlers. References `builder` which is defined later but only called at runtime. */
-	const createActionContext = (cmd) => ({
-		runtime: getCommandRuntime(cmd),
-		command: cmd,
-		program: builder
-	});
+	const createActionContext = (cmd) => {
+		return {
+			runtime: getCommandRuntime(cmd),
+			command: cmd,
+			program: builder,
+			progress: noopIndicator
+		};
+	};
 	const find = (command) => {
 		if (typeof command !== "string") return findCommandByName(command.path, existingCommand.commands);
 		return findCommandByName(command, existingCommand.commands);
@@ -777,7 +713,7 @@ function createPadroneBuilder(inputCommand) {
 		};
 		const arrayArguments = /* @__PURE__ */ new Set();
 		if (curCommand.argsSchema) try {
-			const jsonSchema = curCommand.argsSchema["~standard"].jsonSchema.input({ target: "draft-2020-12" });
+			const jsonSchema = curCommand.argsSchema["~standard"].jsonSchema.input(JSON_SCHEMA_OPTS);
 			if (jsonSchema.type === "object" && jsonSchema.properties) {
 				for (const [key, prop] of Object.entries(jsonSchema.properties)) if (prop?.type === "array") arrayArguments.add(key);
 			}
@@ -919,11 +855,17 @@ function createPadroneBuilder(inputCommand) {
 				const readStdinForParse = () => {
 					const stdinConfig = command.meta?.stdin;
 					if (!stdinConfig) return {};
-					const { field, as } = parseStdinConfig(stdinConfig);
+					const field = parseStdinConfig(stdinConfig);
 					if (field in validateCtx.rawArgs && validateCtx.rawArgs[field] !== void 0) return {};
-					const stdin = resolveStdin(getCommandRuntime(existingCommand));
+					const runtime = getCommandRuntime(existingCommand);
+					const streamInfo = isAsyncStreamField(command.argsSchema, field);
+					if (streamInfo) {
+						const stdinForStream = resolveStdinAlways(runtime);
+						return { [field]: createStdinStream(stdinForStream, streamInfo.itemSchema) };
+					}
+					const stdin = resolveStdin(runtime);
 					if (!stdin) return {};
-					if (as === "lines") return (async () => {
+					if (isArrayField(command.argsSchema, field)) return (async () => {
 						const lines = [];
 						for await (const line of stdin.lines()) lines.push(line);
 						return { [field]: lines };
@@ -1015,11 +957,13 @@ function createPadroneBuilder(inputCommand) {
 		const hasHelpFlag = args.some((p) => p.type === "named" && keyIs(p.key, "help") || p.type === "alias" && keyIs(p.key, "h"));
 		const getDetailLevel = () => {
 			for (const arg of args) {
-				if (arg.type === "named" && keyIs(arg.key, "detail") && typeof arg.value === "string") {
-					if (arg.value === "minimal" || arg.value === "standard" || arg.value === "full") return arg.value;
+				if (arg.type === "named" && keyIs(arg.key, "detail")) {
+					if (typeof arg.value === "string" && (arg.value === "minimal" || arg.value === "standard" || arg.value === "full")) return arg.value;
+					return "full";
 				}
-				if (arg.type === "alias" && keyIs(arg.key, "d") && typeof arg.value === "string") {
-					if (arg.value === "minimal" || arg.value === "standard" || arg.value === "full") return arg.value;
+				if (arg.type === "alias" && keyIs(arg.key, "d")) {
+					if (typeof arg.value === "string" && (arg.value === "minimal" || arg.value === "standard" || arg.value === "full")) return arg.value;
+					return "full";
 				}
 			}
 		};
@@ -1044,6 +988,7 @@ function createPadroneBuilder(inputCommand) {
 			}
 		};
 		const format = getFormat();
+		const hasAllFlag = args.some((p) => p.type === "named" && keyIs(p.key, "all"));
 		const hasVersionFlag = args.some((p) => p.type === "named" && keyIs(p.key, "version") || p.type === "alias" && (keyIs(p.key, "v") || keyIs(p.key, "V")));
 		const normalizedTerms = [...terms];
 		if (normalizedTerms[0] === existingCommand.name) normalizedTerms.shift();
@@ -1056,7 +1001,8 @@ function createPadroneBuilder(inputCommand) {
 				type: "help",
 				command: commandName ? findCommandByName(commandName, existingCommand.commands) : void 0,
 				detail,
-				format
+				format,
+				all: hasAllFlag || void 0
 			};
 		}
 		if (!userHelpCommand && normalizedTerms.length > 0 && normalizedTerms[normalizedTerms.length - 1] === "help") {
@@ -1074,7 +1020,8 @@ function createPadroneBuilder(inputCommand) {
 				type: "help",
 				command: targetCommand,
 				detail,
-				format
+				format,
+				all: hasAllFlag || void 0
 			};
 		}
 		if (!userVersionCommand && normalizedTerms[0] === "version") return { type: "version" };
@@ -1091,16 +1038,53 @@ function createPadroneBuilder(inputCommand) {
 				setup: args.some((p) => p.type === "named" && keyIs(p.key, "setup"))
 			};
 		}
+		if (!findCommandByName("man", existingCommand.commands) && normalizedTerms[0] === "man") return {
+			type: "man",
+			setup: args.some((p) => p.type === "named" && keyIs(p.key, "setup")),
+			remove: args.some((p) => p.type === "named" && keyIs(p.key, "remove"))
+		};
 		if (hasHelpFlag) {
 			const commandName = normalizedTerms.filter((t) => t !== "help").join(" ");
 			return {
 				type: "help",
 				command: commandName ? findCommandByName(commandName, existingCommand.commands) : void 0,
 				detail,
-				format
+				format,
+				all: hasAllFlag || void 0
 			};
 		}
 		if (hasVersionFlag && normalizedTerms.length === 0) return { type: "version" };
+		if (!findCommandByName("mcp", existingCommand.commands) && normalizedTerms[0] === "mcp") {
+			const transportArg = normalizedTerms[1];
+			const transport = transportArg === "stdio" || transportArg === "http" ? transportArg : void 0;
+			const portArg = args.find((p) => p.type === "named" && keyIs(p.key, "port"));
+			const port = typeof portArg?.value === "string" ? parseInt(portArg.value, 10) : void 0;
+			const hostArg = args.find((p) => p.type === "named" && keyIs(p.key, "host"));
+			const host = typeof hostArg?.value === "string" ? hostArg.value : void 0;
+			const basePathArg = args.find((p) => p.type === "named" && keyIs(p.key, "base-path"));
+			const mcpBasePath = typeof basePathArg?.value === "string" ? basePathArg.value : void 0;
+			return {
+				type: "mcp",
+				transport,
+				port: port && !Number.isNaN(port) ? port : void 0,
+				host,
+				basePath: mcpBasePath
+			};
+		}
+		if (!findCommandByName("serve", existingCommand.commands) && normalizedTerms[0] === "serve") {
+			const portArg = args.find((p) => p.type === "named" && keyIs(p.key, "port"));
+			const port = typeof portArg?.value === "string" ? parseInt(portArg.value, 10) : void 0;
+			const hostArg = args.find((p) => p.type === "named" && keyIs(p.key, "host"));
+			const host = typeof hostArg?.value === "string" ? hostArg.value : void 0;
+			const basePathArg = args.find((p) => p.type === "named" && keyIs(p.key, "base-path"));
+			const basePath = typeof basePathArg?.value === "string" ? basePathArg.value : void 0;
+			return {
+				type: "serve",
+				port: port && !Number.isNaN(port) ? port : void 0,
+				host,
+				basePath
+			};
+		}
 		if (args.some((p) => p.type === "named" && keyIs(p.key, "repl"))) return {
 			type: "repl",
 			scope: normalizedTerms.length > 0 ? normalizedTerms.join(" ") : void 0
@@ -1119,6 +1103,28 @@ function createPadroneBuilder(inputCommand) {
 		}
 	};
 	/**
+	* Extract --color flag from input.
+	* - `--color` or `--color=true` → use default theme
+	* - `--color=false` or `--no-color` → disable colors (text format)
+	* - `--color=<theme>` → use the named theme
+	* Returns `undefined` if no --color flag is present.
+	*/
+	const extractColorFlag = (input) => {
+		if (!input) return void 0;
+		const args = parseCliInputToParts(input).filter((p) => p.type === "named");
+		const keyIs = (key, name) => key.length === 1 && key[0] === name;
+		for (const arg of args) {
+			if (arg.type === "named" && keyIs(arg.key, "no-color")) return { disableColor: true };
+			if (arg.type === "named" && keyIs(arg.key, "color")) {
+				if (arg.negated) return { disableColor: true };
+				if (arg.value === void 0 || arg.value === "true") return { theme: "default" };
+				if (arg.value === "false") return { disableColor: true };
+				if (typeof arg.value === "string" && arg.value in colorThemes) return { theme: arg.value };
+				return;
+			}
+		}
+	};
+	/**
 	* Core execution logic shared by eval() and cli().
 	* errorMode controls validation error behavior:
 	* - 'soft': return result with issues (eval behavior)
@@ -1126,51 +1132,97 @@ function createPadroneBuilder(inputCommand) {
 	*/
 	const execCommand = (resolvedInput, evalOptions, errorMode = "soft") => {
 		const baseRuntime = getCommandRuntime(existingCommand);
-		const runtime = evalOptions?.runtime ? Object.assign({}, baseRuntime, Object.fromEntries(Object.entries(evalOptions.runtime).filter(([, v]) => v !== void 0))) : baseRuntime;
+		let runtime = evalOptions?.runtime ? Object.assign({}, baseRuntime, Object.fromEntries(Object.entries(evalOptions.runtime).filter(([, v]) => v !== void 0))) : baseRuntime;
+		const colorFlag = extractColorFlag(resolvedInput);
+		if (colorFlag) runtime = {
+			...runtime,
+			...colorFlag.disableColor ? {
+				format: "text",
+				theme: void 0
+			} : { theme: colorFlag.theme }
+		};
 		const builtin = checkBuiltinCommands(resolvedInput);
 		if (builtin) {
 			if (builtin.type === "help") {
+				resolveAllCommands(existingCommand);
 				const helpText = generateHelp(existingCommand, builtin.command ?? existingCommand, {
 					detail: builtin.detail,
-					format: builtin.format ?? runtime.format
+					format: builtin.format ?? runtime.format,
+					theme: runtime.theme,
+					all: builtin.all
 				});
 				runtime.output(helpText);
-				return {
+				return withDrain({
 					command: existingCommand,
 					args: void 0,
 					result: helpText
-				};
+				});
 			}
 			if (builtin.type === "version") {
 				const version = getVersion(existingCommand.version);
 				runtime.output(version);
-				return {
+				return withDrain({
 					command: existingCommand,
 					args: void 0,
 					result: version
-				};
+				});
 			}
-			if (builtin.type === "completion") return import("./completion.mjs").then(({ detectShell, generateCompletionOutput, setupCompletions }) => {
-				if (builtin.setup) {
-					const shell = builtin.shell ?? detectShell();
-					if (!shell) throw new Error("Could not detect shell. Specify one: completion bash --setup");
-					const result = setupCompletions(existingCommand.name, shell);
-					const message = `${result.updated ? "Updated" : "Added"} ${existingCommand.name} completions in ${result.file}`;
-					runtime.output(message);
-					return {
+			if (builtin.type === "completion") {
+				resolveAllCommands(existingCommand);
+				return import("./completion.mjs").then(({ detectShell, generateCompletionOutput, setupCompletions }) => {
+					if (builtin.setup) {
+						const shell = builtin.shell ?? detectShell();
+						if (!shell) throw new Error("Could not detect shell. Specify one: completion bash --setup");
+						const result = setupCompletions(existingCommand.name, shell);
+						const message = `${result.updated ? "Updated" : "Added"} ${existingCommand.name} completions in ${result.file}`;
+						runtime.output(message);
+						return withDrain({
+							command: existingCommand,
+							args: void 0,
+							result: message
+						});
+					}
+					const completionScript = generateCompletionOutput(existingCommand, builtin.shell);
+					runtime.output(completionScript);
+					return withDrain({
 						command: existingCommand,
 						args: void 0,
-						result: message
-					};
-				}
-				const completionScript = generateCompletionOutput(existingCommand, builtin.shell);
-				runtime.output(completionScript);
-				return {
-					command: existingCommand,
-					args: void 0,
-					result: completionScript
-				};
-			});
+						result: completionScript
+					});
+				});
+			}
+			if (builtin.type === "man") {
+				resolveAllCommands(existingCommand);
+				return import("./docs/index.mjs").then(({ setupManPages, removeManPages, generateDocs }) => {
+					if (builtin.setup) {
+						const result = setupManPages(existingCommand);
+						const message = `${result.updated ? "Updated" : "Installed"} ${result.written.length} man page(s) in ${result.dir}`;
+						runtime.output(message);
+						return withDrain({
+							command: existingCommand,
+							args: void 0,
+							result: message
+						});
+					}
+					if (builtin.remove) {
+						const result = removeManPages(existingCommand);
+						const message = result.removed.length > 0 ? `Removed ${result.removed.length} man page(s) from ${result.dir}` : "No man pages found to remove.";
+						runtime.output(message);
+						return withDrain({
+							command: existingCommand,
+							args: void 0,
+							result: message
+						});
+					}
+					const manPage = generateDocs(existingCommand, { format: "man" }).pages[0]?.content ?? "";
+					runtime.output(manPage);
+					return withDrain({
+						command: existingCommand,
+						args: void 0,
+						result: manPage
+					});
+				});
+			}
 		}
 		const state = {};
 		const rootPlugins = existingCommand.plugins ?? [];
@@ -1185,7 +1237,11 @@ function createPadroneBuilder(inputCommand) {
 				const hasSubcommands = command.commands && command.commands.length > 0;
 				const hasSchema = command.argsSchema != null;
 				if (!command.action && (hasSubcommands || !hasSchema) && unmatchedTerms.length === 0) {
-					const helpText = generateHelp(existingCommand, command, { format: runtime.format });
+					resolveAllCommands(existingCommand);
+					const helpText = generateHelp(existingCommand, command, {
+						format: runtime.format,
+						theme: runtime.theme
+					});
 					runtime.output(helpText);
 					return {
 						command,
@@ -1222,7 +1278,11 @@ function createPadroneBuilder(inputCommand) {
 									runtime.output(`\nAvailable commands: ${cmdList}`);
 								}
 							} else {
-								const helpText = generateHelp(existingCommand, isRootCommand ? existingCommand : command, { format: runtime.format });
+								resolveAllCommands(existingCommand);
+								const helpText = generateHelp(existingCommand, isRootCommand ? existingCommand : command, {
+									format: runtime.format,
+									theme: runtime.theme
+								});
 								runtime.error(helpText);
 							}
 							throw new RoutingError(errorMsg, {
@@ -1251,6 +1311,36 @@ function createPadroneBuilder(inputCommand) {
 					args: void 0,
 					result: parsed.rawArgs["~help"]
 				};
+				const progressConfig = command.progress;
+				if (progressConfig && runtime.progress) {
+					const isObj = typeof progressConfig === "object";
+					const defaultMsg = typeof progressConfig === "string" ? progressConfig : `Running ${command.name}...`;
+					const progressMsg = isObj ? progressConfig.progress ?? defaultMsg : defaultMsg;
+					const validationMsg = isObj ? progressConfig.validation ?? "" : "";
+					state._progressSuccess = isObj ? progressConfig.success : void 0;
+					state._progressError = isObj ? progressConfig.error : void 0;
+					state._progressMsg = progressMsg;
+					state._progressValidationMsg = validationMsg || void 0;
+					const spinnerConfig = isObj ? progressConfig.spinner : void 0;
+					const indicator = createProgress(runtime, validationMsg || progressMsg, spinnerConfig !== void 0 ? { spinner: spinnerConfig } : void 0);
+					state._progress = indicator;
+					const originalOutput = runtime.output;
+					const originalError = runtime.error;
+					runtime.output = (...args) => {
+						indicator.pause();
+						originalOutput(...args);
+						indicator.resume();
+					};
+					runtime.error = (text) => {
+						indicator.pause();
+						originalError(text);
+						indicator.resume();
+					};
+					state._restoreOutput = () => {
+						runtime.output = originalOutput;
+						runtime.error = originalError;
+					};
+				}
 				const validateCtx = {
 					command,
 					rawArgs: parsed.rawArgs,
@@ -1269,6 +1359,8 @@ function createPadroneBuilder(inputCommand) {
 							delete validateCtx.rawArgs.i;
 						}
 					}
+					delete validateCtx.rawArgs.color;
+					delete validateCtx.rawArgs["no-color"];
 					const runtimeDefault = runtime.interactive === "forced" ? true : runtime.interactive === "disabled" ? false : void 0;
 					const effectiveInteractive = flagInteractive ?? evalOptions?.interactive ?? runtimeDefault;
 					const stdinIsPiped = !!command.meta?.stdin && (runtime.stdin ? !runtime.stdin.isTTY : typeof process !== "undefined" && process.stdin?.isTTY !== true);
@@ -1317,11 +1409,16 @@ function createPadroneBuilder(inputCommand) {
 					const readStdin = () => {
 						const stdinConfig = command.meta?.stdin;
 						if (!stdinConfig) return {};
-						const { field, as } = parseStdinConfig(stdinConfig);
+						const field = parseStdinConfig(stdinConfig);
 						if (field in validateCtx.rawArgs && validateCtx.rawArgs[field] !== void 0) return {};
+						const streamInfo = isAsyncStreamField(command.argsSchema, field);
+						if (streamInfo) {
+							const stdinForStream = resolveStdinAlways(runtime);
+							return { [field]: createStdinStream(stdinForStream, streamInfo.itemSchema) };
+						}
 						const stdin = resolveStdin(runtime);
 						if (!stdin) return {};
-						if (as === "lines") return (async () => {
+						if (isArrayField(command.argsSchema, field)) return (async () => {
 							const lines = [];
 							for await (const line of stdin.lines()) lines.push(line);
 							return { [field]: lines };
@@ -1394,7 +1491,7 @@ function createPadroneBuilder(inputCommand) {
 							if (knownOptions) return knownOptions;
 							knownOptions = [];
 							if (command.argsSchema) try {
-								const js = command.argsSchema["~standard"].jsonSchema.input({ target: "draft-2020-12" });
+								const js = command.argsSchema["~standard"].jsonSchema.input(JSON_SCHEMA_OPTS);
 								if (js.type === "object" && js.properties) knownOptions = Object.keys(js.properties);
 							} catch {}
 							return knownOptions;
@@ -1409,7 +1506,11 @@ function createPadroneBuilder(inputCommand) {
 							return base;
 						}).join("\n");
 						if (errorMode === "hard") {
-							const helpText = generateHelp(existingCommand, command, { format: runtime.format });
+							resolveAllCommands(existingCommand);
+							const helpText = generateHelp(existingCommand, command, {
+								format: runtime.format,
+								theme: runtime.theme
+							});
 							runtime.error(`Validation error:\n${issueMessages}`);
 							runtime.error(helpText);
 							throw new ValidationError(`Validation error:\n${issueMessages}`, v.argsResult.issues, {
@@ -1421,13 +1522,15 @@ function createPadroneBuilder(inputCommand) {
 								command: command.path || command.name
 							});
 						}
-						return {
+						return withDrain({
 							command,
 							args: void 0,
 							argsResult: v.argsResult,
 							result: void 0
-						};
+						});
 					}
+					const activeIndicator = state._progress;
+					if (activeIndicator && state._progressMsg && state._progressValidationMsg) activeIndicator.update(state._progressMsg);
 					const executeCtx = {
 						command,
 						args: v.args,
@@ -1435,31 +1538,61 @@ function createPadroneBuilder(inputCommand) {
 					};
 					const coreExecute = () => {
 						const handler = command.action ?? noop;
-						const ctx = evalOptions?.runtime ? {
+						const ctx = {
 							...createActionContext(command),
-							runtime
-						} : createActionContext(command);
+							runtime,
+							progress: state._progress ?? createLazyIndicator(runtime, state)
+						};
 						return { result: handler(executeCtx.args, ctx) };
 					};
 					return thenMaybe(runPluginChain("execute", commandPlugins, executeCtx, coreExecute), (e) => {
-						const commandResult = {
-							command,
-							args: v.args,
-							argsResult: v.argsResult,
-							result: e.result
+						const finalize = (result) => {
+							const indicator = state._progress;
+							if (indicator) {
+								if (!("_progressMsg" in state)) indicator.stop();
+								else {
+									const { message: successMsg, indicator: successIcon } = resolveProgressMessage(state._progressSuccess, result);
+									indicator.succeed(successMsg, successIcon !== void 0 ? { indicator: successIcon } : void 0);
+								}
+								state._restoreOutput?.();
+								state._progress = void 0;
+								state._restoreOutput = void 0;
+							}
+							const commandResult = withDrain({
+								command,
+								args: v.args,
+								argsResult: v.argsResult,
+								result
+							});
+							if (command.autoOutput ?? evalOptions?.autoOutput ?? true) {
+								const outputOrPromise = outputValue(result, runtime.output);
+								if (outputOrPromise instanceof Promise) return outputOrPromise.then(() => commandResult);
+							}
+							return commandResult;
 						};
-						if (command.autoOutput ?? evalOptions?.autoOutput ?? true) {
-							const outputOrPromise = outputValue(e.result, runtime.output);
-							if (outputOrPromise instanceof Promise) return outputOrPromise.then(() => commandResult);
-						}
-						return commandResult;
+						if (e.result instanceof Promise) return e.result.then(finalize, (err) => {
+							const indicator = state._progress;
+							if (indicator) {
+								if (!("_progressMsg" in state)) indicator.stop();
+								else {
+									const fallback = err instanceof Error ? err.message : String(err);
+									const { message: errorMsg, indicator: errorIcon } = resolveProgressMessage(state._progressError, err, fallback);
+									indicator.fail(errorMsg, errorIcon !== void 0 ? { indicator: errorIcon } : void 0);
+								}
+								state._restoreOutput?.();
+								state._progress = void 0;
+								state._restoreOutput = void 0;
+							}
+							throw err;
+						});
+						return finalize(e.result);
 					});
 				};
 				return thenMaybe(warnIfUnexpectedAsync(validatedOrPromise, command), continueAfterValidate);
 			};
 			return thenMaybe(parsedOrPromise, continueAfterParse);
 		};
-		return wrapWithLifecycle(rootPlugins, existingCommand, state, resolvedInput, runPipeline, (result) => ({
+		return wrapWithLifecycle(rootPlugins, existingCommand, state, resolvedInput, runPipeline, (result) => withDrain({
 			command: existingCommand,
 			args: void 0,
 			argsResult: void 0,
@@ -1467,7 +1600,13 @@ function createPadroneBuilder(inputCommand) {
 		}));
 	};
 	const evalCommand = (input, evalOptions) => {
-		return makeThenable(execCommand(input, evalOptions, "soft"));
+		try {
+			const result = execCommand(input, evalOptions, "soft");
+			if (result instanceof Promise) return withPromiseDrain(result.catch((err) => errorResult(err)));
+			return makeThenable(result);
+		} catch (err) {
+			return makeThenable(errorResult(err));
+		}
 	};
 	/**
 	* Collects plugins from the command's parent chain (root → ... → target).
@@ -1490,69 +1629,125 @@ function createPadroneBuilder(inputCommand) {
 		}
 		return chain.flat();
 	};
-	let replFn;
+	const replFn = (options) => {
+		return createReplIterator({
+			existingCommand,
+			evalCommand,
+			replActiveRef
+		}, options);
+	};
 	const replActiveRef = { value: false };
 	const cli = (cliOptions) => {
-		const runtime = getCommandRuntime(existingCommand);
-		const resolvedInput = runtime.argv().join(" ") || void 0;
-		if (cliOptions?.repl !== false) {
+		try {
+			const runtime = getCommandRuntime(existingCommand);
+			const resolvedInput = runtime.argv().join(" ") || void 0;
 			const builtin = checkBuiltinCommands(resolvedInput);
-			if (builtin?.type === "repl") {
-				const replPrefs = {
+			if (cliOptions?.repl !== false && builtin?.type === "repl") {
+				const repl = replFn({
 					...typeof cliOptions?.repl === "object" ? cliOptions.repl : {},
 					scope: builtin.scope,
 					autoOutput: (typeof cliOptions?.repl === "object" ? cliOptions.repl.autoOutput : void 0) ?? cliOptions?.autoOutput
-				};
+				});
 				const drainRepl = async () => {
-					for await (const _ of replFn(replPrefs));
-					return {
+					const { value } = await repl.drain();
+					return withDrain({
+						command: existingCommand,
+						args: void 0,
+						result: value
+					});
+				};
+				return withPromiseDrain(drainRepl());
+			}
+			if (cliOptions?.mcp !== false && builtin?.type === "mcp") {
+				const basePrefs = typeof cliOptions?.mcp === "object" ? cliOptions.mcp : {};
+				const mcpPrefs = {
+					...basePrefs,
+					transport: builtin.transport ?? basePrefs.transport,
+					port: builtin.port ?? basePrefs.port,
+					host: builtin.host ?? basePrefs.host,
+					basePath: builtin.basePath ?? basePrefs.basePath
+				};
+				const startMcp = async () => {
+					const { startMcpServer } = await import("./mcp-mLWIdUIu.mjs");
+					await startMcpServer(builder, existingCommand, evalCommand, mcpPrefs);
+					return withDrain({
 						command: existingCommand,
 						args: void 0,
 						result: void 0
-					};
+					});
 				};
-				return drainRepl();
+				return withPromiseDrain(startMcp());
 			}
-		}
-		let updateCheckPromise;
-		if (existingCommand.updateCheck) {
-			if (!(resolvedInput && parseCliInputToParts(resolvedInput).some((p) => p.type === "named" && p.key.length === 1 && p.key[0] === "no-update-check"))) {
-				const currentVersion = getVersion(existingCommand.version);
-				updateCheckPromise = import("./update-check-EbNDkzyV.mjs").then(({ createUpdateChecker }) => createUpdateChecker(existingCommand.name, currentVersion, existingCommand.updateCheck, runtime));
+			if (cliOptions?.serve !== false && builtin?.type === "serve") {
+				const basePrefs = typeof cliOptions?.serve === "object" ? cliOptions.serve : {};
+				const servePrefs = {
+					...basePrefs,
+					port: builtin.port ?? basePrefs.port,
+					host: builtin.host ?? basePrefs.host,
+					basePath: builtin.basePath ?? basePrefs.basePath
+				};
+				const startServe = async () => {
+					const { startServeServer } = await import("./serve-B0u43DK7.mjs");
+					await startServeServer(builder, existingCommand, evalCommand, servePrefs);
+					return withDrain({
+						command: existingCommand,
+						args: void 0,
+						result: void 0
+					});
+				};
+				return withPromiseDrain(startServe());
 			}
+			let updateCheckPromise;
+			if (existingCommand.updateCheck) {
+				if (!(resolvedInput && parseCliInputToParts(resolvedInput).some((p) => p.type === "named" && p.key.length === 1 && p.key[0] === "no-update-check"))) {
+					const currentVersion = getVersion(existingCommand.version);
+					updateCheckPromise = import("./update-check-CFX1FV3v.mjs").then(({ createUpdateChecker }) => createUpdateChecker(existingCommand.name, currentVersion, existingCommand.updateCheck, runtime));
+				}
+			}
+			const result = execCommand(resolvedInput, cliOptions, "hard");
+			if (updateCheckPromise) {
+				if (result instanceof Promise) return withPromiseDrain(result.then(async (r) => {
+					(await updateCheckPromise)?.();
+					return r;
+				}).catch((err) => errorResult(err)));
+				updateCheckPromise.then((show) => show?.());
+			}
+			if (result instanceof Promise) return withPromiseDrain(result.catch((err) => errorResult(err)));
+			return makeThenable(result);
+		} catch (err) {
+			return makeThenable(errorResult(err));
 		}
-		const result = execCommand(resolvedInput, cliOptions, "hard");
-		if (updateCheckPromise) {
-			if (result instanceof Promise) return result.then(async (r) => {
-				(await updateCheckPromise)?.();
-				return r;
-			});
-			updateCheckPromise.then((show) => show?.());
-		}
-		return makeThenable(result);
 	};
 	const run = (command, args) => {
-		const commandObj = typeof command === "string" ? findCommandByName(command, existingCommand.commands) : command;
-		if (!commandObj) throw new RoutingError(`Command "${command ?? ""}" not found`);
-		if (!commandObj.action) throw new RoutingError(`Command "${commandObj.path}" has no action`, { command: commandObj.path });
-		const executeCtx = {
-			command: commandObj,
-			args,
-			state: {}
-		};
-		const coreExecute = () => {
-			return { result: commandObj.action(executeCtx.args, createActionContext(commandObj)) };
-		};
-		const executedOrPromise = runPluginChain("execute", collectPlugins(commandObj), executeCtx, coreExecute);
-		const toResult = (e) => ({
-			command: commandObj,
-			args,
-			result: e.result
-		});
-		if (executedOrPromise instanceof Promise) return executedOrPromise.then(toResult);
-		return toResult(executedOrPromise);
+		try {
+			const commandObj = typeof command === "string" ? findCommandByName(command, existingCommand.commands) : command;
+			if (!commandObj) throw new RoutingError(`Command "${command ?? ""}" not found`);
+			if (!commandObj.action) throw new RoutingError(`Command "${commandObj.path}" has no action`, { command: commandObj.path });
+			const executeCtx = {
+				command: commandObj,
+				args,
+				state: {}
+			};
+			const coreExecute = () => {
+				return { result: commandObj.action(executeCtx.args, createActionContext(commandObj)) };
+			};
+			const executedOrPromise = runPluginChain("execute", collectPlugins(commandObj), executeCtx, coreExecute);
+			const toResult = (e) => withDrain({
+				command: commandObj,
+				args,
+				result: e.result
+			});
+			if (executedOrPromise instanceof Promise) return executedOrPromise.then(toResult).catch((err) => errorResult(err, {
+				command: commandObj,
+				args
+			}));
+			return toResult(executedOrPromise);
+		} catch (err) {
+			return errorResult(err);
+		}
 	};
 	const tool = () => {
+		resolveAllCommands(existingCommand);
 		const description = `Run a command. Pass the full command string including arguments. Use "help <command>" for detailed usage.\n\n${generateHelp(existingCommand, void 0, { format: "text" })}`;
 		return {
 			type: "function",
@@ -1584,7 +1779,8 @@ function createPadroneBuilder(inputCommand) {
 			needsApproval: async (input) => {
 				const parsed = await parse(input.command);
 				if (typeof parsed.command.needsApproval === "function") return parsed.command.needsApproval(parsed.args);
-				return !!parsed.command.needsApproval;
+				if (parsed.command.needsApproval != null) return !!parsed.command.needsApproval;
+				return !!parsed.command.mutation;
 			},
 			execute: async (input) => {
 				const output = [];
@@ -1657,6 +1853,13 @@ function createPadroneBuilder(inputCommand) {
 				isAsync
 			});
 		},
+		progress(config = true) {
+			const progress = typeof config === "boolean" || typeof config === "string" ? config : { ...config };
+			return createPadroneBuilder({
+				...existingCommand,
+				progress
+			});
+		},
 		action(handler = noop) {
 			const baseHandler = existingCommand.action ?? noop;
 			return createPadroneBuilder({
@@ -1675,6 +1878,7 @@ function createPadroneBuilder(inputCommand) {
 			const name = Array.isArray(nameOrNames) ? nameOrNames[0] : nameOrNames;
 			const aliases = Array.isArray(nameOrNames) && nameOrNames.length > 1 ? nameOrNames.slice(1) : void 0;
 			const existingSubcommand = existingCommand.commands?.find((c) => c.name === name);
+			if (existingSubcommand) resolveCommand(existingSubcommand);
 			const initialCommand = existingSubcommand ? {
 				...existingSubcommand,
 				aliases: aliases ?? existingSubcommand.aliases,
@@ -1686,16 +1890,32 @@ function createPadroneBuilder(inputCommand) {
 				parent: existingCommand,
 				"~types": {}
 			};
-			const builder = createPadroneBuilder(initialCommand);
-			const commandObj = (builderFn?.(builder))?.[commandSymbol] ?? initialCommand;
-			const mergedCommandObj = existingSubcommand ? mergeCommands(existingSubcommand, commandObj) : commandObj;
+			if (builderFn) {
+				const lazyCmd = { ...initialCommand };
+				lazyCmd[lazyResolver] = (target) => {
+					const commandObj = builderFn(createPadroneBuilder(target))?.[commandSymbol] ?? target;
+					const mergedCommandObj = existingSubcommand ? mergeCommands(existingSubcommand, commandObj) : commandObj;
+					Object.assign(target, mergedCommandObj);
+				};
+				const commands = existingCommand.commands || [];
+				const existingIndex = commands.findIndex((c) => c.name === name);
+				const updatedCommands = existingIndex >= 0 ? [
+					...commands.slice(0, existingIndex),
+					lazyCmd,
+					...commands.slice(existingIndex + 1)
+				] : [...commands, lazyCmd];
+				return createPadroneBuilder({
+					...existingCommand,
+					commands: updatedCommands
+				});
+			}
 			const commands = existingCommand.commands || [];
 			const existingIndex = commands.findIndex((c) => c.name === name);
 			const updatedCommands = existingIndex >= 0 ? [
 				...commands.slice(0, existingIndex),
-				mergedCommandObj,
+				initialCommand,
 				...commands.slice(existingIndex + 1)
-			] : [...commands, mergedCommandObj];
+			] : [...commands, initialCommand];
 			return createPadroneBuilder({
 				...existingCommand,
 				commands: updatedCommands
@@ -1741,14 +1961,9 @@ function createPadroneBuilder(inputCommand) {
 		eval: evalCommand,
 		cli,
 		tool,
-		repl: replFn = (options) => {
-			return createReplIterator({
-				existingCommand,
-				evalCommand,
-				replActiveRef
-			}, options);
-		},
+		repl: replFn,
 		api() {
+			resolveAllCommands(existingCommand);
 			function buildApi(command) {
 				const runCommand = ((args) => run(command, args).result);
 				if (!command.commands) return runCommand;
@@ -1758,24 +1973,37 @@ function createPadroneBuilder(inputCommand) {
 			return buildApi(existingCommand);
 		},
 		help(command, prefs) {
+			resolveAllCommands(existingCommand);
 			const commandObj = !command ? existingCommand : typeof command === "string" ? findCommandByName(command, existingCommand.commands) : command;
 			if (!commandObj) throw new RoutingError(`Command "${command ?? ""}" not found`);
 			const runtime = getCommandRuntime(existingCommand);
 			return generateHelp(existingCommand, commandObj, {
 				...prefs,
-				format: prefs?.format ?? runtime.format
+				format: prefs?.format ?? runtime.format,
+				theme: prefs?.theme ?? runtime.theme
 			});
 		},
 		async completion(shell) {
+			resolveAllCommands(existingCommand);
 			const { generateCompletionOutput } = await import("./completion.mjs");
 			return generateCompletionOutput(existingCommand, shell);
 		},
+		async mcp(prefs) {
+			resolveAllCommands(existingCommand);
+			const { startMcpServer } = await import("./mcp-mLWIdUIu.mjs");
+			return startMcpServer(builder, existingCommand, evalCommand, prefs);
+		},
+		async serve(prefs) {
+			resolveAllCommands(existingCommand);
+			const { startServeServer } = await import("./serve-B0u43DK7.mjs");
+			return startServeServer(builder, existingCommand, evalCommand, prefs);
+		},
 		"~types": {},
 		[commandSymbol]: existingCommand
 	};
 	return builder;
 }
 //#endregion
-export { ActionError, ConfigError, PadroneError, REPL_SIGINT, RoutingError, ValidationError, asyncSchema, buildReplCompleter, createPadrone };
+export { ActionError, ConfigError, PadroneError, REPL_SIGINT, RoutingError, ValidationError, asyncSchema, asyncStream, buildReplCompleter, colorThemes, createPadrone };
 
 //# sourceMappingURL=index.mjs.map