miladyai 2.0.0-alpha.27

package/dist/services/mcp-marketplace.js

@@ -0,0 +1,134 @@
+import { createIntegrationTelemetrySpan } from "../diagnostics/integration-observability.js";
+
+//#region src/services/mcp-marketplace.ts
+/**
+* MCP Marketplace Service
+*
+* Fetches MCP servers from the official registry and manages local config.
+*/
+const MCP_REGISTRY_BASE_URL = "https://registry.modelcontextprotocol.io";
+/**
+* Search MCP servers from the official registry.
+*/
+async function searchMcpMarketplace(query, limit = 30) {
+	const url = `${MCP_REGISTRY_BASE_URL}/v0/servers`;
+	const searchSpan = createIntegrationTelemetrySpan({
+		boundary: "mcp",
+		operation: "search_registry_servers"
+	});
+	let resp;
+	try {
+		resp = await fetch(url, { headers: { Accept: "application/json" } });
+	} catch (err) {
+		searchSpan.failure({ error: err });
+		throw err;
+	}
+	if (!resp.ok) {
+		searchSpan.failure({
+			statusCode: resp.status,
+			errorKind: "http_error"
+		});
+		throw new Error(`Registry API error: ${resp.status} ${resp.statusText}`);
+	}
+	let data;
+	try {
+		data = await resp.json();
+	} catch (err) {
+		searchSpan.failure({
+			error: err,
+			statusCode: resp.status
+		});
+		throw err;
+	}
+	const results = [];
+	const seenNames = /* @__PURE__ */ new Set();
+	for (const entry of data.servers) {
+		const server = entry.server;
+		const meta = entry._meta?.["io.modelcontextprotocol.registry/official"];
+		if (!meta?.isLatest) continue;
+		if (seenNames.has(server.name)) continue;
+		seenNames.add(server.name);
+		if (query) {
+			const q = query.toLowerCase();
+			const matchName = server.name.toLowerCase().includes(q);
+			const matchTitle = server.title?.toLowerCase().includes(q);
+			const matchDesc = server.description?.toLowerCase().includes(q);
+			if (!matchName && !matchTitle && !matchDesc) continue;
+		}
+		let connectionType = "remote";
+		let connectionUrl;
+		let npmPackage;
+		let dockerImage;
+		if (server.remotes && server.remotes.length > 0) {
+			connectionType = "remote";
+			connectionUrl = server.remotes[0].url;
+		} else if (server.packages && server.packages.length > 0) {
+			const pkg = server.packages[0];
+			connectionType = "stdio";
+			if (pkg.registryType === "npm") npmPackage = pkg.identifier;
+			else if (pkg.registryType === "oci") dockerImage = pkg.identifier;
+		}
+		results.push({
+			id: `${server.name}@${server.version}`,
+			name: server.name,
+			title: server.title || server.name.split("/").pop() || server.name,
+			description: server.description || "No description",
+			version: server.version,
+			connectionType,
+			connectionUrl,
+			npmPackage,
+			dockerImage,
+			repositoryUrl: server.repository?.url,
+			websiteUrl: server.websiteUrl,
+			iconUrl: server.icons?.[0]?.src,
+			publishedAt: meta?.publishedAt,
+			isLatest: true
+		});
+		if (results.length >= limit) break;
+	}
+	searchSpan.success({ statusCode: resp.status });
+	return { results };
+}
+/**
+* Get detailed info for a specific MCP server from registry.
+*/
+async function getMcpServerDetails(name) {
+	const url = `${MCP_REGISTRY_BASE_URL}/v0/servers/${encodeURIComponent(name)}`;
+	const detailsSpan = createIntegrationTelemetrySpan({
+		boundary: "mcp",
+		operation: "get_registry_server_details"
+	});
+	let resp;
+	try {
+		resp = await fetch(url, { headers: { Accept: "application/json" } });
+	} catch (err) {
+		detailsSpan.failure({ error: err });
+		throw err;
+	}
+	if (!resp.ok) {
+		if (resp.status === 404) {
+			detailsSpan.success({ statusCode: resp.status });
+			return null;
+		}
+		detailsSpan.failure({
+			statusCode: resp.status,
+			errorKind: "http_error"
+		});
+		throw new Error(`Registry API error: ${resp.status}`);
+	}
+	let data;
+	try {
+		data = await resp.json();
+	} catch (err) {
+		detailsSpan.failure({
+			error: err,
+			statusCode: resp.status
+		});
+		throw err;
+	}
+	detailsSpan.success({ statusCode: resp.status });
+	return data.server;
+}
+
+//#endregion
+export { getMcpServerDetails, searchMcpMarketplace };

package/dist/services/plugin-installer.js

@@ -0,0 +1,396 @@
+import { loadMiladyConfig, saveMiladyConfig } from "../config/config.js";
+import { getPluginInfo } from "./registry-client.js";
+import os from "node:os";
+import path from "node:path";
+import { logger } from "@elizaos/core";
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import { promisify } from "node:util";
+
+//#region src/services/plugin-installer.ts
+/**
+* Plugin Installer for Milady.
+*
+* Cross-platform plugin installation and lifecycle management.
+*
+* Install targets:
+*   ~/.milady/plugins/installed/<sanitised-name>/
+*
+* Works identically whether milady is:
+*   - Running from source (dev)
+*   - Running as a CLI install (npm global)
+*   - Running inside an Electron .app bundle
+*   - Running on macOS, Linux, or Windows
+*
+* Strategy:
+*   1. npm/bun install to an isolated prefix directory
+*   2. Fallback: git clone from the plugin's GitHub repo
+*   3. Track the installation in milady.json config
+*   4. Trigger agent restart to load the new plugin
+*
+* @module services/plugin-installer
+*/
+const execFileAsync = promisify(execFile);
+/** npm package names: @scope/name or name. No shell metacharacters. */
+const VALID_PACKAGE_NAME = /^(@[a-zA-Z0-9][\w.-]*\/)?[a-zA-Z0-9][\w.-]*$/;
+/** Version strings: semver, dist-tags, git refs. Conservative allowlist. */
+const VALID_VERSION = /^[a-zA-Z0-9][\w.+-]*$/;
+/** Git branch names: alphanumeric, hyphens, slashes, dots. No shell metacharacters. */
+const VALID_BRANCH = /^[a-zA-Z0-9][\w./-]*$/;
+/** Git URLs: https:// only, no shell metacharacters. */
+const VALID_GIT_URL = /^https:\/\/[a-zA-Z0-9][\w./-]*\.git$/;
+function assertValidPackageName(name) {
+	if (!VALID_PACKAGE_NAME.test(name)) throw new Error(`Invalid package name: "${name}"`);
+}
+function assertValidVersion(version) {
+	if (!VALID_VERSION.test(version)) throw new Error(`Invalid version string: "${version}"`);
+}
+function assertValidGitUrl(url) {
+	if (!VALID_GIT_URL.test(url)) throw new Error(`Invalid git URL: "${url}"`);
+}
+let installLock = Promise.resolve();
+function serialise(fn) {
+	const prev = installLock;
+	let resolve;
+	installLock = new Promise((r) => {
+		resolve = r;
+	});
+	return prev.then(fn).finally(() => resolve?.());
+}
+function pluginsBaseDir() {
+	const base = process.env.MILADY_STATE_DIR?.trim() || path.join(os.homedir(), ".milady");
+	return path.join(base, "plugins", "installed");
+}
+function sanitisePackageName(name) {
+	return name.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+function pluginDir(pluginName) {
+	return path.join(pluginsBaseDir(), sanitisePackageName(pluginName));
+}
+async function detectPackageManager() {
+	for (const cmd of ["bun", "npm"]) try {
+		await execFileAsync(cmd, ["--version"]);
+		return cmd;
+	} catch {}
+	return "npm";
+}
+/**
+* Install a plugin from the registry.
+*
+* 1. Resolves the plugin name in the registry.
+* 2. Installs via npm/bun to ~/.milady/plugins/installed/<name>/.
+* 3. Falls back to git clone if npm is not available for this package.
+* 4. Writes an install record to milady.json.
+* 5. Returns metadata about the installation for the caller to
+*    decide whether to trigger a restart.
+*
+* @param pluginName - The plugin name (e.g., "@elizaos/plugin-twitter")
+* @param onProgress - Optional progress callback
+* @param requestedVersion - Optional specific version to install (e.g., "1.2.23-alpha.0")
+*/
+function installPlugin(pluginName, onProgress, requestedVersion) {
+	return serialise(() => _installPlugin(pluginName, onProgress, requestedVersion));
+}
+async function _installPlugin(pluginName, onProgress, requestedVersion) {
+	const emit = (phase, message) => onProgress?.({
+		phase,
+		pluginName,
+		message
+	});
+	emit("resolving", `Looking up ${pluginName} in registry...`);
+	const info = await getPluginInfo(pluginName);
+	if (!info) return {
+		success: false,
+		pluginName,
+		version: "",
+		installPath: "",
+		requiresRestart: false,
+		error: `Plugin "${pluginName}" not found in the registry`
+	};
+	const canonicalName = info.name;
+	const npmVersion = requestedVersion || info.npm.v2Version || info.npm.v1Version || "next";
+	const localPath = info.localPath;
+	const targetDir = pluginDir(canonicalName);
+	await fs.mkdir(targetDir, { recursive: true });
+	const targetPkgPath = path.join(targetDir, "package.json");
+	try {
+		await fs.access(targetPkgPath);
+	} catch {
+		await fs.writeFile(targetPkgPath, JSON.stringify({
+			private: true,
+			dependencies: {}
+		}, null, 2));
+	}
+	let installedVersion = npmVersion;
+	let installSource = "npm";
+	const pm = await detectPackageManager();
+	let installed = false;
+	if (localPath) {
+		emit("downloading", `Installing ${canonicalName} from local workspace...`);
+		try {
+			await runLocalPathInstall(pm, canonicalName, localPath, targetDir);
+			installedVersion = await readInstalledVersion(targetDir, canonicalName, npmVersion);
+			installSource = "path";
+			installed = true;
+		} catch (localErr) {
+			logger.warn(`[plugin-installer] local install failed for ${canonicalName}: ${localErr instanceof Error ? localErr.message : String(localErr)}`);
+		}
+	}
+	if (!installed) {
+		emit("downloading", `Installing ${canonicalName}@${npmVersion}...`);
+		try {
+			await runPackageInstall(pm, canonicalName, npmVersion, targetDir);
+			installedVersion = await readInstalledVersion(targetDir, canonicalName, npmVersion);
+			installSource = "npm";
+			installed = true;
+		} catch (npmErr) {
+			logger.warn(`[plugin-installer] npm failed for ${canonicalName}: ${npmErr instanceof Error ? npmErr.message : String(npmErr)}`);
+			emit("downloading", `npm failed, cloning from ${info.gitUrl}...`);
+			try {
+				await gitCloneInstall(info, targetDir, onProgress);
+				installedVersion = info.npm.v2Version || info.npm.v1Version || "git";
+				installSource = "path";
+				installed = true;
+			} catch (gitErr) {
+				const msg = gitErr instanceof Error ? gitErr.message : String(gitErr);
+				emit("error", `Installation failed: ${msg}`);
+				return {
+					success: false,
+					pluginName: canonicalName,
+					version: "",
+					installPath: targetDir,
+					requiresRestart: false,
+					error: msg
+				};
+			}
+		}
+	}
+	if (!installed) {
+		emit("error", "Installation failed");
+		return {
+			success: false,
+			pluginName: canonicalName,
+			version: "",
+			installPath: targetDir,
+			requiresRestart: false,
+			error: `Failed to install plugin "${canonicalName}"`
+		};
+	}
+	emit("validating", "Verifying plugin can be loaded...");
+	if (!await resolveEntryPoint(targetDir, canonicalName)) {
+		emit("error", "Plugin installed but entry point not found");
+		return {
+			success: false,
+			pluginName: canonicalName,
+			version: installedVersion,
+			installPath: targetDir,
+			requiresRestart: false,
+			error: "Plugin installed on disk but entry point could not be resolved"
+		};
+	}
+	emit("configuring", "Recording installation in config...");
+	recordInstallation(canonicalName, {
+		source: installSource,
+		spec: `${canonicalName}@${installedVersion}`,
+		installPath: targetDir,
+		version: installedVersion,
+		installedAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	emit("complete", `${canonicalName}@${installedVersion} installed successfully`);
+	return {
+		success: true,
+		pluginName: canonicalName,
+		version: installedVersion,
+		installPath: targetDir,
+		requiresRestart: true
+	};
+}
+async function runPackageInstall(pm, packageName, version, targetDir) {
+	assertValidPackageName(packageName);
+	assertValidVersion(version);
+	await installSpecWithFallback(pm, `${packageName}@${version}`, targetDir);
+}
+async function runLocalPathInstall(pm, packageName, sourcePath, targetDir) {
+	assertValidPackageName(packageName);
+	const resolvedSourcePath = path.resolve(sourcePath);
+	const packageJsonPath = path.join(resolvedSourcePath, "package.json");
+	await fs.access(packageJsonPath);
+	await installSpecWithFallback(pm, `file:${resolvedSourcePath}`, targetDir);
+}
+async function installSpecWithFallback(pm, spec, targetDir) {
+	try {
+		await runInstallSpec(pm, spec, targetDir);
+	} catch (primaryErr) {
+		if (pm === "npm") throw primaryErr;
+		logger.warn(`[plugin-installer] ${pm} install failed for ${spec}; retrying with npm: ${primaryErr instanceof Error ? primaryErr.message : String(primaryErr)}`);
+		await runInstallSpec("npm", spec, targetDir);
+	}
+}
+async function runInstallSpec(pm, spec, targetDir) {
+	switch (pm) {
+		case "bun":
+			await execFileAsync("bun", ["add", spec], { cwd: targetDir });
+			break;
+		default: await execFileAsync("npm", [
+			"install",
+			spec,
+			"--prefix",
+			targetDir
+		]);
+	}
+}
+async function readInstalledVersion(targetDir, packageName, fallbackVersion) {
+	const installedPkgPath = path.join(targetDir, "node_modules", ...packageName.split("/"), "package.json");
+	try {
+		const pkg = JSON.parse(await fs.readFile(installedPkgPath, "utf-8"));
+		if (typeof pkg.version === "string" && pkg.version.length > 0) return pkg.version;
+	} catch {}
+	return fallbackVersion;
+}
+async function remoteBranchExists(gitUrl, branch) {
+	try {
+		const { stdout } = await execFileAsync("git", [
+			"ls-remote",
+			"--heads",
+			gitUrl,
+			branch
+		], { env: {
+			...process.env,
+			GIT_TERMINAL_PROMPT: "0"
+		} });
+		return stdout.trim().length > 0;
+	} catch {
+		return false;
+	}
+}
+async function listRemoteBranches(gitUrl) {
+	try {
+		const { stdout } = await execFileAsync("git", [
+			"ls-remote",
+			"--heads",
+			gitUrl
+		], { env: {
+			...process.env,
+			GIT_TERMINAL_PROMPT: "0"
+		} });
+		const branches = [];
+		for (const rawLine of stdout.split("\n")) {
+			const line = rawLine.trim();
+			if (!line) continue;
+			const parts = line.split(/\s+/);
+			if (parts.length < 2) continue;
+			const ref = parts[1];
+			if (!ref.startsWith("refs/heads/")) continue;
+			const branch = ref.replace(/^refs\/heads\//, "");
+			if (VALID_BRANCH.test(branch)) branches.push(branch);
+		}
+		return branches;
+	} catch {
+		return [];
+	}
+}
+async function resolveGitBranch(info) {
+	assertValidGitUrl(info.gitUrl);
+	const rawCandidates = [
+		info.git.v2Branch,
+		info.git.v1Branch,
+		"next",
+		"main",
+		"master"
+	];
+	const candidates = [...new Set(rawCandidates.filter((c) => Boolean(c?.trim())))];
+	for (const branch of candidates) {
+		if (!VALID_BRANCH.test(branch)) continue;
+		if (await remoteBranchExists(info.gitUrl, branch)) return branch;
+	}
+	const remoteBranches = await listRemoteBranches(info.gitUrl);
+	if (remoteBranches.length > 0) {
+		for (const branch of [
+			"main",
+			"next",
+			"master",
+			"1.x",
+			"develop",
+			"dev"
+		]) if (remoteBranches.includes(branch)) return branch;
+		return remoteBranches[0];
+	}
+	return "main";
+}
+async function gitCloneInstall(info, targetDir, onProgress) {
+	const branch = await resolveGitBranch(info);
+	const tempDir = path.join(path.dirname(targetDir), `temp-${Date.now()}`);
+	await fs.mkdir(tempDir, { recursive: true });
+	try {
+		await execFileAsync("git", [
+			"clone",
+			"--branch",
+			branch,
+			"--single-branch",
+			"--depth",
+			"1",
+			info.gitUrl,
+			tempDir
+		], { env: {
+			...process.env,
+			GIT_TERMINAL_PROMPT: "0"
+		} });
+		onProgress?.({
+			phase: "installing-deps",
+			pluginName: info.name,
+			message: "Installing dependencies..."
+		});
+		const pm = await detectPackageManager();
+		await execFileAsync(pm, ["install"], { cwd: tempDir });
+		const tsDir = path.join(tempDir, "typescript");
+		try {
+			await fs.access(tsDir);
+		} catch (err) {
+			if (err.code === "ENOENT") {
+				await fs.cp(tempDir, targetDir, { recursive: true });
+				return;
+			}
+			throw err;
+		}
+		await execFileAsync(pm, ["run", "build"], { cwd: tsDir }).catch((buildErr) => {
+			logger.warn(`[plugin-installer] build step failed for ${info.name}: ${buildErr.message}`);
+		});
+		await fs.cp(tsDir, targetDir, { recursive: true });
+	} finally {
+		await fs.rm(tempDir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+/**
+* Resolve the importable entry point for an installed plugin.
+*
+* For npm-installed plugins the entry is:
+*   <targetDir>/node_modules/<packageName>/
+*
+* For git-cloned plugins the entry is the targetDir itself.
+*/
+async function resolveEntryPoint(targetDir, packageName) {
+	const nmPath = path.join(targetDir, "node_modules", ...packageName.split("/"));
+	try {
+		await fs.access(nmPath);
+		return nmPath;
+	} catch {}
+	const pkgPath = path.join(targetDir, "package.json");
+	try {
+		await fs.access(pkgPath);
+		return targetDir;
+	} catch {}
+	return null;
+}
+function recordInstallation(pluginName, record) {
+	const config = loadMiladyConfig();
+	if (!config.plugins) config.plugins = {};
+	if (!config.plugins.installs) config.plugins.installs = {};
+	config.plugins.installs[pluginName] = record;
+	saveMiladyConfig(config);
+}
+
+//#endregion
+export { installPlugin };

package/dist/services/plugin-manager-types.js

@@ -0,0 +1,15 @@
+//#region src/services/plugin-manager-types.ts
+function isObjectRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function isPluginManagerLike(candidate) {
+	if (!isObjectRecord(candidate)) return false;
+	return typeof candidate.refreshRegistry === "function" && typeof candidate.listInstalledPlugins === "function" && typeof candidate.getRegistryPlugin === "function" && typeof candidate.searchRegistry === "function" && typeof candidate.installPlugin === "function" && typeof candidate.uninstallPlugin === "function";
+}
+function isCoreManagerLike(candidate) {
+	if (!isObjectRecord(candidate)) return false;
+	return typeof candidate.getCoreStatus === "function";
+}
+
+//#endregion
+export { isCoreManagerLike, isPluginManagerLike };

package/dist/services/registry-client-app-meta.js

@@ -0,0 +1,144 @@
+import { logger } from "@elizaos/core";
+
+//#region src/services/registry-client-app-meta.ts
+const LOCAL_APP_DEFAULT_SANDBOX = "allow-scripts allow-same-origin allow-popups";
+const ALLOWED_SANDBOX_TOKENS = new Set([
+	"allow-downloads",
+	"allow-forms",
+	"allow-modals",
+	"allow-orientation-lock",
+	"allow-pointer-lock",
+	"allow-popups",
+	"allow-popups-to-escape-sandbox",
+	"allow-presentation",
+	"allow-same-origin",
+	"allow-scripts",
+	"allow-storage-access-by-user-activation",
+	"allow-top-navigation-by-user-activation"
+]);
+const LOCAL_APP_OVERRIDES = {
+	"@elizaos/app-babylon": {
+		launchType: "url",
+		launchUrl: "http://localhost:3000",
+		viewer: {
+			url: "http://localhost:3000",
+			sandbox: "allow-scripts allow-same-origin allow-popups allow-forms"
+		}
+	},
+	"@elizaos/app-hyperscape": {
+		launchType: "connect",
+		launchUrl: "http://localhost:3333",
+		viewer: {
+			url: "http://localhost:3333",
+			embedParams: {
+				embedded: "true",
+				mode: "spectator",
+				quality: "medium"
+			},
+			postMessageAuth: true,
+			sandbox: "allow-scripts allow-same-origin allow-popups allow-forms"
+		}
+	},
+	"@elizaos/app-hyperfy": {
+		launchType: "connect",
+		launchUrl: "http://localhost:3003",
+		viewer: {
+			url: "http://localhost:3003",
+			sandbox: LOCAL_APP_DEFAULT_SANDBOX
+		}
+	},
+	"@elizaos/app-2004scape": {
+		launchType: "connect",
+		launchUrl: "http://localhost:8880",
+		viewer: {
+			url: "http://localhost:8880",
+			embedParams: { bot: "{RS_SDK_BOT_NAME}" },
+			postMessageAuth: true,
+			sandbox: "allow-scripts allow-same-origin allow-popups allow-forms"
+		}
+	},
+	"@elizaos/app-agent-town": {
+		launchType: "url",
+		launchUrl: "http://localhost:5173/ai-town/index.html",
+		viewer: {
+			url: "http://localhost:5173/ai-town/index.html",
+			sandbox: "allow-scripts allow-same-origin allow-popups allow-forms"
+		}
+	},
+	"@elizaos/app-dungeons": {
+		launchType: "local",
+		launchUrl: "http://localhost:3345",
+		viewer: {
+			url: "http://localhost:3345",
+			sandbox: "allow-scripts allow-same-origin allow-popups allow-forms"
+		}
+	}
+};
+function sanitizeSandbox(rawSandbox) {
+	if (!rawSandbox || !rawSandbox.trim()) return LOCAL_APP_DEFAULT_SANDBOX;
+	const tokens = rawSandbox.split(/\s+/).map((token) => token.trim()).filter((token) => token.length > 0);
+	if (tokens.length === 0) return LOCAL_APP_DEFAULT_SANDBOX;
+	for (const token of tokens) if (!ALLOWED_SANDBOX_TOKENS.has(token)) {
+		logger.warn(`[registry-client] rejecting untrusted sandbox token: ${token}`);
+		return LOCAL_APP_DEFAULT_SANDBOX;
+	}
+	return Array.from(new Set(tokens)).join(" ");
+}
+function normalizeViewer(viewer) {
+	if (!viewer) return void 0;
+	return {
+		...viewer,
+		sandbox: sanitizeSandbox(viewer.sandbox)
+	};
+}
+function mergeViewer(base, patch) {
+	if (!base && !patch) return void 0;
+	if (!base) return normalizeViewer(patch);
+	if (!patch) return normalizeViewer(base);
+	return normalizeViewer({
+		...base,
+		...patch,
+		embedParams: {
+			...base.embedParams ?? {},
+			...patch.embedParams ?? {}
+		}
+	});
+}
+function mergeAppMeta(base, patch) {
+	if (!base && !patch) return void 0;
+	if (!base) return patch;
+	if (!patch) return base;
+	return {
+		...base,
+		...patch,
+		capabilities: patch.capabilities.length > 0 ? patch.capabilities : base.capabilities,
+		viewer: mergeViewer(base.viewer, patch.viewer)
+	};
+}
+function resolveAppOverride(packageName, appMeta) {
+	const override = LOCAL_APP_OVERRIDES[packageName];
+	if (!override) return appMeta;
+	const base = appMeta ?? {
+		displayName: override.displayName ?? packageName.replace(/^@elizaos\/app-/, ""),
+		category: override.category ?? "game",
+		launchType: override.launchType ?? "url",
+		launchUrl: override.launchUrl ?? null,
+		icon: null,
+		capabilities: override.capabilities ?? [],
+		minPlayers: null,
+		maxPlayers: null,
+		viewer: override.viewer
+	};
+	return {
+		...base,
+		displayName: override.displayName ?? base.displayName,
+		category: override.category ?? base.category,
+		launchType: override.launchType ?? base.launchType,
+		launchUrl: override.launchUrl !== void 0 ? override.launchUrl : base.launchUrl,
+		capabilities: override.capabilities !== void 0 ? override.capabilities : base.capabilities,
+		viewer: mergeViewer(base.viewer, override.viewer)
+	};
+}
+
+//#endregion
+export { mergeAppMeta, resolveAppOverride, sanitizeSandbox };