muon-ui 0.11.0 → 0.12.0

package/dist/cli.cjs

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 /*!
 * name: muon-ui
-* version: 0.11.0
+* version: 0.12.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: db70f7643ac9fb1f61ab79f1de55c3dd8686de8d
+* git.commit.hash: e716d83ebb5283f31cbdf524872df61039e6a7f0
 */
-const require_vite_internals = require("./vite-internals-Dha0jYI8.cjs");
+const require_vite_internals = require("./vite-internals-BK3BM9YY.cjs");
 let commander = require("commander");
 let node_child_process = require("node:child_process");
 let node_fs = require("node:fs");
@@ -76,6 +76,62 @@ var loadViteMuonOptions = async (cwd) => {
 		pluginOptions: muonPlugins[0]
 	};
 };
+var getRuntimePluginConfigFromViteBuild = async (root) => {
+	const vite = await import("vite");
+	let resolvedRuntimeStates = [];
+	const inspector = {
+		name: "muon-run-vite-build-inspector",
+		enforce: "post",
+		configResolved: (config) => {
+			const runtimeStates = config.plugins.map((plugin) => require_vite_internals.getMuonVitePluginRuntimeState(plugin)).filter((runtimeState) => runtimeState !== void 0);
+			if (runtimeStates.length > 1) throw new Error("Multiple muon() plugin definitions were found in vite.config.*.");
+			resolvedRuntimeStates = runtimeStates;
+		}
+	};
+	const previous = process.env[require_vite_internals.muonBuildSequenceSuppressViteBuildEnvironmentKey];
+	process.env[require_vite_internals.muonBuildSequenceSuppressViteBuildEnvironmentKey] = "1";
+	try {
+		await vite.build({
+			root,
+			logLevel: "silent",
+			plugins: [inspector]
+		});
+	} finally {
+		if (previous === void 0) delete process.env[require_vite_internals.muonBuildSequenceSuppressViteBuildEnvironmentKey];
+		else process.env[require_vite_internals.muonBuildSequenceSuppressViteBuildEnvironmentKey] = previous;
+	}
+	const runtimePluginConfig = resolvedRuntimeStates[0]?.getRuntimePluginConfig();
+	if (runtimePluginConfig === void 0) throw new Error("muon Vite plugin runtime config was not resolved.");
+	return runtimePluginConfig;
+};
+var copyViteOutputAsRunAssets = async (project, assetSourcePath, assetPrefix) => {
+	if (project.viteOutputDirectory === void 0) throw new Error("Vite output directory could not be resolved.");
+	await assertDevelopmentAssetDirectory(project.viteOutputDirectory);
+	const destinationPath = (0, node_path.join)(assetSourcePath, ...assetPrefix.split("/"));
+	await (0, node_fs_promises.mkdir)((0, node_path.dirname)(destinationPath), { recursive: true });
+	await (0, node_fs_promises.cp)(project.viteOutputDirectory, destinationPath, { recursive: true });
+};
+var prepareViteRunAssets = async (cwd) => {
+	const project = await require_vite_internals.loadMuonBuildSequenceProject(cwd);
+	if (project.pluginOptions === void 0) return;
+	const buildOptions = require_vite_internals.resolveMuonViteBuildOptions(project.pluginOptions);
+	const packagedAssetOptions = require_vite_internals.createVitePackagedAssetOptions(project.viteBase ?? "/");
+	const assetSourcePath = (0, node_path.join)(project.root, ".muon", "run", "assets");
+	await (0, node_fs_promises.rm)(assetSourcePath, {
+		recursive: true,
+		force: true
+	});
+	const runtimePluginConfig = await getRuntimePluginConfigFromViteBuild(project.viteBuildRoot);
+	await copyViteOutputAsRunAssets(project, assetSourcePath, packagedAssetOptions.assetPrefix);
+	return {
+		root: project.root,
+		pluginOptions: project.pluginOptions,
+		configPath: buildOptions.configPath,
+		assetSourcePath,
+		browserStartPage: packagedAssetOptions.browserStartPage,
+		runtimePluginConfig
+	};
+};
 var resolveProjectConfigPath = async (root, configPath) => {
 	if (configPath !== void 0) {
 		const resolvedPath = resolveFromRoot(root, configPath);
@@ -125,6 +181,11 @@ var readConfigAssetSourcePath = (config) => {
 	if (sourcePath.trim().length === 0) throw new Error("muon config asset.sourcePath must not be empty.");
 	return sourcePath;
 };
+var hasConfigBrowserStartPage = (config) => {
+	if (config === void 0) return false;
+	const browser = config.browser;
+	return isJsonObject$1(browser) && browser.startPage !== void 0;
+};
 var assertDevelopmentAssetDirectory = async (assetSourcePath) => {
 	if (await directoryExists(assetSourcePath)) return;
 	try {
@@ -155,16 +216,21 @@ var resolveAssetSource = async (root, assetSourcePath, projectConfig) => {
 		overrideAssetSourcePath: defaultAssetSourcePath
 	};
 };
-var createMuonDevOverrideConfig = (assetSourcePath, enableDebugger) => ({
-	...assetSourcePath === void 0 ? {} : { asset: { sourcePath: assetSourcePath } },
-	...enableDebugger ? {
-		cdp: { enable: true },
-		browser: { keybind: {
+var createMuonDevOverrideConfig = (assetSourcePath, enableDebugger, browserStartPage, runtimePluginConfig) => {
+	const browser = browserStartPage === void 0 && !enableDebugger ? void 0 : {
+		...browserStartPage === void 0 ? {} : { startPage: browserStartPage },
+		...enableDebugger ? { keybind: {
 			devtools: "f12",
 			recycle: "ctrl+f12"
-		} }
-	} : {}
-});
+		} } : {}
+	};
+	return {
+		...assetSourcePath === void 0 ? {} : { asset: { sourcePath: assetSourcePath } },
+		...enableDebugger ? { cdp: { enable: true } } : {},
+		...browser === void 0 ? {} : { browser },
+		...runtimePluginConfig === void 0 ? {} : { plugin: runtimePluginConfig }
+	};
+};
 var writeMuonDevOverrideConfig = async (overrideConfigPath, overrideConfig) => {
 	await (0, node_fs_promises.mkdir)((0, node_path.dirname)(overrideConfigPath), { recursive: true });
 	await (0, node_fs_promises.writeFile)(overrideConfigPath, `${JSON.stringify(overrideConfig, null, 2)}\n`);
@@ -198,7 +264,12 @@ 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 cwd = (0, node_path.resolve)(options.root ?? process.cwd());
+	const preparedViteAssets = options.assetSourcePath === void 0 ? await prepareViteRunAssets(cwd) : void 0;
+	const loadedViteOptions = preparedViteAssets === void 0 ? await loadViteMuonOptions(cwd) : {
+		root: preparedViteAssets.root,
+		pluginOptions: preparedViteAssets.pluginOptions
+	};
 	const root = loadedViteOptions.root;
 	const pluginOptions = loadedViteOptions.pluginOptions;
 	const platform = options.platform ?? process.platform;
@@ -213,8 +284,12 @@ var runMuonDev = async (options = {}) => {
 	const cefPath = options.cefPath !== void 0 ? resolveFromRoot(root, options.cefPath) : pluginOptions?.cefPath === void 0 ? void 0 : resolveFromRoot(root, pluginOptions.cefPath);
 	const stagePath = options.stagePath !== void 0 ? resolveFromRoot(root, options.stagePath) : pluginOptions?.stagePath === void 0 ? (0, node_path.resolve)(root, ".muon", target) : resolveFromRoot(root, pluginOptions.stagePath);
 	const enableDebugger = options.enableDebugger ?? pluginOptions?.enableDebugger ?? true;
-	const projectConfig = await resolveProjectConfig(root, options.configPath);
-	const asset = await resolveAssetSource(root, options.assetSourcePath, projectConfig);
+	const projectConfig = await resolveProjectConfig(root, options.configPath ?? preparedViteAssets?.configPath);
+	const asset = preparedViteAssets === void 0 ? await resolveAssetSource(root, options.assetSourcePath, projectConfig) : {
+		assetSourcePath: preparedViteAssets.assetSourcePath,
+		overrideAssetSourcePath: preparedViteAssets.assetSourcePath
+	};
+	const browserStartPage = preparedViteAssets?.browserStartPage !== void 0 && !hasConfigBrowserStartPage(projectConfig.config) ? preparedViteAssets.browserStartPage : void 0;
 	const overrideConfigPath = (0, node_path.join)(root, ".muon", "run", "muon.run.json");
 	await require_vite_internals.ensureMuonGitignoreEntry(root);
 	const preparedRuntime = await require_vite_internals.runMuonPrepare({
@@ -230,7 +305,7 @@ var runMuonDev = async (options = {}) => {
 		cwd: root
 	});
 	if (preparedRuntime.stagePath === void 0) throw new Error("muon-builder did not return a staged runtime path.");
-	await writeMuonDevOverrideConfig(overrideConfigPath, createMuonDevOverrideConfig(asset.overrideAssetSourcePath, enableDebugger));
+	await writeMuonDevOverrideConfig(overrideConfigPath, createMuonDevOverrideConfig(asset.overrideAssetSourcePath, enableDebugger, browserStartPage, preparedViteAssets?.runtimePluginConfig));
 	const muonExecutablePath = require_vite_internals.getMuonExecutablePath(preparedRuntime.stagePath, platform);
 	const exitCode = await runMuonExecutable(muonExecutablePath, [...projectConfig.configPath === void 0 ? [] : [projectConfig.configPath], overrideConfigPath], environment);
 	return {
@@ -280,7 +355,41 @@ var defaultPackageBuildDirectory = ".muon/pack";
 var systemRuntimeRoot = "/var/lib/muon/apps";
 var systemCefCacheRoot = "/var/cache/muon/cef";
 var runtimeHelperExecutableName = "muon-runtime-helper";
-var debGtk3RuntimeDependency = "libgtk-3-0t64 | libgtk-3-0";
+var portableProfilePath = "profile";
+var portableInstallMetadata = {
+	type: "portable",
+	runtimeMode: "in-place"
+};
+var debRuntimeDependencies = [
+	"libc6",
+	"libgcc-s1",
+	"libstdc++6",
+	"libffi8",
+	"libexpat1",
+	"libdbus-1-3",
+	"libglib2.0-0t64 | libglib2.0-0",
+	"libgtk-3-0t64 | libgtk-3-0",
+	"libatk-bridge2.0-0t64 | libatk-bridge2.0-0",
+	"libatk1.0-0t64 | libatk1.0-0",
+	"libatspi2.0-0t64 | libatspi2.0-0",
+	"libcups2t64 | libcups2",
+	"libnspr4",
+	"libnss3",
+	"libgbm1",
+	"libasound2t64 | libasound2",
+	"libudev1",
+	"libx11-6",
+	"libxcb1",
+	"libxcomposite1",
+	"libxdamage1",
+	"libxext6",
+	"libxfixes3",
+	"libxi6",
+	"libxkbcommon0",
+	"libxrandr2",
+	"libcairo2",
+	"libpango-1.0-0"
+];
 var isJsonObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var readJsonObjectFile = async (path) => {
 	const parsed = (0, import_dist.parse)(await (0, node_fs_promises.readFile)(path, "utf8"));
@@ -369,6 +478,7 @@ var packTypeSupportsTarget = (type, target) => {
 	const descriptor = require_vite_internals.getMuonTargetDescriptor(target);
 	return type === "zip" && descriptor.os === "windows" || type === "tar.gz" && descriptor.os === "linux" || type === "deb" && descriptor.os === "linux" || type === "nsis" && descriptor.os === "windows";
 };
+var isPortablePackType = (type) => type === "zip" || type === "tar.gz";
 var createPackTargetPlan = (types, targets) => {
 	const plan = targets.map((target) => ({
 		target,
@@ -404,6 +514,17 @@ var runTool = async (executable, args, cwd, environment) => {
 	});
 	if (exitCode !== 0) throw new Error(`${executable} failed with exit code ${exitCode}: ${stderr.trim()}`);
 };
+var isUnavailableToolError = (error, executable) => {
+	if (!(error instanceof Error)) return false;
+	const nodeError = error;
+	return nodeError.code === "ENOENT" && (nodeError.syscall === `spawn ${executable}` || nodeError.path === executable);
+};
+var reportSkippedUnavailableTool = (progress, executable, type, target) => {
+	progress?.({
+		phase: "pack",
+		status: `Warning: ${executable} is not available; skipping ${type} package for ${target}.`
+	});
+};
 var statOrUndefined = async (path) => {
 	try {
 		return await (0, node_fs_promises.stat)(path);
@@ -427,9 +548,10 @@ var addDirectoryToZip = async (zip, directory, entryRoot) => {
 	};
 	await walk(directory);
 };
+var getPortableArchiveEntryRoot = (target, metadata) => `${metadata.packageName}/${target.target}`;
 var packageZip = async (target, metadata, artifactsRoot) => {
 	const zip = new AdmZip();
-	await addDirectoryToZip(zip, target.outputPath, target.distributionDirectoryName);
+	await addDirectoryToZip(zip, target.outputPath, getPortableArchiveEntryRoot(target, metadata));
 	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());
@@ -459,13 +581,16 @@ var createTarGzEntryGenerator = async function* (directory, entryRoot) {
 var packageTarGz = async (target, metadata, artifactsRoot) => {
 	const outputPath = (0, node_path.join)(artifactsRoot, `${metadata.packageName}-${metadata.version}-${target.target}.tar.gz`);
 	await (0, node_fs_promises.mkdir)((0, node_path.dirname)(outputPath), { recursive: true });
-	await (0, tar_vern.storeReaderToFile)((0, tar_vern.createTarPacker)(createTarGzEntryGenerator(target.outputPath, target.distributionDirectoryName), "gzip"), outputPath);
+	await (0, tar_vern.storeReaderToFile)((0, tar_vern.createTarPacker)(createTarGzEntryGenerator(target.outputPath, getPortableArchiveEntryRoot(target, metadata)), "gzip"), outputPath);
 	return {
 		type: "tar.gz",
 		target: target.target,
 		path: outputPath
 	};
 };
+var writePortableInstallMetadata = async (target) => {
+	await (0, node_fs_promises.writeFile)((0, node_path.join)(target.outputPath, "muon-install.json"), `${JSON.stringify(portableInstallMetadata, void 0, 2)}\n`);
+};
 var packageDeb = async (root, target, metadata, artifactsRoot, packageBuildRoot, environment, linuxSandbox, progress) => {
 	const descriptor = require_vite_internals.getMuonTargetDescriptor(target.target);
 	if (descriptor.os !== "linux") throw new Error(`Unsupported deb target: ${target.target}`);
@@ -523,7 +648,7 @@ var packageDeb = async (root, target, metadata, artifactsRoot, packageBuildRoot,
 		`Version: ${metadata.version}`,
 		`Architecture: ${architecture}`,
 		`Maintainer: ${metadata.author}`,
-		`Depends: ${debGtk3RuntimeDependency}`,
+		`Depends: ${debRuntimeDependencies.join(", ")}`,
 		`Description: ${metadata.description}`,
 		""
 	].join("\n"));
@@ -562,12 +687,20 @@ var packageDeb = async (root, target, metadata, artifactsRoot, packageBuildRoot,
 		phase: "pack",
 		status: "Running dpkg-deb"
 	});
-	await runTool("dpkg-deb", [
-		"--root-owner-group",
-		"--build",
-		packageRoot,
-		outputPath
-	], root, environment);
+	try {
+		await runTool("dpkg-deb", [
+			"--root-owner-group",
+			"--build",
+			packageRoot,
+			outputPath
+		], root, environment);
+	} catch (error) {
+		if (isUnavailableToolError(error, "dpkg-deb")) {
+			reportSkippedUnavailableTool(progress, "dpkg-deb", "deb", target.target);
+			return;
+		}
+		throw error;
+	}
 	return {
 		type: "deb",
 		target: target.target,
@@ -634,7 +767,15 @@ var packageNsis = async (root, target, metadata, windowsResource, artifactsRoot,
 		phase: "pack",
 		status: "Running makensis"
 	});
-	await runTool("makensis", [scriptPath], root, environment);
+	try {
+		await runTool("makensis", [scriptPath], root, environment);
+	} catch (error) {
+		if (isUnavailableToolError(error, "makensis")) {
+			reportSkippedUnavailableTool(progress, "makensis", "nsis", target.target);
+			return;
+		}
+		throw error;
+	}
 	if (await statOrUndefined(outputPath) === void 0) throw new Error(`makensis did not create installer: ${outputPath}`);
 	return {
 		type: "nsis",
@@ -675,6 +816,55 @@ var reapplyPackWindowsResources = async (targets, resource, root, environment) =
 		}
 	}
 };
+var createPortableBuildOptions = (input) => {
+	const buildOptions = {
+		root: input.project.root,
+		targets: input.targets,
+		allTargets: false,
+		outputRoot: input.outputRoot
+	};
+	if (input.project.pluginOptions !== void 0) {
+		if (input.project.viteOutputDirectory === void 0) throw new Error("Vite output directory could not be resolved.");
+		Object.assign(buildOptions, input.pluginBuildOptions);
+		const packagedAssetOptions = require_vite_internals.createVitePackagedAssetOptions(input.project.viteBase ?? "/");
+		buildOptions.assetSourcePath = input.project.viteOutputDirectory;
+		buildOptions.assetPrefix = packagedAssetOptions.assetPrefix;
+		if (packagedAssetOptions.browserStartPage !== void 0) buildOptions.browserStartPage = packagedAssetOptions.browserStartPage;
+	}
+	buildOptions.targets = input.targets;
+	buildOptions.allTargets = false;
+	buildOptions.outputRoot = input.outputRoot;
+	if (input.options.configPath !== void 0) buildOptions.configPath = input.options.configPath;
+	if (input.iconPath !== void 0) buildOptions.iconPath = input.iconPath;
+	if (input.options.appName !== void 0) buildOptions.appName = input.options.appName;
+	if (input.options.appId !== void 0) buildOptions.appId = input.options.appId;
+	if (input.options.packageDirectory !== void 0) buildOptions.packageDirectory = input.options.packageDirectory;
+	if (input.windowsResourceOptions !== void 0) buildOptions.windowsResource = input.windowsResourceOptions;
+	if (input.linuxDesktopOptions !== void 0) buildOptions.linuxDesktop = input.linuxDesktopOptions;
+	if (input.progress !== void 0) buildOptions.progress = input.progress;
+	buildOptions.browserProfilePathOverride = portableProfilePath;
+	return buildOptions;
+};
+var buildPortableTargets = async (input) => {
+	if (input.targets.length === 0) return /* @__PURE__ */ new Map();
+	input.progress?.({
+		phase: "pack",
+		status: "Building portable distributions"
+	});
+	const build = await require_vite_internals.buildMuonApp(createPortableBuildOptions({
+		project: input.project,
+		pluginBuildOptions: input.pluginBuildOptions,
+		options: input.options,
+		outputRoot: (0, node_path.join)(input.packageBuildRoot, "portable-build"),
+		targets: input.targets,
+		windowsResourceOptions: input.windowsResourceOptions,
+		linuxDesktopOptions: input.linuxDesktopOptions,
+		iconPath: input.iconPath,
+		progress: input.progress
+	}));
+	await Promise.all(build.targets.map(writePortableInstallMetadata));
+	return new Map(build.targets.map((target) => [target.target, target]));
+};
 /**
 * Runs the muon build sequence and creates redistributable packages.
 *
@@ -737,6 +927,7 @@ var packMuonApp = async (options) => {
 	const build = await require_vite_internals.runMuonBuildSequence(buildOptions, project);
 	if (options.packageVersion !== void 0) await reapplyPackWindowsResources(build.targets, windowsResource, root, environment);
 	const typesByTarget = new Map(targetPlan.map((entry) => [entry.target, entry.types]));
+	const portableTargets = targetPlan.filter((entry) => entry.types.some(isPortablePackType)).map((entry) => entry.target);
 	await (0, node_fs_promises.rm)(packageBuildRoot, {
 		recursive: true,
 		force: true
@@ -750,6 +941,18 @@ var packMuonApp = async (options) => {
 		force: true
 	});
 	await (0, node_fs_promises.mkdir)(artifactsRoot, { recursive: true });
+	const portableTargetsByTarget = await buildPortableTargets({
+		project,
+		pluginBuildOptions,
+		options,
+		packageBuildRoot,
+		targets: portableTargets,
+		windowsResourceOptions,
+		linuxDesktopOptions,
+		iconPath,
+		progress
+	});
+	if (options.packageVersion !== void 0) await reapplyPackWindowsResources([...portableTargetsByTarget.values()], windowsResource, root, environment);
 	const artifacts = [];
 	const totalArtifacts = targetPlan.reduce((sum, entry) => sum + entry.types.length, 0);
 	let artifactIndex = 0;
@@ -760,10 +963,17 @@ var packMuonApp = async (options) => {
 			status: `Packaging ${type} ${target.target} (${artifactIndex}/${totalArtifacts})`
 		});
 		let artifact;
-		if (type === "zip") artifact = await packageZip(target, metadata, artifactsRoot);
-		else if (type === "tar.gz") artifact = await packageTarGz(target, metadata, artifactsRoot);
-		else if (type === "deb") artifact = await packageDeb(root, target, metadata, artifactsRoot, packageBuildRoot, environment, linuxSandbox, progress);
+		if (type === "zip") {
+			const portableTarget = portableTargetsByTarget.get(target.target);
+			if (portableTarget === void 0) throw new Error(`Portable target was not built: ${target.target}`);
+			artifact = await packageZip(portableTarget, metadata, artifactsRoot);
+		} else if (type === "tar.gz") {
+			const portableTarget = portableTargetsByTarget.get(target.target);
+			if (portableTarget === void 0) throw new Error(`Portable target was not built: ${target.target}`);
+			artifact = await packageTarGz(portableTarget, metadata, artifactsRoot);
+		} else if (type === "deb") artifact = await packageDeb(root, target, metadata, artifactsRoot, packageBuildRoot, environment, linuxSandbox, progress);
 		else artifact = await packageNsis(root, target, metadata, windowsResource, artifactsRoot, packageBuildRoot, environment, progress);
+		if (artifact === void 0) continue;
 		artifacts.push(artifact);
 		progress?.({
 			phase: "pack",
@@ -783,8 +993,8 @@ var packMuonApp = async (options) => {
 };
 //#endregion
 //#region src/generated/packageMetadata.ts
-var version = "0.11.0";
-var git_commit_hash = "db70f7643ac9fb1f61ab79f1de55c3dd8686de8d";
+var version = "0.12.0";
+var git_commit_hash = "e716d83ebb5283f31cbdf524872df61039e6a7f0";
 //#endregion
 //#region src/cli.ts
 var readTargetValues = (value) => {