@rzl-zone/build-tools 0.0.9 → 0.0.11

package/dist/index.js

@@ -2,22 +2,23 @@
 * ========================================================================
 *  @rzl-zone/build-tools
 * ------------------------------------------------------------------------
-*  Version: `0.0.9`
+*  Version: `0.0.11`
 *  Author: `Rizalvin Dwiky <rizalvindwiky1998@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/build-tools`
 * ========================================================================
 */
 
-import { S as toStringSet, _ as isUndefined, a as isError, d as isNumber, g as isString, h as isSet, i as isBoolean, l as isNonEmptyString, m as isRegExp, n as flattenStrings, p as isPlainObject, r as isArray, v as normalizeSpaces, x as toObjectSet, y as safeStableStringify } from "./helper-D11A-ZKL.js";
-import { a as resolvePatternOptions, i as defaultPatternOptions, n as fsExtra, o as sourceOfPatternOptions, r as ICONS, t as fastGlob } from "./server-1H2HFAbi.js";
-import { t as CommandIdentity } from "./identity-C5MeSAA7.js";
-import { a as joinInline, i as formatOptionValue, l as picocolors, n as EOL, o as joinLines, s as joinLinesLoose, u as plural } from "./client-DUlrjus0.js";
-import { n as getPackageJson, t as generatePackageBanner } from "./package-banner-vwqcAX8E.js";
+import { S as toStringSet, _ as isUndefined, a as isError, d as isNumber, g as isString, h as isSet, i as isBoolean, l as isNonEmptyString, m as isRegExp, n as flattenStrings, p as isPlainObject, r as isArray, v as normalizeSpaces, x as toObjectSet, y as safeStableStringify } from "./helper-C0AShk-j.js";
+import { a as resolvePatternOptions, i as defaultPatternOptions, n as fsExtra, o as sourceOfPatternOptions, r as ICONS, t as fastGlob } from "./server-Dc93jndm.js";
+import { t as CommandIdentity } from "./identity-CcYkvy9q.js";
+import { a as joinInline, i as formatOptionValue, l as picocolors, n as EOL, o as joinLines, s as joinLinesLoose, u as plural } from "./client-DzeqTq6Y.js";
+import { n as getPackageJson, t as generatePackageBanner } from "./package-banner-DkNDAjMK.js";
 import "@rzl-zone/node-only";
 import * as t from "@babel/types";
 import { parse } from "@babel/parser";
 import traverseImport from "@babel/traverse";
 import path from "node:path";
+import { parse as parse$2 } from "shell-quote";
 import { ChildProcess, spawn } from "node:child_process";
 import * as acorn from "acorn";
 function isLogLevel(value) {
@@ -1155,31 +1156,44 @@ const normalizeJsBuildNewlines = async (pattern, options = {}) => {
 	}
 };
 function runCommand(command, argsOrOptions = [], maybeOptions = {}) {
-	assertValidCommand(command);
-	let args;
-	let options;
-	if (Array.isArray(argsOrOptions)) {
-		args = argsOrOptions;
-		options = maybeOptions;
-	} else {
-		args = [];
-		options = argsOrOptions;
-	}
 	return new Promise((resolve, reject) => {
-		const { shell = true, stdio = "inherit", argv0: _argv0, useColors = true, ...restOption } = options;
-		const { child, setupLifecycle, cmdStringPlain } = spawnWithLifecycle(command, args, {
-			...restOption,
-			stdio,
-			useColors,
-			shell
-		}, { rejectOnNonZero: true });
-		setupLifecycle({
-			onSuccess: (code) => {
-				if (code === 0) resolve(child);
-				else reject(/* @__PURE__ */ new Error(`${cmdStringPlain} exited with code ${code}`));
-			},
-			onError: reject
-		});
+		try {
+			let args;
+			let options;
+			const isArgsArray = isArray(argsOrOptions);
+			if (isArgsArray) {
+				args = argsOrOptions;
+				options = maybeOptions;
+			} else {
+				args = [];
+				options = argsOrOptions;
+			}
+			assertValidCommand(command, {
+				apiType: "runCommand",
+				useColors: options.useColors,
+				allowInline: !isArgsArray
+			});
+			const { shell = true, stdio = "inherit", argv0: _argv0, useColors = true, ...restOption } = options;
+			const { child, setupLifecycle, cmdStringPlain } = spawnWithLifecycle(command, args, {
+				...restOption,
+				stdio,
+				useColors,
+				shell
+			}, { rejectOnNonZero: true });
+			setupLifecycle({
+				onSuccess: (code) => {
+					if (code === 0) resolve(child);
+					else reject(/* @__PURE__ */ new Error(`${cmdStringPlain} exited with code ${code}`));
+				},
+				onError: reject
+			});
+		} catch (err) {
+			const e = err instanceof Error ? err : new Error(String(err));
+			const cleanedBase = stripInternalStack(((/* @__PURE__ */ new Error()).stack?.split(EOL).slice(1) ?? []).filter((line) => !line.includes("runCommand")));
+			e.stack = [e.message, ...cleanedBase].join(EOL);
+			reject(e);
+			return;
+		}
 	});
 }
 function normalizeChunk(chunk) {
@@ -1188,74 +1202,89 @@ function normalizeChunk(chunk) {
 	return String(chunk);
 }
 function runCommandCapture(command, argsOrOptions = [], maybeOptions = {}) {
-	assertValidCommand(command);
-	let args;
-	let options;
-	if (Array.isArray(argsOrOptions)) {
-		args = argsOrOptions;
-		options = maybeOptions;
-	} else {
-		args = [];
-		options = argsOrOptions;
-	}
-	const { shell = true, signal, timeout, forceKill, useColors = true, argv0: _argv0, ...restOption } = options;
 	return new Promise((resolve, reject) => {
-		const { child, setupLifecycle } = spawnWithLifecycle(command, args, {
-			...restOption,
-			stdio: "pipe",
-			shell,
-			signal,
-			timeout,
-			forceKill,
-			useColors
-		}, { rejectOnNonZero: false });
-		let stdout = "";
-		let stderr = "";
-		child.stdout?.on("data", (chunk) => {
-			stdout += normalizeChunk(chunk);
-		});
-		child.stderr?.on("data", (chunk) => {
-			stderr += normalizeChunk(chunk);
-		});
-		setupLifecycle({
-			onSuccess: (code) => {
-				resolve({
-					stdout: stdout.trimEnd(),
-					stderr: stderr.trimEnd(),
-					exitCode: code,
-					ok: code === 0
-				});
-			},
-			onError: reject
-		});
+		try {
+			let args;
+			let options;
+			const isArgsArray = isArray(argsOrOptions);
+			if (isArgsArray) {
+				args = argsOrOptions;
+				options = maybeOptions;
+			} else {
+				args = [];
+				options = argsOrOptions;
+			}
+			assertValidCommand(command, {
+				apiType: "runCommandCapture",
+				useColors: options.useColors,
+				allowInline: !isArgsArray
+			});
+			const { shell = true, signal, timeout, forceKill, useColors = true, argv0: _argv0, ...restOption } = options;
+			const { child, setupLifecycle } = spawnWithLifecycle(command, args, {
+				...restOption,
+				stdio: "pipe",
+				shell,
+				signal,
+				timeout,
+				forceKill,
+				useColors
+			}, { rejectOnNonZero: false });
+			let stdout = "";
+			let stderr = "";
+			child.stdout?.on("data", (chunk) => {
+				stdout += normalizeChunk(chunk);
+			});
+			child.stderr?.on("data", (chunk) => {
+				stderr += normalizeChunk(chunk);
+			});
+			setupLifecycle({
+				onSuccess: (code) => {
+					resolve({
+						stdout: stdout.trimEnd(),
+						stderr: formatMessageColor(stderr.trimEnd(), useColors),
+						exitCode: code,
+						ok: code === 0
+					});
+				},
+				onError: reject
+			});
+		} catch (err) {
+			const e = err instanceof Error ? err : new Error(String(err));
+			const cleanedBase = stripInternalStack(((/* @__PURE__ */ new Error()).stack?.split(EOL).slice(1) ?? []).filter((line) => !line.includes("runCommandCapture")));
+			e.stack = [e.message, ...cleanedBase].join(EOL);
+			reject(e);
+			return;
+		}
 	});
 }
+const formatMessageColor = (message, useColors = true) => {
+	return useColors ? picocolors.redBright(message) : message;
+};
 function formatCommand(command, args, { useColors = true } = {}) {
 	const hasArgs = args.length > 0;
 	const argsString = hasArgs ? args.map((a) => safeStableStringify(a)).join(" ") : "";
-	if (useColors) {
-		const cmd = picocolors.cyanBright(command);
-		return hasArgs ? `${cmd} ${picocolors.gray(argsString)}` : cmd;
-	}
-	return hasArgs ? `${command} ${argsString}` : command;
+	if (!hasArgs) return formatMessageColor(command, useColors);
+	if (useColors) return `${picocolors.cyanBright(command)} ${picocolors.gray(argsString)}`;
+	return `${command} ${argsString}`;
 }
-function assertValidCommand(command, { useColors = true } = {}) {
-	if (typeof command !== "string") {
+function assertValidCommand(command, options) {
+	const { useColors = true, allowInline = false, apiType } = options || {};
+	if (!isString(command)) {
 		const errorMsg = `Invalid command: expected a string, received ${safeStableStringify(command)}`;
-		throw new TypeError(useColors ? picocolors.redBright(errorMsg) : errorMsg);
+		throw new TypeError(formatMessageColor(errorMsg, useColors));
 	}
 	const trimmed = command.trim();
-	if (trimmed.length === 0) {
-		const errorMsg = "Invalid command: command cannot be empty";
-		throw new Error(useColors ? picocolors.redBright(errorMsg) : errorMsg);
+	if (trimmed.length === 0) throw new Error(formatMessageColor("Invalid command: command cannot be empty", useColors));
+	const hasSpace = /\s/.test(trimmed);
+	if (hasShellSyntax(trimmed)) {
+		const errorMsg = joinLinesLoose(`Invalid command: "${trimmed}"`, "Shell operators are not supported in this context (e.g. &&, ||, |, >).", "This utility only supports a single command with arguments.");
+		throw new Error(formatMessageColor(errorMsg, useColors));
 	}
-	const hasSpace = trimmed.includes(" ");
-	const hasQuotes = /['"`]/.test(trimmed);
-	const hasShellOps = /[|&;<>(){}$]/.test(trimmed);
-	if (hasSpace || hasQuotes || hasShellOps) {
+	if (!allowInline && hasSpace) {
 		const [cmd, ...rest] = trimmed.split(/\s+/);
-		const errorMsg = joinLinesLoose(`Invalid command: "${trimmed}"`, "Do not pass a full shell command.", `Use arguments instead: runCommand("${cmd}", ${safeStableStringify(rest)})`);
-		throw new Error(useColors ? picocolors.redBright(errorMsg) : errorMsg);
+		if (!cmd) throw new Error("Invalid command: unable to resolve executable.");
+		const errorMsg = joinLinesLoose(`Invalid command: "${trimmed}"`, "Do not include arguments in the command when passing them separately.", `Use: ${apiType}("${cmd}", ${safeStableStringify(rest)})`);
+		throw new Error(formatMessageColor(errorMsg, useColors));
 	}
 }
 function stripInternalStack(lines) {
@@ -1267,8 +1296,10 @@ function stripInternalStack(lines) {
 		"createProcessError",
 		"formatError",
 		"spawnWithLifecycle",
+		"assertValidCommand",
 		"setupLifecycle",
-		"node:internal"
+		"node:internal",
+		"node:internal/process/promises"
 	];
 	return lines.filter((line) => {
 		if (blacklist.some((key) => line.includes(key))) return false;
@@ -1335,29 +1366,70 @@ var CommandProcessError = class extends Error {
 function isCommandProcessError(err) {
 	return err instanceof CommandProcessError;
 }
+function hasShellSyntax(str) {
+	return /(\|\||&&|[|&;<>\n])/.test(str);
+}
+function resolveCommand(input, useColors = true) {
+	const tokens = parse$2(input);
+	const normalized = [];
+	for (const t of tokens) {
+		if (typeof t === "string") {
+			normalized.push(t);
+			continue;
+		}
+		if ("comment" in t) continue;
+		if ("pattern" in t) {
+			normalized.push(t.pattern);
+			continue;
+		}
+		if ("op" in t) throw new Error(formatMessageColor("Unsupported shell operator detected.", useColors));
+		throw new Error(formatMessageColor("Unknown token in command.", useColors));
+	}
+	if (normalized.length === 0) throw new Error(formatMessageColor("Invalid command: empty after parsing.", useColors));
+	const [cmd, ...args] = normalized;
+	if (!cmd) throw new Error(formatMessageColor("Invalid command: empty after parsing.", useColors));
+	return {
+		command: cmd,
+		args
+	};
+}
 function spawnWithLifecycle(command, args, options, config) {
-	const { useColors = true, timeout, forceKill, signal: abortSignal, ...restOption } = options;
+	const { useColors = true, timeout, forceKill, signal: abortSignal, shell = false, ...restOption } = options;
+	let cmd = command;
+	let finalArgs = [...args];
+	const isInline = finalArgs.length === 0 && /\s/.test(cmd);
 	const baseStack = (/* @__PURE__ */ new Error()).stack;
-	const cmdString = formatCommand(command, args, { useColors });
-	const cmdStringPlain = formatCommand(command, args, { useColors: false });
 	const formatError = config?.formatError ?? ((msg, meta) => {
 		const metaCommand = meta.command.trim();
-		const argsString = meta.args.length > 0 ? meta.args.map((a) => safeStableStringify(a).trim()).join(" ") : "";
+		const hasArgs = meta.args.length > 0;
+		const argsString = hasArgs ? meta.args.map((a) => safeStableStringify(a).trim()).join(" ") : "";
+		const commandString = hasArgs ? `${metaCommand} ${argsString}` : metaCommand;
 		if (meta.useColors) {
 			const cmd = picocolors.magentaBright(metaCommand);
-			const args = argsString ? picocolors.yellowBright(argsString) : "";
+			const args = hasArgs ? picocolors.yellowBright(argsString) : "";
 			return createProcessError(`${cmd}${args ? " " + args : ""} ${picocolors.redBright(msg)}`, {
 				...meta,
-				command: `${metaCommand} ${argsString}`
+				command: commandString
 			}, baseStack);
 		}
-		return createProcessError(`${metaCommand}${isNonEmptyString(argsString) ? " " + argsString : ""} ${msg}`, {
+		return createProcessError(`${commandString} ${msg}`, {
 			...meta,
-			command: `${metaCommand} ${argsString}`
+			command: commandString
 		}, baseStack);
 	});
 	const rejectOnNonZero = config?.rejectOnNonZero ?? false;
-	const child = spawn(command, [...args], restOption);
+	if (isInline) {
+		const resolved = resolveCommand(cmd, useColors);
+		cmd = resolved.command;
+		finalArgs = resolved.args;
+	}
+	for (const arg of finalArgs) if (hasShellSyntax(arg)) throw new Error(formatMessageColor(`Invalid argument: "${arg}" contains unsupported shell syntax`, useColors));
+	const cmdString = formatCommand(cmd, finalArgs, { useColors });
+	const cmdStringPlain = formatCommand(cmd, finalArgs, { useColors: false });
+	const child = spawn(cmd, finalArgs, {
+		shell,
+		...restOption
+	});
 	let finished = false;
 	const kill = () => {
 		try {
@@ -1382,8 +1454,8 @@ function spawnWithLifecycle(command, args, options, config) {
 				kill();
 				fail(formatError(`timed out after ${timeout}ms`, {
 					reason: "timeout",
-					command,
-					args,
+					command: cmd,
+					args: finalArgs,
 					useColors
 				}));
 			}, timeout) : null;
@@ -1407,8 +1479,8 @@ function spawnWithLifecycle(command, args, options, config) {
 				kill();
 				fail(formatError("aborted by signal", {
 					reason: "abort",
-					command,
-					args,
+					command: cmd,
+					args: finalArgs,
 					useColors
 				}));
 			};
@@ -1426,8 +1498,8 @@ function spawnWithLifecycle(command, args, options, config) {
 						reason: "signal",
 						signal,
 						exitCode: code ?? void 0,
-						command,
-						args,
+						command: cmd,
+						args: finalArgs,
 						useColors
 					}));
 					return;
@@ -1437,8 +1509,8 @@ function spawnWithLifecycle(command, args, options, config) {
 					fail(formatError(`exited with code ${exitCode}`, {
 						reason: "non-zero exit code",
 						exitCode,
-						command,
-						args,
+						command: cmd,
+						args: finalArgs,
 						useColors
 					}));
 					return;