muon-ui 0.5.0 → 0.7.0

package/dist/cli.cjs

@@ -1,19 +1,21 @@
 #!/usr/bin/env node
 /*!
 * name: muon-ui
-* version: 0.5.0
+* version: 0.7.0
 * description: A multi-platform GUI application framework that uses CEF as its backend
 * author: Kouji Matsui (@kekyo@mi.kekyo.net)
 * license: MIT
 * repository.url: https://github.com/kekyo/muon-ui.git
-* git.commit.hash: 122830dc7b35ced0c4c88c91d3a9dd8b3dee18e2
+* git.commit.hash: fe80718aaa617c0c0ea5c816bbe38d22bf2e8402
 */
-const require_vite_options = require("./vite-options-D4u4kLQI.cjs");
+const require_vite_options = require("./vite-options-FFh0NWUa.cjs");
 let commander = require("commander");
 let node_child_process = require("node:child_process");
 let node_fs = require("node:fs");
 let node_fs_promises = require("node:fs/promises");
 let node_path = require("node:path");
+let adm_zip = require("adm-zip");
+adm_zip = require_vite_options.__toESM(adm_zip, 1);
 //#region src/dev.ts
 var import_dist = require_vite_options.require_dist();
 var muonRecycleExitCode = 88;
@@ -23,7 +25,7 @@ var defaultProjectConfigFileNames = [
 	"muon.json"
 ];
 var resolveFromRoot = (root, path) => (0, node_path.isAbsolute)(path) ? path : (0, node_path.resolve)(root, path);
-var isJsonObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isJsonObject$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var getErrorMessage = (error) => error instanceof Error ? error.message : String(error);
 var fileExists = async (path) => {
 	try {
@@ -39,16 +41,16 @@ var directoryExists = async (path) => {
 		return false;
 	}
 };
-var isMissingVitePackageError = (error) => {
+var isMissingVitePackageError$1 = (error) => {
 	const candidate = error;
 	return candidate.code === "ERR_MODULE_NOT_FOUND" && typeof candidate.message === "string" && candidate.message.includes("vite");
 };
-var loadViteMuonOptions = async (cwd) => {
+var loadViteMuonOptions$1 = async (cwd) => {
 	let vite;
 	try {
 		vite = await import("vite");
 	} catch (error) {
-		if (isMissingVitePackageError(error)) return {
+		if (isMissingVitePackageError$1(error)) return {
 			root: (0, node_path.resolve)(cwd),
 			pluginOptions: void 0
 		};
@@ -84,7 +86,7 @@ var resolveProjectConfigPath = async (root, configPath) => {
 		if (await fileExists(candidatePath)) return candidatePath;
 	}
 };
-var readJsonObjectFile = async (filePath, label) => {
+var readJsonObjectFile$1 = async (filePath, label) => {
 	let content;
 	try {
 		content = await (0, node_fs_promises.readFile)(filePath, "utf8");
@@ -97,7 +99,7 @@ var readJsonObjectFile = async (filePath, label) => {
 	} catch (error) {
 		throw new Error(`${label} could not be parsed: ${filePath}: ${getErrorMessage(error)}`);
 	}
-	if (!isJsonObject(parsed)) throw new Error(`${label} must contain a JSON object: ${filePath}`);
+	if (!isJsonObject$1(parsed)) throw new Error(`${label} must contain a JSON object: ${filePath}`);
 	return parsed;
 };
 var resolveProjectConfig = async (root, configPath) => {
@@ -108,14 +110,14 @@ var resolveProjectConfig = async (root, configPath) => {
 	};
 	return {
 		configPath: resolvedConfigPath,
-		config: await readJsonObjectFile(resolvedConfigPath, "muon config")
+		config: await readJsonObjectFile$1(resolvedConfigPath, "muon config")
 	};
 };
 var readConfigAssetSourcePath = (config) => {
 	if (config === void 0) return;
 	const asset = config.asset;
 	if (asset === void 0) return;
-	if (!isJsonObject(asset)) throw new Error("muon config asset must be an object when present.");
+	if (!isJsonObject$1(asset)) throw new Error("muon config asset must be an object when present.");
 	const sourcePath = asset.sourcePath;
 	if (sourcePath === void 0) return;
 	if (typeof sourcePath !== "string") throw new Error("muon config asset.sourcePath must be a string.");
@@ -195,7 +197,7 @@ var runMuonExecutable = async (muonExecutablePath, configPaths, environment) =>
 * @returns Development startup result after the Muon process exits.
 */
 var runMuonDev = async (options = {}) => {
-	const loadedViteOptions = await loadViteMuonOptions((0, node_path.resolve)(options.root ?? process.cwd()));
+	const loadedViteOptions = await loadViteMuonOptions$1((0, node_path.resolve)(options.root ?? process.cwd()));
 	const root = loadedViteOptions.root;
 	const pluginOptions = loadedViteOptions.pluginOptions;
 	const platform = options.platform ?? process.platform;
@@ -244,9 +246,330 @@ var runMuonDev = async (options = {}) => {
 	};
 };
 //#endregion
+//#region src/pack.ts
+var AdmZip = __resolveDefaultExport(adm_zip.default, false);
+globalThis.__screwUpIsInCJS_733954c41a89 = true;
+function __resolveDefaultExport(module, isESM) {
+	const __isInCJS = typeof globalThis !== "undefined" && globalThis.__screwUpIsInCJS_733954c41a89 === true;
+	const maybe = module;
+	const hasDefault = !!(maybe && typeof maybe === "object" && "default" in maybe);
+	const unwrapNamespaceDefault = (value) => {
+		if (!value || typeof value !== "object") return value;
+		const inner = value;
+		if ((inner.__esModule === true || typeof Symbol !== "undefined" && inner[Symbol.toStringTag] === "Module") && "default" in inner) return inner.default;
+		return value;
+	};
+	const resolvedDefault = hasDefault ? unwrapNamespaceDefault(maybe.default) : void 0;
+	if (__isInCJS) return hasDefault ? resolvedDefault ?? module : module;
+	if (isESM) {
+		if (hasDefault) return resolvedDefault;
+		throw new Error("Default export not found.");
+	}
+	return hasDefault ? resolvedDefault ?? module : module;
+}
+var supportedPackTypes = [
+	"zip",
+	"deb",
+	"nsis"
+];
+var defaultArtifactsDirectory = "artifacts";
+var defaultPackageBuildDirectory = ".muon/pack";
+var suppressViteMuonBuildEnvironmentKey = "MUON_SUPPRESS_VITE_MUON_BUILD";
+var isJsonObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isMissingVitePackageError = (error) => {
+	const candidate = error;
+	return candidate.code === "ERR_MODULE_NOT_FOUND" && typeof candidate.message === "string" && candidate.message.includes("vite");
+};
+var loadViteMuonOptions = async (cwd) => {
+	let vite;
+	try {
+		vite = await import("vite");
+	} catch (error) {
+		if (isMissingVitePackageError(error)) return {
+			root: (0, node_path.resolve)(cwd),
+			pluginOptions: void 0
+		};
+		throw error;
+	}
+	const loaded = await vite.loadConfigFromFile({
+		command: "build",
+		mode: "production",
+		isPreview: false,
+		isSsrBuild: false
+	}, void 0, cwd, "silent");
+	if (loaded === null) return {
+		root: (0, node_path.resolve)(cwd),
+		pluginOptions: void 0
+	};
+	const config = loaded.config;
+	const root = typeof config.root === "string" ? (0, node_path.resolve)(cwd, config.root) : (0, node_path.resolve)(cwd);
+	const muonPlugins = (await require_vite_options.flattenVitePluginOptions(config.plugins)).map((plugin) => require_vite_options.getMuonVitePluginOptions(plugin)).filter((pluginOptions) => pluginOptions !== void 0);
+	if (muonPlugins.length > 1) throw new Error("Multiple muon() plugin definitions were found in vite.config.*.");
+	return {
+		root,
+		pluginOptions: muonPlugins[0]
+	};
+};
+var readJsonObjectFile = async (path) => {
+	const parsed = (0, import_dist.parse)(await (0, node_fs_promises.readFile)(path, "utf8"));
+	if (!isJsonObject(parsed)) throw new Error(`JSON file must contain an object: ${path}`);
+	return parsed;
+};
+var readPackageJson = async (root) => {
+	return await readJsonObjectFile((0, node_path.join)(root, "package.json"));
+};
+var sanitizePackageName = (value) => {
+	const sanitized = (value.startsWith("@") ? value.slice(value.indexOf("/") + 1) : value).trim().toLowerCase().replace(/[^a-z0-9+.-]+/g, "-").replace(/^[.+-]+/g, "").replace(/[.+-]+$/g, "");
+	return sanitized.length > 0 ? sanitized : "muon-app";
+};
+var stringifyAuthor = (value) => {
+	if (typeof value === "string") return value;
+	if (!isJsonObject(value) || typeof value.name !== "string") return;
+	return value.email === void 0 || typeof value.email !== "string" ? value.name : `${value.name} <${value.email}>`;
+};
+var resolveMetadata = (packageJson, options) => {
+	const packageNameSource = options.packageName ?? (typeof packageJson.name === "string" ? packageJson.name : void 0);
+	if (packageNameSource === void 0 || packageNameSource.trim() === "") throw new Error("package.json name is required for muon pack.");
+	const version = options.packageVersion ?? (typeof packageJson.version === "string" ? packageJson.version : void 0);
+	if (version === void 0 || version.trim() === "") throw new Error("package.json version is required for muon pack.");
+	const description = options.description ?? (typeof packageJson.description === "string" ? packageJson.description : "Muon application");
+	const author = options.author ?? stringifyAuthor(packageJson.author) ?? "Unknown";
+	return {
+		packageName: sanitizePackageName(packageNameSource),
+		version,
+		description,
+		author
+	};
+};
+var normalizePackTypes = (types) => {
+	const normalized = types.flatMap((value) => value.split(",")).map((value) => value.trim().toLowerCase()).filter((value) => value.length > 0);
+	if (normalized.length === 0) throw new Error("Specify at least one package type with --type.");
+	for (const type of normalized) if (!supportedPackTypes.includes(type)) throw new Error(`Unsupported muon pack type: ${type}`);
+	return [...new Set(normalized)];
+};
+var getPluginBuildOptions = (pluginOptions) => {
+	return typeof pluginOptions?.build === "object" ? pluginOptions.build : {};
+};
+var resolveBuildOutputDirectory = async (root) => {
+	const resolved = await (await import("vite")).resolveConfig({ root }, "build", "production", "production");
+	return (0, node_path.isAbsolute)(resolved.build.outDir) ? resolved.build.outDir : (0, node_path.resolve)(resolved.root, resolved.build.outDir);
+};
+var runViteBuild = async (root, _environment) => {
+	const vite = await import("vite");
+	const previous = process.env[suppressViteMuonBuildEnvironmentKey];
+	process.env[suppressViteMuonBuildEnvironmentKey] = "1";
+	try {
+		await vite.build({ root });
+	} finally {
+		if (previous === void 0) delete process.env[suppressViteMuonBuildEnvironmentKey];
+		else process.env[suppressViteMuonBuildEnvironmentKey] = previous;
+	}
+};
+var createBuildOptions = (root, assetSourcePath, pluginBuildOptions, options) => {
+	const buildOptions = {
+		root,
+		assetSourcePath,
+		assetPrefix: "main"
+	};
+	Object.assign(buildOptions, pluginBuildOptions);
+	if (options.targets !== void 0 && options.targets.length > 0) {
+		buildOptions.targets = options.targets;
+		buildOptions.allTargets = false;
+	} else if (options.allTargets !== void 0) buildOptions.allTargets = options.allTargets;
+	if (options.configPath !== void 0) buildOptions.configPath = options.configPath;
+	if (options.appName !== void 0) buildOptions.appName = options.appName;
+	if (options.appId !== void 0) buildOptions.appId = options.appId;
+	if (options.packageDirectory !== void 0) buildOptions.packageDirectory = options.packageDirectory;
+	return buildOptions;
+};
+var assertPackTypeSupportsTarget = (type, target) => {
+	const descriptor = require_vite_options.getMuonTargetDescriptor(target);
+	if (type === "deb" && descriptor.os !== "linux") throw new Error("deb packaging supports only Linux targets.");
+	if (type === "nsis" && descriptor.os !== "windows") throw new Error("nsis packaging supports only Windows targets.");
+};
+var runTool = async (executable, args, cwd, environment) => {
+	const child = (0, node_child_process.spawn)(executable, [...args], {
+		cwd,
+		env: environment,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		]
+	});
+	let stderr = "";
+	child.stderr.setEncoding("utf8");
+	child.stderr.on("data", (chunk) => {
+		stderr += chunk;
+	});
+	const exitCode = await new Promise((resolvePromise, reject) => {
+		child.once("error", reject);
+		child.once("close", (code) => {
+			resolvePromise(code ?? 1);
+		});
+	});
+	if (exitCode !== 0) throw new Error(`${executable} failed with exit code ${exitCode}: ${stderr.trim()}`);
+};
+var statOrUndefined = async (path) => {
+	try {
+		return await (0, node_fs_promises.stat)(path);
+	} catch {
+		return;
+	}
+};
+var addDirectoryToZip = async (zip, directory, entryRoot) => {
+	const walk = async (currentDirectory) => {
+		const entries = await (0, node_fs_promises.readdir)(currentDirectory, { withFileTypes: true });
+		entries.sort((left, right) => left.name.localeCompare(right.name));
+		for (const entry of entries) {
+			const path = (0, node_path.join)(currentDirectory, entry.name);
+			if (entry.isDirectory()) await walk(path);
+			else if (entry.isFile()) {
+				const stats = await (0, node_fs_promises.stat)(path);
+				const relativePath = (0, node_path.relative)(directory, path).split(node_path.sep).join("/");
+				zip.addFile(`${entryRoot}/${relativePath}`, await (0, node_fs_promises.readFile)(path), void 0, stats.mode << 16);
+			}
+		}
+	};
+	await walk(directory);
+};
+var packageZip = async (target, metadata, artifactsRoot) => {
+	const zip = new AdmZip();
+	await addDirectoryToZip(zip, target.outputPath, target.distributionDirectoryName);
+	const outputPath = (0, node_path.join)(artifactsRoot, `${metadata.packageName}-${metadata.version}-${target.target}.zip`);
+	await (0, node_fs_promises.mkdir)((0, node_path.dirname)(outputPath), { recursive: true });
+	await (0, node_fs_promises.writeFile)(outputPath, zip.toBuffer());
+	return {
+		type: "zip",
+		target: target.target,
+		path: outputPath
+	};
+};
+var packageDeb = async (root, target, metadata, artifactsRoot, packageBuildRoot, environment) => {
+	const descriptor = require_vite_options.getMuonTargetDescriptor(target.target);
+	if (descriptor.os !== "linux") throw new Error(`Unsupported deb target: ${target.target}`);
+	const architecture = descriptor.arch;
+	const packageRoot = (0, node_path.join)(packageBuildRoot, "deb", `${metadata.packageName}-${target.target}`);
+	await (0, node_fs_promises.rm)(packageRoot, {
+		recursive: true,
+		force: true
+	});
+	const installedDist = (0, node_path.join)((0, node_path.join)(packageRoot, "usr", "lib", metadata.packageName), target.distributionDirectoryName);
+	await (0, node_fs_promises.mkdir)(installedDist, { recursive: true });
+	await (0, node_fs_promises.cp)(target.outputPath, installedDist, { recursive: true });
+	const binPath = (0, node_path.join)(packageRoot, "usr", "bin", metadata.packageName);
+	const launcherName = (0, node_path.basename)(target.launcherPath);
+	await (0, node_fs_promises.mkdir)((0, node_path.dirname)(binPath), { recursive: true });
+	await (0, node_fs_promises.writeFile)(binPath, [
+		"#!/usr/bin/env bash",
+		"set -euo pipefail",
+		`exec ${JSON.stringify(`/usr/lib/${metadata.packageName}/${target.distributionDirectoryName}/${launcherName}`)} "$@"`,
+		""
+	].join("\n"));
+	await (0, node_fs_promises.chmod)(binPath, 493);
+	const controlPath = (0, node_path.join)(packageRoot, "DEBIAN", "control");
+	await (0, node_fs_promises.mkdir)((0, node_path.dirname)(controlPath), { recursive: true });
+	await (0, node_fs_promises.writeFile)(controlPath, [
+		`Package: ${metadata.packageName}`,
+		`Version: ${metadata.version}`,
+		`Architecture: ${architecture}`,
+		`Maintainer: ${metadata.author}`,
+		`Description: ${metadata.description}`,
+		""
+	].join("\n"));
+	const outputPath = (0, node_path.join)(artifactsRoot, `${metadata.packageName}-${metadata.version}-${architecture}.deb`);
+	await (0, node_fs_promises.mkdir)((0, node_path.dirname)(outputPath), { recursive: true });
+	await runTool("dpkg-deb", [
+		"--build",
+		packageRoot,
+		outputPath
+	], root, environment);
+	return {
+		type: "deb",
+		target: target.target,
+		path: outputPath
+	};
+};
+var escapeNsis = (value) => value.replaceAll("\\", "\\\\").replaceAll("\"", "$\\\"");
+var packageNsis = async (root, target, metadata, artifactsRoot, packageBuildRoot, environment) => {
+	const descriptor = require_vite_options.getMuonTargetDescriptor(target.target);
+	if (descriptor.os !== "windows") throw new Error(`Unsupported nsis target: ${target.target}`);
+	const scriptPath = (0, node_path.join)(packageBuildRoot, "nsis", `${metadata.packageName}-${target.target}.nsi`);
+	const outputPath = (0, node_path.join)(artifactsRoot, `${metadata.packageName}-${metadata.version}-${descriptor.arch}-setup.exe`);
+	await (0, node_fs_promises.mkdir)((0, node_path.dirname)(scriptPath), { recursive: true });
+	await (0, node_fs_promises.mkdir)((0, node_path.dirname)(outputPath), { recursive: true });
+	await (0, node_fs_promises.writeFile)(scriptPath, [
+		"Unicode true",
+		`Name "${escapeNsis(metadata.packageName)}"`,
+		`OutFile "${escapeNsis(outputPath)}"`,
+		`InstallDir "$LOCALAPPDATA\\Programs\\${escapeNsis(metadata.packageName)}"`,
+		"RequestExecutionLevel user",
+		"Section",
+		"  SetOutPath \"$INSTDIR\"",
+		`  File /r "${escapeNsis(target.outputPath)}\\*"`,
+		`  CreateShortCut "$SMPROGRAMS\\${escapeNsis(metadata.packageName)}.lnk" "$INSTDIR\\${escapeNsis((0, node_path.basename)(target.launcherPath))}"`,
+		"SectionEnd",
+		""
+	].join("\n"));
+	await runTool("makensis", [scriptPath], root, environment);
+	if (await statOrUndefined(outputPath) === void 0) throw new Error(`makensis did not create installer: ${outputPath}`);
+	return {
+		type: "nsis",
+		target: target.target,
+		path: outputPath
+	};
+};
+/**
+* Builds a Vite app, creates Muon dist directories, and packages them.
+*
+* @param options Pack options.
+* @returns Generated package artifacts.
+*/
+var packMuonApp = async (options) => {
+	const cwd = (0, node_path.resolve)(options.root ?? process.cwd());
+	const environment = options.environment ?? process.env;
+	const loadedOptions = await loadViteMuonOptions(cwd);
+	const root = loadedOptions.root;
+	const metadata = resolveMetadata(await readPackageJson(root), options);
+	const artifactsRoot = (0, node_path.resolve)(root, options.artifactsDir ?? defaultArtifactsDirectory);
+	const packageBuildRoot = (0, node_path.resolve)(root, defaultPackageBuildDirectory);
+	const types = normalizePackTypes(options.types);
+	const viteOutputDirectory = await resolveBuildOutputDirectory(root);
+	await runViteBuild(root, environment);
+	const build = await require_vite_options.buildMuonApp(createBuildOptions(root, viteOutputDirectory, getPluginBuildOptions(loadedOptions.pluginOptions), options));
+	for (const type of types) for (const target of build.targets) assertPackTypeSupportsTarget(type, target.target);
+	await (0, node_fs_promises.rm)(packageBuildRoot, {
+		recursive: true,
+		force: true
+	});
+	await (0, node_fs_promises.rm)((0, node_path.join)(artifactsRoot, "deb"), {
+		recursive: true,
+		force: true
+	});
+	await (0, node_fs_promises.rm)((0, node_path.join)(artifactsRoot, "nsis"), {
+		recursive: true,
+		force: true
+	});
+	await (0, node_fs_promises.mkdir)(artifactsRoot, { recursive: true });
+	const artifacts = [];
+	for (const target of build.targets) for (const type of types) if (type === "zip") artifacts.push(await packageZip(target, metadata, artifactsRoot));
+	else if (type === "deb") artifacts.push(await packageDeb(root, target, metadata, artifactsRoot, packageBuildRoot, environment));
+	else artifacts.push(await packageNsis(root, target, metadata, artifactsRoot, packageBuildRoot, environment));
+	return {
+		root,
+		packageName: metadata.packageName,
+		version: metadata.version,
+		appName: build.appName,
+		appId: build.appId,
+		build,
+		targets: build.targets,
+		artifacts
+	};
+};
+//#endregion
 //#region src/generated/packageMetadata.ts
-var version = "0.5.0";
-var git_commit_hash = "122830dc7b35ced0c4c88c91d3a9dd8b3dee18e2";
+var version = "0.7.0";
+var git_commit_hash = "fe80718aaa617c0c0ea5c816bbe38d22bf2e8402";
 //#endregion
 //#region src/cli.ts
 var readTargetValues = (value) => {
@@ -255,6 +578,9 @@ var readTargetValues = (value) => {
 var appendTargetValues = (value, previous) => {
 	return [...previous, ...readTargetValues(value)];
 };
+var appendPackTypeValues = (value, previous) => {
+	return [...previous, ...readTargetValues(value)];
+};
 var validateEmbedConfigOptions = (options) => {
 	if (options.runtimePath !== void 0 && options.corePath !== void 0) throw new Error("Specify at most one of --runtime-path or --core-path.");
 	if (options.runtimePath === void 0 && options.corePath === void 0 && options.bootstrapPath === void 0) throw new Error("Specify at least one of --runtime-path, --core-path, or --bootstrap-path.");
@@ -274,10 +600,34 @@ var runBuildCommand = async (commandOptions) => {
 	if (commandOptions.config !== void 0) buildOptions.configPath = commandOptions.config;
 	if (commandOptions.outDir !== void 0) buildOptions.outputRoot = commandOptions.outDir;
 	if (commandOptions.name !== void 0) buildOptions.appName = commandOptions.name;
+	if (commandOptions.appId !== void 0) buildOptions.appId = commandOptions.appId;
 	const result = await require_vite_options.buildMuonApp(buildOptions);
 	if (commandOptions.json === true) console.log(JSON.stringify(result, null, 2));
 	else for (const target of result.targets) console.log(target.outputPath);
 };
+var runPackCommand = async (commandOptions) => {
+	const targets = commandOptions.target;
+	if (commandOptions.all === true && targets.length > 0) throw new Error("Specify either --all or --target, not both.");
+	const packOptions = {
+		root: process.cwd(),
+		types: commandOptions.type,
+		environment: process.env
+	};
+	if (targets.length > 0) packOptions.targets = targets;
+	if (commandOptions.all !== void 0) packOptions.allTargets = commandOptions.all;
+	if (commandOptions.config !== void 0) packOptions.configPath = commandOptions.config;
+	if (commandOptions.name !== void 0) packOptions.appName = commandOptions.name;
+	if (commandOptions.appId !== void 0) packOptions.appId = commandOptions.appId;
+	if (commandOptions.packageDirectory !== void 0) packOptions.packageDirectory = commandOptions.packageDirectory;
+	if (commandOptions.artifactsDir !== void 0) packOptions.artifactsDir = commandOptions.artifactsDir;
+	if (commandOptions.packageName !== void 0) packOptions.packageName = commandOptions.packageName;
+	if (commandOptions.packageVersion !== void 0) packOptions.packageVersion = commandOptions.packageVersion;
+	if (commandOptions.description !== void 0) packOptions.description = commandOptions.description;
+	if (commandOptions.author !== void 0) packOptions.author = commandOptions.author;
+	const result = await packMuonApp(packOptions);
+	if (commandOptions.json === true) console.log(JSON.stringify(result, null, 2));
+	else for (const artifact of result.artifacts) console.log(artifact.path);
+};
 var runPrepareCommand = async (commandOptions) => {
 	const result = await require_vite_options.runMuonPrepare({
 		muonPath: commandOptions.muonPath ?? "",
@@ -353,9 +703,12 @@ var createCliCommand = () => {
 		program.outputHelp({ error: true });
 		process.exitCode = 1;
 	});
-	program.command("build").description("Build CEF-free Muon app distribution directories").option("--target <target>", "target alias or comma-separated target aliases", appendTargetValues, []).option("--all", "build all supported targets").option("--assets <path>", "asset root path").option("--config <path>", "muon config path").option("--out-dir <path>", "output root directory").option("--name <name>", "launcher file name").option("--json", "write result as JSON").action(async (options) => {
+	program.command("build").description("Build CEF-free Muon app distribution directories").option("--target <target>", "public target or comma-separated public targets", appendTargetValues, []).option("--all", "build all supported targets").option("--assets <path>", "asset root path").option("--config <path>", "muon config path").option("--out-dir <path>", "output root directory").option("--name <name>", "launcher file name").option("--app-id <id>", "stable application identifier").option("--json", "write result as JSON").action(async (options) => {
 		await runBuildCommand(options);
 	});
+	program.command("pack").description("Build and package a Muon app").requiredOption("-t, --type <type>", "package type or comma-separated package types: zip, deb, nsis", appendPackTypeValues, []).option("--target <target>", "public target or comma-separated public targets", appendTargetValues, []).option("--all", "build all supported targets").option("--config <path>", "muon config path").option("--name <name>", "launcher file name").option("--app-id <id>", "stable application identifier").option("--package-directory <path>", "Muon package dist directory").option("--artifacts-dir <path>", "package artifact output directory").option("--package-name <name>", "package name override").option("--package-version <version>", "package version override").option("--description <text>", "package description override").option("--author <text>", "package author override").option("--json", "write result as JSON").action(async (options) => {
+		await runPackCommand(options);
+	});
 	const devCommand = program.command("dev").description("Launch Muon directly with local development assets").option("--muon-path <path>", "Muon runtime file root").option("--cef-path <path>", "CEF file root").option("--stage-dir <path>", "prepared runtime output directory").option("--config <path>", "muon config path").option("--assets <path>", "development asset directory").option("--no-debugger", "disable Muon debugger defaults").option("--json", "write result as JSON").action(async (options) => {
 		await runDevCommand(options, devCommand);
 	});