@rage-against-the-pixel/unity-cli 3.0.2 → 4.0.1

package/dist/unity-installer.js

@@ -0,0 +1,1018 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnityInstaller = void 0;
+exports.resolveEditorExecutable = resolveEditorExecutable;
+exports.moveMacInstalledItem = moveMacInstalledItem;
+exports.getExecutableArchitectures = getExecutableArchitectures;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const crypto_1 = require("crypto");
+const child_process_1 = require("child_process");
+const logging_1 = require("./logging");
+const unity_editor_1 = require("./unity-editor");
+const unity_version_1 = require("./unity-version");
+const unity_cli_1 = require("./unity-cli");
+const process_tracker_1 = require("./process-tracker");
+const utilities_1 = require("./utilities");
+const unity_releases_api_1 = require("@rage-against-the-pixel/unity-releases-api");
+/** Exit codes the official CLI documents as retryable: network, install locked and timeout. */
+const RETRYABLE_EXIT_CODES = [7, 9, 14];
+/**
+ * Packages the Unity Linux Editor needs that Ubuntu runners do not ship.
+ * Some of them are only in jammy, so its archive is added as a source.
+ */
+const LINUX_EDITOR_DEPENDENCIES_SCRIPT = `#!/bin/sh
+set -e
+# an Ubuntu jammy source only works on Ubuntu; a Debian or other apt host would break its own apt-get update
+if grep -qs '^ID=ubuntu$' /etc/os-release; then
+  if [ ! -f /etc/apt/sources.list.d/jammy.list ]; then
+    echo "deb https://archive.ubuntu.com/ubuntu jammy main universe" > /etc/apt/sources.list.d/jammy.list
+  fi
+  # jammy only supplies packages the host release lacks; it never replaces the host's own packages
+  printf 'Package: *\\nPin: release n=jammy\\nPin-Priority: 100\\n' > /etc/apt/preferences.d/unity-cli-jammy
+fi
+export DEBIAN_FRONTEND=noninteractive
+# a stalled mirror must not hold the job: apt retries slow requests, and each step has a hard limit
+APT_OPTS="-o Acquire::http::Timeout=30 -o Acquire::https::Timeout=30 -o Acquire::Retries=3 -o DPkg::Lock::Timeout=120"
+timeout 300 apt-get $APT_OPTS update
+# without pulseaudio, FMOD logs audio device errors on 2019 and 2020 editors; it pulls in about 38 MB,
+# which the runners' Azure mirror has taken over 10 minutes to serve
+timeout 1200 apt-get $APT_OPTS install -y --no-install-recommends xvfb libgtk2.0-0 libglu1-mesa libgconf-2-4 libncurses5 pulseaudio
+`;
+/** ffmpeg is only for video capture and import, so it is opt-in with UNITY_CLI_LINUX_FFMPEG=true. */
+const LINUX_FFMPEG_SCRIPT = `timeout 300 apt-get $APT_OPTS install -y --no-install-recommends ffmpeg || echo "Skipped ffmpeg: the install did not finish"
+`;
+/**
+ * SHA-256 of the fixed installers unity-cli downloads, recorded from the files Unity and Ubuntu serve today.
+ * A download that does not match is deleted instead of installed.
+ */
+const PINNED_DOWNLOAD_SHA256 = {
+    'https://beta.unity3d.com/download/UnitySetup-4.7.2.exe': '30e462dfe9c2ef176e4d1c78742ab777099ae5cfab3b46502af6c426b7e4e8a7',
+    'https://beta.unity3d.com/download/unity-4.7.2.dmg': '2fcaa916624b2eecc1686a943d5b7806fb5bdaf01df7b4a544103f114b85f40b',
+    'https://archive.ubuntu.com/ubuntu/pool/main/o/openssl/libssl1.0.0_1.0.2g-1ubuntu4.20_amd64.deb': '8003f9866297dd0fe77cc771470a06803d1d1b860350ad91dd212e38c36a20d2',
+    'https://archive.ubuntu.com/ubuntu/pool/main/o/openssl/libssl1.1_1.1.0g-2ubuntu4_amd64.deb': '82e424d50e144320319414a1964d3a980abde4bc39fc7d8c2885819328cb5cb4',
+};
+/** Unity 5.x target support installer names, keyed by module id. */
+/** The PlaybackEngines folder each archive module installs into, where it differs from `<name>Support`. */
+const ARCHIVE_PLAYBACK_ENGINE_FOLDERS = {
+    'Android': 'AndroidPlayer',
+    'Linux': 'LinuxStandaloneSupport',
+    'Mac': 'MacStandaloneSupport',
+    'Windows': 'WindowsStandaloneSupport',
+};
+const ARCHIVE_MODULE_NAMES = {
+    'android': 'Android',
+    'ios': 'iOS',
+    'appletv': 'AppleTV',
+    'webgl': 'WebGL',
+    'linux': 'Linux',
+    'linux-il2cpp': 'Linux',
+    'mac': 'Mac',
+    'mac-il2cpp': 'Mac',
+    'windows': 'Windows',
+    'windows-il2cpp': 'Windows',
+    'universal-windows-platform': 'Metro',
+    'facebook-games': 'Facebook-Games',
+    'samsungtv': 'Samsung-TV',
+    'tizen': 'Tizen',
+};
+/**
+ * Finds or installs Unity Editors.
+ * - 2017.4 and newer install through the official Unity CLI (`unity install`).
+ * - 5.x installs from Unity's download archive, because the official CLI reads one-digit majors as Unity 6 shorthand.
+ * - 4.x installs from Unity's legacy installers.
+ */
+class UnityInstaller {
+    logger = logging_1.Logger.instance;
+    cli;
+    /** The 5.x release being installed from the archive, and its installers' published integrity values. */
+    archiveVersion;
+    archiveIntegrity;
+    /**
+     * @param cli The official Unity CLI to use. Installed on demand when omitted.
+     */
+    constructor(cli = undefined) {
+        this.cli = cli;
+    }
+    /**
+     * Gets the official Unity CLI, installing it when needed.
+     */
+    async GetCli() {
+        if (!this.cli) {
+            this.cli = await unity_cli_1.UnityCli.Get();
+        }
+        return this.cli;
+    }
+    /**
+     * Sets the directory editors are installed to.
+     * @param installPath The directory to install editors to.
+     */
+    async SetInstallPath(installPath) {
+        const cli = await this.GetCli();
+        await cli.SetInstallPath(path.resolve(installPath));
+    }
+    /**
+     * Gets the directory editors are installed to.
+     */
+    async GetInstallPath() {
+        const cli = await this.GetCli();
+        return await cli.GetInstallPath();
+    }
+    /**
+     * Finds the requested Unity Editor, installing it and any missing modules when needed.
+     * @param unityVersion The Unity version to find or install. Partial versions such as 2021.3.x resolve to the newest matching release.
+     * @param modules The module ids to install alongside the editor.
+     * @param channels The release channels to accept when resolving a partial version: f, p, b, a or x. Default is ['f'].
+     */
+    async GetEditor(unityVersion, modules = [], channels = ['f']) {
+        this.logger.ci(`Getting release info for Unity ${unityVersion.toString()}...`);
+        const resolvedVersion = await this.resolveVersion(unityVersion, channels);
+        let editorPath;
+        if (resolvedVersion.isLegacy()) {
+            editorPath = await this.installLegacyEditor(resolvedVersion);
+        }
+        else if (resolvedVersion.isLessThan('2017.0.0')) {
+            editorPath = await this.installArchiveEditor(resolvedVersion, modules);
+        }
+        else {
+            editorPath = await this.installCliEditor(resolvedVersion, modules);
+        }
+        await fs.promises.access(editorPath, fs.constants.X_OK);
+        await this.patchBeeBackend(editorPath);
+        return new unity_editor_1.UnityEditor(path.normalize(editorPath), resolvedVersion);
+    }
+    /**
+     * Resolves a partial or changeset-less version to an exact release with its changeset.
+     * 4.x versions are returned as they are, since no release service lists them.
+     * @param unityVersion The requested version.
+     * @param channels The release channels to accept.
+     */
+    async resolveVersion(unityVersion, channels = ['f']) {
+        if (unityVersion.isLegacy() || (unityVersion.isFullyQualified() && unityVersion.changeset)) {
+            return unityVersion;
+        }
+        try {
+            const release = await UnityInstaller.GetEditorReleaseInfo(unityVersion, channels);
+            return new unity_version_1.UnityVersion(release.version, release.shortRevision, unityVersion.architecture);
+        }
+        catch (error) {
+            // fail closed for partial versions: never install "6000.6" and hope it picks a release
+            if (!unityVersion.isFullyQualified()) {
+                const message = error instanceof Error ? error.message : String(error);
+                throw new Error(`Failed to resolve Unity ${unityVersion.toString()} for channel(s) [${channels.join(', ')}]: ${message}`);
+            }
+            this.logger.warn(`Failed to get Unity release info for ${unityVersion.toString()}! falling back to the release notes page...\n${error}`);
+            try {
+                return await UnityInstaller.fallbackVersionLookup(unityVersion);
+            }
+            catch (fallbackError) {
+                this.logger.warn(`Failed to lookup changeset for Unity ${unityVersion.toString()}!\n${fallbackError}`);
+                return unityVersion;
+            }
+        }
+    }
+    async installCliEditor(unityVersion, modules) {
+        const cli = await this.GetCli();
+        let editorPath = await this.findCliEditor(cli, unityVersion);
+        const requestedModules = modules.length > 0 ? await this.filterModules(cli, unityVersion, modules) : [];
+        if (!editorPath) {
+            if (process.platform === 'linux') {
+                await this.installLinuxDependencies(unityVersion);
+            }
+            this.logger.ci(`Installing Unity ${unityVersion.toString()}...`);
+            const args = ['install', unityVersion.version];
+            if (unityVersion.changeset) {
+                args.push('--changeset', unityVersion.changeset);
+            }
+            args.push('--architecture', unityVersion.architecture.toLowerCase());
+            if (requestedModules.length > 0) {
+                for (const module of requestedModules) {
+                    this.logger.ci(`  > with module: ${module}`);
+                }
+                args.push('--module', ...requestedModules, '--child-modules');
+            }
+            args.push('--accept-eula', '--yes');
+            await this.execWithRetry(cli, args);
+            editorPath = await this.findCliEditor(cli, unityVersion);
+            if (!editorPath) {
+                throw new Error(`Unity ${unityVersion.toString()} was installed, but its editor could not be found`);
+            }
+        }
+        else if (requestedModules.length > 0) {
+            this.logger.ci(`Installing modules for Unity ${unityVersion.toString()}: ${requestedModules.join(', ')}`);
+            await this.execWithRetry(cli, [
+                'install-modules',
+                '--editor-version', unityVersion.version,
+                '--architecture', unityVersion.architecture.toLowerCase(),
+                '--module', ...requestedModules,
+                '--child-modules',
+                '--accept-eula',
+                '--yes'
+            ]);
+        }
+        if (unityVersion.isGreaterThanOrEqualTo('6000.0.0')) {
+            // so the editor opens without the terms dialog
+            const result = await cli.Run(['terms', 'accept', unityVersion.version, '--architecture', unityVersion.architecture.toLowerCase(), '--yes']);
+            if (result.exitCode !== 0) {
+                this.logger.debug(`unity terms accept exited with code ${result.exitCode}:\n${result.stdout}${result.stderr}`);
+            }
+        }
+        return editorPath;
+    }
+    async execWithRetry(cli, args) {
+        let result = await cli.Run(args, { stream: true });
+        if (RETRYABLE_EXIT_CODES.includes(result.exitCode)) {
+            this.logger.warn(`unity ${args[0]} failed with exit code ${result.exitCode}, retrying...`);
+            result = await cli.Run(args[0] === 'install' ? [...args, '--resume'] : args, { stream: true });
+        }
+        // install-modules fails when every requested module is already installed
+        if (result.exitCode !== 0 && args[0] === 'install-modules' && `${result.stdout}${result.stderr}`.includes('No modules found to install')) {
+            this.logger.info('The requested modules are already installed.');
+            return;
+        }
+        if (result.exitCode !== 0) {
+            throw new Error(`unity ${args.join(' ')} failed with exit code ${result.exitCode}`);
+        }
+    }
+    /**
+     * Drops modules the release does not offer, since `unity install` fails on an unknown module id.
+     */
+    async filterModules(cli, unityVersion, modules) {
+        const { exitCode, envelope } = await cli.RunJson(['editors', 'info', unityVersion.version]);
+        const available = envelope?.data?.modules?.map(module => module.id);
+        if (exitCode !== 0 || !available || available.length === 0) {
+            this.logger.debug(`Could not read the module list for Unity ${unityVersion.version}, requesting modules as given`);
+            return [...modules];
+        }
+        const supported = [];
+        for (const module of modules) {
+            if (available.includes(module)) {
+                supported.push(module);
+            }
+            else {
+                this.logger.warn(`Unity ${unityVersion.version} has no ${module} module on ${process.platform}, skipping it`);
+            }
+        }
+        return supported;
+    }
+    /**
+     * Looks up an installed editor with `unity editors path`, registering one that sits in the install path but that the CLI does not know about yet.
+     */
+    async findCliEditor(cli, unityVersion) {
+        const { exitCode, envelope } = await cli.RunJson(['editors', 'path', unityVersion.version]);
+        // editors path takes no architecture, so the binary is checked to not return another architecture's install
+        const matchesArchitecture = (editorPath) => {
+            const architectures = getExecutableArchitectures(editorPath);
+            const matches = !architectures || architectures.includes(unityVersion.architecture);
+            if (!matches) {
+                this.logger.debug(`Skipping ${editorPath}: built for ${architectures.join(', ')}, not ${unityVersion.architecture}`);
+            }
+            return matches;
+        };
+        if (exitCode === 0 && envelope?.success !== false) {
+            const editorPath = resolveEditorExecutable((0, unity_cli_1.FindAbsolutePath)(envelope?.data));
+            if (editorPath && matchesArchitecture(editorPath)) {
+                this.logger.debug(`Found installed editor: "${editorPath}"`);
+                return editorPath;
+            }
+        }
+        let installPath;
+        try {
+            installPath = await cli.GetInstallPath();
+        }
+        catch (error) {
+            this.logger.debug(`${error}`);
+            return undefined;
+        }
+        // the architecture-specific folder first; the plain one only when its binary is the requested architecture
+        const candidates = [
+            path.join(installPath, `${unityVersion.version}-${unityVersion.architecture.toLowerCase()}`),
+            path.join(installPath, unityVersion.version),
+        ];
+        for (const candidate of candidates) {
+            const editorPath = resolveEditorExecutable(candidate);
+            if (editorPath && matchesArchitecture(editorPath)) {
+                this.logger.info(`Registering existing Unity ${unityVersion.version} at ${editorPath}`);
+                const result = await cli.Run(['editors', 'add', editorPath]);
+                if (result.exitCode !== 0) {
+                    this.logger.warn(`unity editors add exited with code ${result.exitCode}`);
+                }
+                return editorPath;
+            }
+        }
+        return undefined;
+    }
+    async getLegacyInstallPath() {
+        try {
+            return await this.GetInstallPath();
+        }
+        catch (error) {
+            this.logger.debug(`Falling back to the default editor install path: ${error}`);
+            switch (process.platform) {
+                case 'win32':
+                    return path.join(process.env.ProgramFiles || 'C:\\Program Files', 'Unity', 'Hub', 'Editor');
+                case 'darwin':
+                    return '/Applications/Unity/Hub/Editor';
+                default:
+                    return path.join(os.homedir(), 'Unity', 'Hub', 'Editor');
+            }
+        }
+    }
+    /**
+     * Installs Unity 5.x from the download archive.
+     */
+    async installArchiveEditor(unityVersion, modules) {
+        if (!unityVersion.changeset) {
+            throw new Error(`Unity ${unityVersion.toString()} needs a changeset to install from the download archive`);
+        }
+        UnityInstaller.assertArchiveVersion(unityVersion);
+        this.archiveVersion = unityVersion;
+        this.archiveIntegrity = undefined;
+        const installPath = await this.getLegacyInstallPath();
+        const installDir = path.join(installPath, unityVersion.version);
+        const baseUrl = `https://download.unity3d.com/download_unity/${unityVersion.changeset}`;
+        const moduleNames = this.getArchiveModuleNames(unityVersion, modules);
+        switch (process.platform) {
+            case 'win32': {
+                let editorPath = resolveEditorExecutable(installDir);
+                if (!editorPath) {
+                    this.logger.ci(`Installing Unity ${unityVersion.toString()}...`);
+                    await this.runWindowsInstaller(`${baseUrl}/Windows64EditorInstaller/UnitySetup64-${unityVersion.version}.exe`, installDir);
+                    editorPath = resolveEditorExecutable(installDir);
+                }
+                if (!editorPath) {
+                    throw new Error(`Failed to install Unity ${unityVersion.toString()} to ${installDir}`);
+                }
+                for (const moduleName of moduleNames) {
+                    const engineFolder = ARCHIVE_PLAYBACK_ENGINE_FOLDERS[moduleName] ?? `${moduleName}Support`;
+                    // Windows paths are case-insensitive, so the folder name's case does not matter here
+                    if (fs.existsSync(path.join(installDir, 'Editor', 'Data', 'PlaybackEngines', engineFolder))) {
+                        continue;
+                    }
+                    this.logger.ci(`  > with module: ${moduleName}`);
+                    await this.runWindowsInstaller(`${baseUrl}/TargetSupportInstaller/UnitySetup-${moduleName}-Support-for-Editor-${unityVersion.version}.exe`, installDir);
+                }
+                return editorPath;
+            }
+            case 'darwin': {
+                let editorPath = resolveEditorExecutable(installDir);
+                const modulePackages = moduleNames.map(name => `${baseUrl}/MacEditorTargetInstaller/UnitySetup-${name}-Support-for-Editor-${unityVersion.version}.pkg`);
+                if (editorPath) {
+                    if (modulePackages.length > 0) {
+                        // the target support packages install into /Applications/Unity/PlaybackEngines, so they are moved into this editor afterwards
+                        this.logger.ci(`Installing modules for Unity ${unityVersion.toString()}: ${moduleNames.join(', ')}`);
+                        await this.installMacPackages(modulePackages);
+                        await this.moveMacPlaybackEngines(installDir);
+                    }
+                    return editorPath;
+                }
+                this.logger.ci(`Installing Unity ${unityVersion.toString()}...`);
+                await this.installMacPackages([`${baseUrl}/MacEditorInstaller/Unity-${unityVersion.version}.pkg`, ...modulePackages]);
+                await this.moveMacApplicationsUnity(installDir);
+                editorPath = resolveEditorExecutable(installDir);
+                if (!editorPath) {
+                    throw new Error(`Failed to install Unity ${unityVersion.toString()} to ${installDir}`);
+                }
+                return editorPath;
+            }
+            default:
+                throw new Error(`Unity ${unityVersion.toString()} is not supported on ${process.platform}`);
+        }
+    }
+    /**
+     * Gets the checksum a download must match before it is installed: a pinned SHA-256 for the fixed installers,
+     * or the Unity Releases API integrity value for 5.x archive installers. Fails closed when neither is known.
+     * @param url The download URL.
+     */
+    async getDownloadOptions(url) {
+        const pinned = PINNED_DOWNLOAD_SHA256[url];
+        if (pinned) {
+            return { sha256: pinned };
+        }
+        const archive = url.match(/^https:\/\/download\.unity3d\.com\/download_unity\/([0-9a-f]{12})\//);
+        if (archive && this.archiveVersion) {
+            if (!this.archiveIntegrity) {
+                this.archiveIntegrity = await UnityInstaller.getReleaseIntegrity(this.archiveVersion);
+            }
+            const integrity = this.archiveIntegrity.get(url);
+            if (integrity) {
+                return { integrity };
+            }
+        }
+        throw new Error(`No checksum is known for ${url}, so it is not installed`);
+    }
+    /**
+     * Maps each installer URL of a release (editor and modules) to the integrity value the Unity Releases API publishes for it.
+     * @param unityVersion The exact release.
+     */
+    static async getReleaseIntegrity(unityVersion) {
+        const integrity = new Map();
+        const releasesClient = new unity_releases_api_1.UnityReleasesClient();
+        const { data, error } = await releasesClient.api.Release.getUnityReleases({
+            url: '/unity/editor/release/v1/releases',
+            query: { version: unityVersion.version, limit: 5 },
+        });
+        if (error) {
+            throw new Error(`Failed to read the checksums for Unity ${unityVersion.version}: ${JSON.stringify(error)}`);
+        }
+        const collect = (entries) => {
+            if (!Array.isArray(entries)) {
+                return;
+            }
+            for (const entry of entries) {
+                if (entry.url && entry.integrity) {
+                    integrity.set(entry.url, entry.integrity);
+                }
+                collect(entry.modules);
+            }
+        };
+        for (const release of data?.results ?? []) {
+            if (release.version === unityVersion.version) {
+                collect(release.downloads);
+            }
+        }
+        return integrity;
+    }
+    getArchiveModuleNames(unityVersion, modules) {
+        const hostModule = process.platform === 'win32' ? 'Windows' : process.platform === 'darwin' ? 'Mac' : 'Linux';
+        const names = [];
+        for (const module of modules) {
+            const name = ARCHIVE_MODULE_NAMES[module];
+            if (!name) {
+                this.logger.warn(`Unity ${unityVersion.version} has no ${module} module in the download archive, skipping it`);
+            }
+            else if (name !== hostModule && !names.includes(name)) {
+                names.push(name);
+            }
+        }
+        return names;
+    }
+    /**
+     * Runs a Unity NSIS installer silently. NSIS needs `/D=` last and unquoted, so the command line is passed verbatim, without a shell.
+     */
+    async runWindowsInstaller(url, installDir) {
+        if (/["\r\n]/.test(installDir)) {
+            throw new Error(`Invalid install directory: ${installDir}`);
+        }
+        const installerPath = tempInstallerPath('.exe');
+        await (0, utilities_1.DownloadFile)(url, installerPath, await this.getDownloadOptions(url));
+        this.logger.info(`Running ${path.basename(url)}...`);
+        try {
+            const exitCode = await new Promise((resolve, reject) => {
+                const child = (0, child_process_1.spawn)(installerPath, ['/S', `/D=${installDir}`], {
+                    shell: false,
+                    stdio: 'ignore',
+                    windowsVerbatimArguments: true,
+                });
+                child.on('error', reject);
+                child.on('close', (code) => resolve(code ?? 1));
+            });
+            if (exitCode !== 0) {
+                throw new Error(`${path.basename(url)} failed with exit code ${exitCode}`);
+            }
+        }
+        finally {
+            await fs.promises.rm(installerPath, { force: true });
+        }
+    }
+    async installMacPackages(urls) {
+        for (const url of urls) {
+            const pkgPath = tempInstallerPath('.pkg');
+            await (0, utilities_1.DownloadFile)(url, pkgPath, await this.getDownloadOptions(url));
+            try {
+                await (0, utilities_1.Exec)('sudo', ['installer', '-pkg', pkgPath, '-target', '/'], { silent: true, showCommand: true });
+            }
+            finally {
+                await fs.promises.rm(pkgPath, { force: true });
+            }
+        }
+    }
+    /**
+     * Moves target support that macOS packages installed to /Applications/Unity/PlaybackEngines into an existing versioned editor.
+     */
+    async moveMacPlaybackEngines(targetPath) {
+        const sourcePath = path.join('/Applications', 'Unity', 'PlaybackEngines');
+        if (!fs.existsSync(sourcePath)) {
+            throw new Error(`The module packages did not install anything into ${sourcePath}`);
+        }
+        const destinationPath = path.join(targetPath, 'PlaybackEngines');
+        await fs.promises.mkdir(destinationPath, { recursive: true });
+        // the parent too, since removing PlaybackEngines afterwards needs write permission on it
+        await claimMacInstalledItem(path.dirname(sourcePath), false);
+        await claimMacInstalledItem(sourcePath, true);
+        for (const item of await fs.promises.readdir(sourcePath)) {
+            await moveMacInstalledItem(path.join(sourcePath, item), path.join(destinationPath, item));
+        }
+        await fs.promises.rm(sourcePath, { recursive: true, force: true });
+    }
+    /**
+     * Moves an editor that a macOS package installed to /Applications/Unity into its versioned folder.
+     */
+    async moveMacApplicationsUnity(targetPath) {
+        const unityAppPath = path.join('/Applications', 'Unity');
+        if (!fs.existsSync(path.join(unityAppPath, 'Unity.app'))) {
+            throw new Error('Failed to find /Applications/Unity/Unity.app after installation.');
+        }
+        this.logger.debug(`Moving ${unityAppPath} to ${targetPath}...`);
+        await fs.promises.mkdir(targetPath, { recursive: true });
+        // the folder itself, so its entries can be moved out; the Hub folder inside it is left as it is
+        await claimMacInstalledItem(unityAppPath, false);
+        for (const item of await fs.promises.readdir(unityAppPath)) {
+            // the editor install path itself lives in /Applications/Unity/Hub
+            if (item === 'Hub') {
+                continue;
+            }
+            const source = path.join(unityAppPath, item);
+            await claimMacInstalledItem(source, true);
+            await moveMacInstalledItem(source, path.join(targetPath, item));
+        }
+        await fs.promises.chmod(targetPath, 0o755);
+    }
+    /**
+     * Rejects versions and changesets that are not plain Unity release identifiers before they become URLs and paths.
+     */
+    static assertArchiveVersion(unityVersion) {
+        if (!/^\d{1,2}\.\d{1,2}\.\d{1,2}(?:[abcfpx]\d{1,3})?$/.test(unityVersion.version)) {
+            throw new Error(`Invalid Unity version: ${unityVersion.version}`);
+        }
+        if (unityVersion.changeset && !/^[0-9a-f]{12}$/i.test(unityVersion.changeset)) {
+            throw new Error(`Invalid Unity changeset: ${unityVersion.changeset}`);
+        }
+    }
+    /**
+     * Installs Unity 4.x from Unity's legacy installers.
+     */
+    async installLegacyEditor(unityVersion) {
+        UnityInstaller.assertArchiveVersion(unityVersion);
+        const installPath = await this.getLegacyInstallPath();
+        const installDir = path.join(installPath, `Unity ${unityVersion.version}`);
+        let editorPath = resolveEditorExecutable(installDir);
+        if (editorPath) {
+            return editorPath;
+        }
+        this.logger.ci(`Installing Unity ${unityVersion.toString()}...`);
+        switch (process.platform) {
+            case 'win32': {
+                await this.runWindowsInstaller(`https://beta.unity3d.com/download/UnitySetup-${unityVersion.version}.exe`, installDir);
+                break;
+            }
+            case 'darwin': {
+                const url = `https://beta.unity3d.com/download/unity-${unityVersion.version}.dmg`;
+                const installerPath = tempInstallerPath('.dmg');
+                await (0, utilities_1.DownloadFile)(url, installerPath, await this.getDownloadOptions(url));
+                let mountPoint = '';
+                try {
+                    const output = await (0, utilities_1.Exec)('hdiutil', ['attach', installerPath, '-nobrowse'], { silent: true, showCommand: true });
+                    const mountPointMatch = output.match(/\/Volumes\/Unity Installer.*$/m);
+                    if (!mountPointMatch || mountPointMatch.length === 0) {
+                        throw new Error(`Failed to find mount point in hdiutil output: ${output}`);
+                    }
+                    mountPoint = mountPointMatch[0];
+                    const pkgPath = path.join(mountPoint, 'Unity.pkg');
+                    await fs.promises.access(pkgPath, fs.constants.R_OK);
+                    await (0, utilities_1.Exec)('sudo', ['installer', '-pkg', pkgPath, '-target', '/', '-verboseR'], { silent: true, showCommand: true });
+                    await this.moveMacApplicationsUnity(installDir);
+                }
+                finally {
+                    try {
+                        if (mountPoint.length > 0) {
+                            await (0, utilities_1.Exec)('hdiutil', ['detach', mountPoint, '-quiet'], { silent: true, showCommand: true });
+                        }
+                    }
+                    finally {
+                        await fs.promises.rm(installerPath, { force: true });
+                    }
+                }
+                break;
+            }
+            default:
+                throw new Error(`Unity ${unityVersion.toString()} is not supported on ${process.platform}`);
+        }
+        editorPath = resolveEditorExecutable(installDir);
+        if (!editorPath) {
+            throw new Error(`Failed to install Unity ${unityVersion.toString()} to ${installDir}`);
+        }
+        return editorPath;
+    }
+    /**
+     * Installs the system packages the Linux editor needs, and the older libssl that 2019.1 to 2021.x link against.
+     */
+    async installLinuxDependencies(unityVersion) {
+        if (process.env.UNITY_CLI_LINUX_DEPENDENCIES_INSTALLED !== 'true') {
+            try {
+                // streamed, so a slow mirror shows where it stalls
+                // sudo drops the caller's environment, so the opt-in is read here rather than in the script
+                const ffmpeg = process.env.UNITY_CLI_LINUX_FFMPEG === 'true' ? LINUX_FFMPEG_SCRIPT : '';
+                await (0, utilities_1.Exec)('sudo', ['sh', '-c', `${LINUX_EDITOR_DEPENDENCIES_SCRIPT}${ffmpeg}apt-get clean\n`], { silent: false, showCommand: true });
+                process.env.UNITY_CLI_LINUX_DEPENDENCIES_INSTALLED = 'true';
+                this.logger.CI_setEnvironmentVariable('UNITY_CLI_LINUX_DEPENDENCIES_INSTALLED', 'true');
+            }
+            catch (error) {
+                this.logger.warn(`Failed to install Linux editor dependencies: ${error}`);
+            }
+        }
+        const arch = process.arch === 'x64' ? 'amd64' : process.arch;
+        let debName;
+        if (['2019.1', '2019.2'].some(v => unityVersion.version.startsWith(v))) {
+            debName = `libssl1.0.0_1.0.2g-1ubuntu4.20_${arch}.deb`;
+        }
+        else if (['2019.3', '2019.4'].some(v => unityVersion.version.startsWith(v)) ||
+            unityVersion.version.startsWith('2020.') ||
+            unityVersion.version.startsWith('2021.')) {
+            debName = `libssl1.1_1.1.0g-2ubuntu4_${arch}.deb`;
+        }
+        if (debName) {
+            const downloadPath = tempInstallerPath('.deb');
+            const url = `https://archive.ubuntu.com/ubuntu/pool/main/o/openssl/${debName}`;
+            await (0, utilities_1.DownloadFile)(url, downloadPath, await this.getDownloadOptions(url));
+            try {
+                await (0, utilities_1.Exec)('sudo', ['dpkg', '-i', downloadPath]);
+            }
+            finally {
+                await fs.promises.rm(downloadPath, { force: true });
+            }
+        }
+    }
+    /**
+     * Patches the Bee Backend for Unity Linux Editor.
+     * https://discussions.unity.com/t/linux-editor-stuck-on-loading-because-of-bee-backend-w-workaround/854480
+     * @param editorPath The path to the Unity Editor executable.
+     */
+    async patchBeeBackend(editorPath) {
+        if (process.platform === 'linux') {
+            const dataPath = path.join(path.dirname(editorPath), 'Data');
+            const beeBackend = path.join(dataPath, 'bee_backend');
+            const dotBeeBackend = path.join(dataPath, '.bee_backend');
+            // linking fails with EEXIST once patched and ENOENT without a bee_backend, so nothing is checked before it is used
+            try {
+                await fs.promises.link(beeBackend, dotBeeBackend);
+            }
+            catch (error) {
+                const code = error.code;
+                if (code === 'ENOENT') {
+                    return;
+                }
+                if (code !== 'EEXIST') {
+                    throw error;
+                }
+                // patched before; only a run that stopped before the wrapper landed leaves .bee_backend without bee_backend
+                try {
+                    await fs.promises.access(beeBackend);
+                    return;
+                }
+                catch {
+                    this.logger.ci('Restoring the Bee Backend wrapper an earlier run did not finish...');
+                }
+            }
+            this.logger.ci(`Patching Unity Linux Editor for Bee Backend...`);
+            const wrapperSource = `#!/bin/bash
+# https://discussions.unity.com/t/linux-editor-stuck-on-loading-because-of-bee-backend-w-workaround/854480
+set -e
+args=("$@")
+for ((i = 0; i < "\${#args[@]}"; ++i)); do
+    case \${args[i]} in
+    --stdin-canary)
+        unset "args[i]"
+        break
+        ;;
+    esac
+done
+"$(dirname "$0")/.$(basename "$0")" "\${args[@]}"`;
+            // written under a temporary name and renamed over bee_backend, so a stop at any point leaves either the
+            // original (still linked as .bee_backend) or the whole wrapper, never neither
+            const tempWrapper = path.join(dataPath, `.bee_backend.${(0, crypto_1.randomUUID)()}.tmp`);
+            await fs.promises.writeFile(tempWrapper, wrapperSource, { encoding: 'utf-8', mode: 0o755, flag: 'wx' });
+            await fs.promises.rename(tempWrapper, beeBackend);
+        }
+    }
+    /**
+     * Gets the specified Unity release info from the Unity Releases API.
+     * Supports querying by exact version or by prefix (e.g., "2020", "2020.1", "2021.x", "2021.3.x").
+     * @param unityVersion The Unity version to get the release info for.
+     * @param channels Letter channels to accept (`f`, `p`, `b`, `a`, `x`). Default stable-only.
+     * @returns The Unity release info.
+     */
+    static async GetEditorReleaseInfo(unityVersion, channels = ['f']) {
+        // Prefer querying the releases API with the exact fully-qualified Unity version (e.g., 2022.3.10f1).
+        // If we don't have a fully-qualified version, use the most specific prefix available:
+        //  - "YYYY.M" when provided (e.g., 6000.1)
+        //  - otherwise "YYYY"
+        const fullUnityVersionPattern = /^\d{1,4}\.\d+\.\d+[abcfpx]\d+$/;
+        let version;
+        if (fullUnityVersionPattern.test(unityVersion.version)) {
+            version = unityVersion.version;
+        }
+        else {
+            const match = unityVersion.version.match(/^(\d{1,4})(?:\.(\d+))?/);
+            if (match) {
+                version = match[2] ? `${match[1]}.${match[2]}` : match[1];
+            }
+            else {
+                version = unityVersion.version.split('.')[0];
+            }
+        }
+        const releasesClient = new unity_releases_api_1.UnityReleasesClient();
+        const channelSet = new Set(channels.map(c => c.toLowerCase()));
+        function getPlatform() {
+            switch (process.platform) {
+                case 'darwin':
+                    return ['MAC_OS'];
+                case 'linux':
+                    return ['LINUX'];
+                case 'win32':
+                    return ['WINDOWS'];
+                default:
+                    throw new Error(`Unsupported platform: ${process.platform}`);
+            }
+        }
+        function releaseChannelLetter(releaseVersion) {
+            const m = /^(\d{1,4})\.(\d+)\.(\d+)([abcfpx])(\d+)$/.exec(releaseVersion);
+            return m?.[4];
+        }
+        const request = {
+            url: '/unity/editor/release/v1/releases',
+            query: {
+                version: version,
+                architecture: [unityVersion.architecture],
+                platform: getPlatform(),
+                limit: 10,
+                order: 'RELEASE_DATE_DESC',
+            }
+        };
+        logging_1.Logger.instance.debug(`Get Unity Release: ${JSON.stringify(request, null, 2)}`);
+        async function getRelease() {
+            const { data, error } = await releasesClient.api.Release.getUnityReleases(request);
+            if (error) {
+                throw new Error(`Failed to get Unity releases: ${JSON.stringify(error, null, 2)}`);
+            }
+            if (!data || !data.results || data.results.length === 0) {
+                throw new Error(`No Unity releases found for version: ${version}`);
+            }
+            const releases = (data.results || [])
+                .filter((release) => {
+                const v = release.version;
+                if (v == null || v === '') {
+                    return false;
+                }
+                // Exact FQ request: accept that row regardless of channel filter.
+                if (fullUnityVersionPattern.test(unityVersion.version) && v === unityVersion.version) {
+                    return true;
+                }
+                const letter = releaseChannelLetter(v);
+                return letter != null && channelSet.has(letter);
+            })
+                .map(release => ({
+                unityRelease: release,
+                unityVersion: new unity_version_1.UnityVersion(release.version, release.shortRevision, unityVersion.architecture)
+            }));
+            if (releases.length === 0) {
+                const channelList = [...channelSet].join(',');
+                throw new Error(`No suitable Unity releases (channels: ${channelList}) found for version: ${version}` +
+                    (channelSet.has('f') && channelSet.size === 1
+                        ? `. No stable (f) release for ${version}; use --channel b/a or a fully-qualified version.`
+                        : ''));
+            }
+            releases.sort((a, b) => unity_version_1.UnityVersion.compare(b.unityVersion, a.unityVersion));
+            logging_1.Logger.instance.debug(`Found ${releases.length} matching Unity releases for version: ${version}`);
+            releases.forEach(release => {
+                logging_1.Logger.instance.debug(` - ${release.unityRelease.version} (${release.unityRelease.shortRevision}) - ${release.unityRelease.recommended}`);
+            });
+            return releases[0].unityRelease;
+        }
+        try {
+            return await getRelease();
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('fetch failed')) {
+                // Transient network error, retry once
+                return await getRelease();
+            }
+            throw new Error(`Failed to get Unity releases: ${error}`);
+        }
+    }
+    static async fallbackVersionLookup(unityVersion) {
+        const url = `https://unity.com/releases/editor/whats-new/${unityVersion.version}`;
+        logging_1.Logger.instance.debug(`Fetching release page: "${url}"`);
+        const response = await fetch(url);
+        const responseText = await response.text();
+        if (!response.ok) {
+            throw new Error(`Failed to fetch changeset for Unity ${unityVersion.toString()} [${response.status}] "${url}"`);
+        }
+        const match = responseText.match(/unityhub:\/\/(?<version>\d+\.\d+\.\d+[abcfpx]?\d*)\/(?<changeset>[a-zA-Z0-9]+)/);
+        if (match && match.groups && match.groups.version && match.groups.changeset) {
+            return new unity_version_1.UnityVersion(match.groups.version, match.groups.changeset, unityVersion.architecture);
+        }
+        throw new Error(`Failed to find changeset for Unity ${unityVersion.toString()} in "${url}"`);
+    }
+    /**
+     * Get the mapping of Unity platform targets to their corresponding module identifiers for the current OS.
+     * @returns A map of Unity platform targets to their corresponding module identifiers for the current OS.
+     */
+    static GetPlatformTargetModuleMap() {
+        const osType = os.type();
+        switch (osType) {
+            case 'Linux':
+                return {
+                    "StandaloneLinux64": "linux-il2cpp",
+                    "Android": "android",
+                    "WebGL": "webgl",
+                    "iOS": "ios",
+                };
+            case 'Darwin':
+                return {
+                    "StandaloneOSX": "mac-il2cpp",
+                    "iOS": "ios",
+                    "Android": "android",
+                    "tvOS": "appletv",
+                    "StandaloneLinux64": "linux-il2cpp",
+                    "WebGL": "webgl",
+                    "VisionOS": "visionos"
+                };
+            case 'Windows_NT':
+                return {
+                    "StandaloneWindows64": "windows-il2cpp",
+                    "WSAPlayer": "universal-windows-platform",
+                    "Android": "android",
+                    "iOS": "ios",
+                    "tvOS": "appletv",
+                    "StandaloneLinux64": "linux-il2cpp",
+                    "Lumin": "lumin",
+                    "WebGL": "webgl",
+                };
+            default:
+                throw Error(`${osType} not supported`);
+        }
+    }
+}
+exports.UnityInstaller = UnityInstaller;
+/**
+ * Resolves an install directory, Editor folder, app bundle or executable to the editor executable.
+ * @param location A path the editor may be under.
+ * @returns The editor executable, or undefined when none is found.
+ */
+function resolveEditorExecutable(location) {
+    if (!location || !fs.existsSync(location)) {
+        return undefined;
+    }
+    if (fs.statSync(location).isFile()) {
+        return location;
+    }
+    let candidates;
+    switch (process.platform) {
+        case 'darwin':
+            candidates = [
+                path.join(location, 'Unity.app', 'Contents', 'MacOS', 'Unity'),
+                path.join(location, 'Contents', 'MacOS', 'Unity'),
+            ];
+            break;
+        case 'win32':
+            candidates = [
+                path.join(location, 'Editor', 'Unity.exe'),
+                path.join(location, 'Unity.exe'),
+            ];
+            break;
+        default:
+            candidates = [
+                path.join(location, 'Editor', 'Unity'),
+                path.join(location, 'Unity'),
+            ];
+            break;
+    }
+    return candidates.find(candidate => fs.existsSync(candidate) && fs.statSync(candidate).isFile());
+}
+/**
+ * A fresh temp path for a downloaded installer. The name is random rather than taken from the URL,
+ * so nothing from the requested version reaches the installer command line.
+ * @param extension The installer's file extension, e.g. .pkg.
+ */
+function tempInstallerPath(extension) {
+    return path.join((0, utilities_1.GetTempDir)(), `unity-installer-${(0, crypto_1.randomUUID)()}${extension}`);
+}
+/**
+ * Gives the runner's user something a macOS package installed under /Applications/Unity. The installer runs as root,
+ * so its files are root-owned and cannot be moved or removed otherwise, such as PlaybackEngines/AndroidPlayer.
+ * @param source A path under /Applications/Unity, never one from a caller, since it runs as root.
+ * @param recursive Whether to claim everything below it too.
+ */
+async function claimMacInstalledItem(source, recursive) {
+    if (!(0, process_tracker_1.IsPathUnder)(source, path.join('/Applications', 'Unity'))) {
+        throw new Error(`Refusing to take ownership of ${source}`);
+    }
+    const { uid, gid } = os.userInfo();
+    // -h changes a symlink itself, so a broken one does not fail the walk
+    await (0, utilities_1.Exec)('sudo', ['chown', ...(recursive ? ['-R'] : []), '-h', `${uid}:${gid}`, source], { silent: true, showCommand: true });
+    await (0, utilities_1.Exec)('sudo', ['chmod', ...(recursive ? ['-R'] : []), 'u+w', source], { silent: true, showCommand: true });
+}
+/**
+ * Moves something a macOS package installed. Older editors ship symlinks whose targets are gone, such as 5.6's
+ * MonoDevelop.app, which fs.cp fails on, so links are moved or recreated as they are.
+ */
+async function moveMacInstalledItem(source, destination) {
+    await fs.promises.rm(destination, { recursive: true, force: true });
+    try {
+        await fs.promises.rename(source, destination);
+    }
+    catch (error) {
+        // the install path can be on another volume than /Applications
+        if (error.code !== 'EXDEV') {
+            throw error;
+        }
+        await copyKeepingSymlinks(source, destination);
+        await fs.promises.rm(source, { recursive: true, force: true });
+    }
+}
+async function copyKeepingSymlinks(source, destination) {
+    const stat = await fs.promises.lstat(source);
+    if (stat.isSymbolicLink()) {
+        await fs.promises.symlink(await fs.promises.readlink(source), destination);
+    }
+    else if (stat.isDirectory()) {
+        await fs.promises.mkdir(destination, { mode: stat.mode & 0o7777 });
+        for (const entry of await fs.promises.readdir(source)) {
+            await copyKeepingSymlinks(path.join(source, entry), path.join(destination, entry));
+        }
+    }
+    else {
+        await fs.promises.copyFile(source, destination);
+        await fs.promises.chmod(destination, stat.mode & 0o7777);
+    }
+}
+/**
+ * Reads the CPU architectures of a macOS editor binary from its Mach-O header.
+ * @param executablePath The editor executable.
+ * @returns The architectures, or undefined off macOS or when the header is not recognized, in which case callers accept the editor.
+ */
+function getExecutableArchitectures(executablePath) {
+    if (process.platform !== 'darwin') {
+        return undefined;
+    }
+    const cpuTypes = { 0x01000007: 'X86_64', 0x0100000c: 'ARM64' };
+    let header;
+    try {
+        const fd = fs.openSync(executablePath, 'r');
+        try {
+            header = Buffer.alloc(4096);
+            fs.readSync(fd, header, 0, header.length, 0);
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    catch {
+        return undefined;
+    }
+    const magic = header.readUInt32BE(0);
+    if (magic === 0xcafebabe) {
+        // fat binary: big-endian count, then 20 bytes per architecture with the CPU type first
+        const count = header.readUInt32BE(4);
+        const architectures = [];
+        for (let i = 0; i < count && 8 + i * 20 + 4 <= header.length; i++) {
+            const architecture = cpuTypes[header.readUInt32BE(8 + i * 20)];
+            if (architecture && !architectures.includes(architecture)) {
+                architectures.push(architecture);
+            }
+        }
+        return architectures.length > 0 ? architectures : undefined;
+    }
+    if (magic === 0xcffaedfe) {
+        // thin 64-bit binary, little-endian
+        const architecture = cpuTypes[header.readUInt32LE(4)];
+        return architecture ? [architecture] : undefined;
+    }
+    return undefined;
+}
+//# sourceMappingURL=unity-installer.js.map