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

package/dist/unity-hub.js

@@ -1,1425 +0,0 @@
-"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.UnityHub = exports.LINUX_HUB_EXECUTABLE_LEGACY = exports.LINUX_HUB_EXECUTABLE_MODERN = void 0;
-exports.resolveLinuxHubExecutable = resolveLinuxHubExecutable;
-const fs = __importStar(require("fs"));
-const os = __importStar(require("os"));
-const path = __importStar(require("path"));
-const yaml = __importStar(require("yaml"));
-const asar = __importStar(require("@electron/asar"));
-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 semver_1 = require("semver");
-const utilities_1 = require("./utilities");
-const unity_releases_api_1 = require("@rage-against-the-pixel/unity-releases-api");
-/** First Unity Hub line with native Windows ARM64 installers on the public CDN. */
-const MIN_NATIVE_WINDOWS_ARM64_HUB_VERSION = (0, semver_1.coerce)('3.17.0');
-/** Allowed characters in a Debian package version (no shell metacharacters). */
-const LINUX_HUB_DEB_VERSION_RE = /^[0-9A-Za-z.+~:-]+$/;
-/** Hub 3.20+ Electron Forge deb layout. */
-exports.LINUX_HUB_EXECUTABLE_MODERN = '/usr/lib/unityhub/unityhub';
-/** Hub ≤3.19 fpm / electron-builder layout. */
-exports.LINUX_HUB_EXECUTABLE_LEGACY = '/opt/unityhub/unityhub';
-/**
- * Resolves the Unity Hub binary on Linux.
- * Prefers UNITY_HUB_PATH, then the Hub 3.20+ path, then the legacy /opt path.
- * When neither is present (pre-install), defaults to the modern path.
- */
-function resolveLinuxHubExecutable(envPath = process.env.UNITY_HUB_PATH, existsSync = fs.existsSync) {
-    if (envPath !== undefined && envPath.length > 0) {
-        return envPath;
-    }
-    if (existsSync(exports.LINUX_HUB_EXECUTABLE_MODERN)) {
-        return exports.LINUX_HUB_EXECUTABLE_MODERN;
-    }
-    if (existsSync(exports.LINUX_HUB_EXECUTABLE_LEGACY)) {
-        return exports.LINUX_HUB_EXECUTABLE_LEGACY;
-    }
-    return exports.LINUX_HUB_EXECUTABLE_MODERN;
-}
-/**
- * Fixed bootstrap for Linux Hub apt repo + update index. No user-controlled interpolation (CodeQL).
- * Uses DEB822 .sources (Hub 3.20+) and removes legacy .list to avoid duplicate-source warnings.
- */
-const LINUX_HUB_LINUX_UPDATE_REPO_BOOTSTRAP = `#!/bin/sh
-set -e
-wget -qO - https://hub.unity3d.com/linux/keys/public | gpg --dearmor | sudo tee /usr/share/keyrings/Unity_Technologies_ApS.gpg >/dev/null
-sudo rm -f /etc/apt/sources.list.d/unityhub.list
-sudo tee /etc/apt/sources.list.d/unityhub.sources >/dev/null <<'EOF'
-Types: deb
-URIs: https://hub.unity3d.com/linux/repos/deb
-Suites: stable
-Components: main
-Signed-By: /usr/share/keyrings/Unity_Technologies_ApS.gpg
-EOF
-sudo apt-get update --allow-releaseinfo-change
-`;
-/**
- * First phase of fresh Linux Hub install: machine-id, repo keys, jammy mirror, apt-get update.
- * No user-controlled interpolation. Uses DEB822 .sources (Hub 3.20+).
- */
-const LINUX_HUB_LINUX_INSTALL_BOOTSTRAP = `#!/bin/sh
-set -e
-dbus-uuidgen >/etc/machine-id && mkdir -p /var/lib/dbus/ && ln -sf /etc/machine-id /var/lib/dbus/machine-id
-wget -qO - https://hub.unity3d.com/linux/keys/public | gpg --dearmor | tee /usr/share/keyrings/Unity_Technologies_ApS.gpg >/dev/null
-rm -f /etc/apt/sources.list.d/unityhub.list
-tee /etc/apt/sources.list.d/unityhub.sources >/dev/null <<'EOF'
-Types: deb
-URIs: https://hub.unity3d.com/linux/repos/deb
-Suites: stable
-Components: main
-Signed-By: /usr/share/keyrings/Unity_Technologies_ApS.gpg
-EOF
-echo "deb https://archive.ubuntu.com/ubuntu jammy main universe" | tee /etc/apt/sources.list.d/jammy.list
-apt-get update
-`;
-/**
- * Post-install cleanup and xvfb / unity-hub wrapper setup. Runs as root; no user interpolation.
- * Wrapper resolves Hub 3.20+ (/usr/lib/unityhub) vs legacy (/opt/unityhub) at runtime so apt
- * upgrades that move the binary do not leave a stale path (exit 127).
- */
-const LINUX_HUB_LINUX_INSTALL_POST = `#!/bin/sh
-set -e
-apt-get clean
-sed -i 's/^\\(.*DISPLAY=:.*XAUTHORITY=.*\\)\\( "\\$@" \\)2>&1$/\\1\\2/' /usr/bin/xvfb-run
-command -v unityhub >/dev/null || { echo "Unity Hub installation failed"; exit 1; }
-hubPath=$(readlink -f "$(command -v unityhub)" 2>/dev/null || true)
-if [ -z "$hubPath" ] || [ ! -x "$hubPath" ]; then
-    if [ -x /usr/lib/unityhub/unityhub ]; then
-        hubPath=/usr/lib/unityhub/unityhub
-    elif [ -x /opt/unityhub/unityhub ]; then
-        hubPath=/opt/unityhub/unityhub
-    else
-        echo "Failed to install Unity Hub"
-        exit 1
-    fi
-fi
-tee /usr/bin/unity-hub >/dev/null <<'WRAPPER'
-#!/bin/bash
-if [ -x /usr/lib/unityhub/unityhub ]; then
-  hubBin=/usr/lib/unityhub/unityhub
-elif [ -x /opt/unityhub/unityhub ]; then
-  hubBin=/opt/unityhub/unityhub
-else
-  hubBin=$(readlink -f "$(command -v unityhub)" 2>/dev/null || true)
-fi
-if [ -z "$hubBin" ] || [ ! -x "$hubBin" ]; then
-  echo "Unity Hub binary not found" >&2
-  exit 127
-fi
-exec xvfb-run --auto-servernum "$hubBin" "$@" 2>/dev/null
-WRAPPER
-chmod 777 /usr/bin/unity-hub
-chmod -R 777 "$(dirname "$hubPath")"
-`;
-const LINUX_HUB_LINUX_APT_EXTRAS = [
-    'xvfb',
-    'ffmpeg',
-    'libgtk2.0-0',
-    'libglu1-mesa',
-    'libgconf-2-4',
-    'libncurses5',
-    'pulseaudio',
-];
-class UnityHub {
-    /** The path to the Unity Hub executable. */
-    executable;
-    /** The root directory of the Unity Hub installation. */
-    rootDirectory;
-    /** The file extension for the Unity editor executable. */
-    editorFileExtension;
-    logger = logging_1.Logger.instance;
-    constructor() {
-        switch (process.platform) {
-            case 'win32': {
-                const hubPath = process.env.UNITY_HUB_PATH ?? undefined;
-                if (hubPath !== undefined && hubPath.length > 0) {
-                    this.executable = hubPath;
-                }
-                else {
-                    const pf64 = path.join(process.env.ProgramFiles || 'C:\\Program Files', 'Unity Hub', 'Unity Hub.exe');
-                    const pfx86 = path.join(process.env['ProgramFiles(x86)'] || 'C:\\Program Files (x86)', 'Unity Hub', 'Unity Hub.exe');
-                    // Windows ARM64 images install Hub under WOW64; x64 prefers 64-bit path when present.
-                    if (process.arch === 'arm64') {
-                        this.executable = pfx86;
-                    }
-                    else {
-                        this.executable = fs.existsSync(pf64) ? pf64 : fs.existsSync(pfx86) ? pfx86 : pf64;
-                    }
-                }
-                this.rootDirectory = path.join(this.executable, '../');
-                this.editorFileExtension = '\\Editor\\Unity.exe';
-                break;
-            }
-            case 'darwin':
-                this.executable = process.env.UNITY_HUB_PATH || '/Applications/Unity Hub.app/Contents/MacOS/Unity Hub';
-                this.rootDirectory = path.join(this.executable, '../../../');
-                this.editorFileExtension = '/Unity.app/Contents/MacOS/Unity';
-                break;
-            case 'linux':
-                this.refreshLinuxHubPaths();
-                this.editorFileExtension = '/Editor/Unity';
-                break;
-            default:
-                throw new Error(`Unsupported platform: ${process.platform}`);
-        }
-    }
-    /** Re-resolve Linux Hub executable + root after install/upgrade (Hub 3.20 moved under /usr/lib). */
-    refreshLinuxHubPaths() {
-        this.executable = resolveLinuxHubExecutable();
-        this.rootDirectory = path.join(this.executable, '../');
-    }
-    /**
-     * Some Hub builds (notably Windows headless) occasionally exit non-zero after streaming usable
-     * `editors --releases` / `editors -i` data. Tolerate only when the captured output parses the same
-     * way {@link ListAvailableReleases} / {@link ListInstalledEditors} would (avoids regex false positives).
-     */
-    hubListingExitTolerable(args, hubOutput) {
-        if (!this.isHubEditorListingArgs(args)) {
-            return false;
-        }
-        if (args.includes('--releases')) {
-            return this.parseAvailableReleasesFromHubText(hubOutput).length > 0;
-        }
-        if (args.includes('-i') || args.includes('--installed')) {
-            return hubOutput.includes('installed at');
-        }
-        return false;
-    }
-    isHubEditorListingArgs(args) {
-        return args.length > 0 && args[0] === 'editors' &&
-            (args.includes('--releases') || args.includes('-i') || args.includes('--installed'));
-    }
-    async delayMs(ms) {
-        await new Promise((resolve) => setTimeout(resolve, ms));
-    }
-    /** Same parsing rules as {@link ListAvailableReleases}; must stay in sync. */
-    parseAvailableReleasesFromHubText(output) {
-        return output.split('\n')
-            .map(line => line.trim())
-            .map(line => {
-            const match = line.match(/^(\d{1,4}\.\d+\.\d+[abcfpx]?\d*)/);
-            return match ? match[1] : undefined;
-        })
-            .filter((line) => !!line && /^\d{1,4}\.\d+\.\d+[abcfpx]?\d*/.test(line))
-            .map(line => new unity_version_1.UnityVersion(line))
-            .sort((a, b) => unity_version_1.UnityVersion.compare(b, a));
-    }
-    /** Same parsing rules as {@link ListInstalledEditors}; must stay in sync. */
-    parseInstalledEditorsFromHubText(output) {
-        const paths = output.split('\n')
-            .filter(line => /installed at/.test(line))
-            .map(line => line.trim());
-        const editors = [];
-        const pattern = /(?<version>\d+\.\d+\.\d+[abcfpx]?\d*)\s*(?:\((?<arch>Apple silicon|Intel)\))?\s*,? installed at (?<editorPath>.*)/;
-        const matches = paths.map((line) => line.match(pattern)).filter(match => match && match.groups);
-        if (paths.length !== matches.length) {
-            throw new Error(`Failed to parse all installed Unity Editors!\n > paths: ${JSON.stringify(paths)}\n  > matches: ${JSON.stringify(matches)}`);
-        }
-        for (const match of matches) {
-            if (match && match.groups && match.groups.version && match.groups.editorPath) {
-                const version = new unity_version_1.UnityVersion(match.groups.version, null, match.groups.arch === 'Apple silicon' ? 'ARM64' : match.groups.arch === 'Intel' ? 'X86_64' : undefined);
-                editors.push(new unity_editor_1.UnityEditor(path.normalize(match.groups.editorPath), version));
-            }
-        }
-        editors.sort((a, b) => {
-            if (!a.version && !b.version) {
-                return 0;
-            }
-            if (!a.version) {
-                return 1;
-            }
-            if (!b.version) {
-                return -1;
-            }
-            return unity_version_1.UnityVersion.compare(b.version, a.version);
-        });
-        return editors;
-    }
-    /**
-     * Executes the Unity Hub command with the specified arguments.
-     * @param args Arguments to pass to the Unity Hub executable.
-     * @param options Logging and spawn options for this invocation.
-     * @returns The output from the command.
-     */
-    async Exec(args, options = { silent: this.logger.logLevel > logging_1.LogLevel.CI, showCommand: this.logger.logLevel <= logging_1.LogLevel.CI }) {
-        return this.execImpl(args, options, 0);
-    }
-    /**
-     * @param listingRetryDepth 0 on first attempt; 1 after one listing-only retry (flaky Hub exits on Windows CI).
-     */
-    async execImpl(args, options, listingRetryDepth) {
-        let output = '';
-        let exitCode = 0;
-        const filteredArgs = args.filter(arg => arg !== '--headless' && arg !== '--');
-        const executable = process.platform === 'linux' ? 'unity-hub' : this.executable;
-        const execArgs = process.platform === 'linux' ? ['--headless', ...filteredArgs] : ['--', '--headless', ...filteredArgs];
-        if (options.showCommand) {
-            this.logger.startGroup(`\x1b[34m${executable} ${execArgs.join(' ')}\x1b[0m`);
-        }
-        if (this.executable.includes(path.sep)) {
-            fs.accessSync(this.executable, fs.constants.R_OK | fs.constants.X_OK);
-        }
-        const ignoredLines = [
-            'This error originated either by throwing inside of an async function without a catch block',
-            'Unexpected error attempting to determine if executable file exists',
-            'dri3 extension not supported',
-            'Failed to connect to the bus:',
-            'Error: No modules found to install.',
-            'Checking for beta autoupdate feature for deb/rpm distributions',
-            'Found package-type: deb',
-            'XPC error for connection com.apple.backupd.sandbox.xpc: Connection invalid',
-            'Failed to execute the command due the following, please see \'-- --headless help\' for assistance.',
-            'Unable to move the cache: Access is denied.',
-            'Entities without keys will be embedded directly on the parent entity. If this is intentional, create a `keys` config for `UnityReleaseLabel` that always returns null.',
-            'https://bit.ly/2XbVrpR#15',
-            'Interaction is not allowed with the Security Server." (-25308)',
-            'Network service crashed, restarting service.',
-            'Invalid key: The GraphQL query at the field at',
-            'You have to request `id` or `_id` fields for all selection sets or create a custom `keys` config for `UnityReleaseLabel`.',
-        ];
-        try {
-            exitCode = await new Promise((resolve, reject) => {
-                let isSettled = false; // Has the promise been settled (resolved or rejected)?
-                let isHubTaskCompleteSuccess = false; // Has the Unity Hub tasks completed successfully?
-                let isHubTaskCompleteFailed = false; // Has the Unity Hub tasks completed with failure?
-                let lineBuffer = ''; // Buffer for incomplete lines
-                const tasksCompleteMessages = [
-                    'All Tasks Completed Successfully.',
-                    'Completed with errors.'
-                ];
-                const child = (0, child_process_1.spawn)(executable, execArgs, {
-                    stdio: ['ignore', 'pipe', 'pipe'],
-                    ...(process.platform === 'win32' ? { windowsHide: true } : {}),
-                });
-                const sigintHandler = () => child.kill('SIGINT');
-                const sigtermHandler = () => child.kill('SIGTERM');
-                process.once('SIGINT', sigintHandler);
-                process.once('SIGTERM', sigtermHandler);
-                let hasCleanedUpListeners = false;
-                function removeListeners() {
-                    if (hasCleanedUpListeners) {
-                        return;
-                    }
-                    hasCleanedUpListeners = true;
-                    process.removeListener('SIGINT', sigintHandler);
-                    process.removeListener('SIGTERM', sigtermHandler);
-                }
-                function processOutput(data) {
-                    try {
-                        const chunk = data.toString();
-                        const fullChunk = lineBuffer + chunk;
-                        const lines = fullChunk.split(/\r?\n/) // split by newline
-                            .filter(line => line.length > 0); // filter out empty lines
-                        if (!chunk.endsWith('\n')) {
-                            lineBuffer = lines.pop() || '';
-                        }
-                        else {
-                            lineBuffer = '';
-                        }
-                        if (lines.some(line => tasksCompleteMessages.includes(line))) {
-                            isHubTaskCompleteSuccess = lines.includes('All Tasks Completed Successfully.');
-                            isHubTaskCompleteFailed = lines.includes('Completed with errors.');
-                            if (child?.pid) {
-                                try {
-                                    child.kill('SIGTERM');
-                                    setTimeout(() => {
-                                        try {
-                                            if (child?.pid && !child.killed) {
-                                                child.kill('SIGKILL');
-                                            }
-                                        }
-                                        catch {
-                                            // Ignore, process may have already exited
-                                        }
-                                    }, 1000);
-                                }
-                                catch {
-                                    // Ignore, process may have already exited
-                                }
-                                finally {
-                                    if (isHubTaskCompleteSuccess) {
-                                        settle(0);
-                                    }
-                                    else if (isHubTaskCompleteFailed) {
-                                        settle(1);
-                                    }
-                                    else {
-                                        settle(null);
-                                    }
-                                }
-                            }
-                        }
-                        for (const line of lines) {
-                            output += `${line}\n`;
-                            if (!options.silent && !ignoredLines.some(ignored => line.includes(ignored))) {
-                                process.stdout.write(`${line}\n`);
-                            }
-                        }
-                    }
-                    catch (error) {
-                        if (error.code !== 'EPIPE') {
-                            throw error;
-                        }
-                    }
-                }
-                function flushOutput() {
-                    try {
-                        if (lineBuffer.length > 0) {
-                            const lines = lineBuffer.split(/\r?\n/) // split by newline
-                                .filter(line => line.length > 0); // filter out empty lines
-                            lineBuffer = '';
-                            const outputLines = lines.filter(line => !ignoredLines.some(ignored => line.includes(ignored)));
-                            if (outputLines.some(line => tasksCompleteMessages.includes(line))) {
-                                isHubTaskCompleteSuccess = outputLines.includes('All Tasks Completed Successfully.');
-                                isHubTaskCompleteFailed = outputLines.includes('Completed with errors.');
-                            }
-                            for (const line of outputLines) {
-                                output += `${line}\n`;
-                                if (!options.silent) {
-                                    process.stdout.write(`${line}\n`);
-                                }
-                            }
-                        }
-                    }
-                    catch (error) {
-                        if (error.code !== 'EPIPE') {
-                            logging_1.Logger.instance.error(`Failed to process buffered output: ${error}`);
-                        }
-                    }
-                }
-                function settle(code) {
-                    if (isSettled) {
-                        return;
-                    }
-                    isSettled = true;
-                    removeListeners();
-                    flushOutput();
-                    resolve(code === null ? 0 : code);
-                }
-                child.stdout.on('data', processOutput);
-                child.stderr.on('data', processOutput);
-                child.on('error', (error) => {
-                    isSettled = true;
-                    removeListeners();
-                    flushOutput();
-                    reject(error);
-                });
-                child.on('close', settle);
-            });
-        }
-        finally {
-            this.logger.endGroup();
-            const match = output.match(/Assertion (?<assert>.+) failed/g);
-            const retryConditions = [
-                'async hook stack has become corrupted',
-                'failed to download'
-            ];
-            if (match ||
-                retryConditions.some(s => output.includes(s))) {
-                this.logger.warn(`Install failed, retrying...`);
-                return await this.execImpl(args, options, 0);
-            }
-            if (exitCode > 0) {
-                if (this.hubListingExitTolerable(args, output)) {
-                    this.logger.warn(`Unity Hub exited with code ${exitCode} but produced usable listing output; continuing.`);
-                }
-                else {
-                    const error = output.match(/Error(?: given)?:\s*(.+)/);
-                    const errorMessage = error && error[1] ? error[1] : 'Unknown Error';
-                    switch (errorMessage) {
-                        case 'No modules found to install.':
-                            break;
-                        default:
-                            if (this.isHubEditorListingArgs(args) && listingRetryDepth < 1) {
-                                this.logger.warn(`Unity Hub listing command failed (exit code ${exitCode}); retrying once after 2s...`);
-                                await this.delayMs(2000);
-                                return await this.execImpl(args, options, listingRetryDepth + 1);
-                            }
-                            this.logger.debug(output);
-                            throw new Error(`Failed to execute Unity Hub (exit code: ${exitCode}) ${errorMessage}`);
-                    }
-                }
-            }
-            output = output.split('\n')
-                .filter(line => line.trim().length > 0)
-                .filter(line => !ignoredLines.some(ignored => line.includes(ignored)))
-                .join('\n');
-        }
-        return output;
-    }
-    /**
-     * Prints the installed Unity Hub version.
-     * @returns The installed Unity Hub version.
-     */
-    async Version() {
-        const version = await this.getInstalledHubVersion();
-        return version.version;
-    }
-    /**
-     * Installs or updates the Unity Hub.
-     * If the Unity Hub is already installed, it will be updated to the latest version.
-     * @param autoUpdate If true, automatically updates the Unity Hub if it is already installed. Default is true.
-     * @returns The path to the Unity Hub executable.
-     */
-    async Install(autoUpdate = true, version) {
-        if (autoUpdate && version) {
-            throw new Error('Cannot use autoUpdate with version.');
-        }
-        let isInstalled = false;
-        let installedVersion = undefined;
-        try {
-            await fs.promises.access(this.executable, fs.constants.X_OK);
-            installedVersion = await this.getInstalledHubVersion();
-            isInstalled = true;
-        }
-        catch {
-            await this.installHub(version);
-        }
-        if (isInstalled && autoUpdate) {
-            if (!installedVersion) {
-                installedVersion = await this.getInstalledHubVersion();
-            }
-            this.logger.ci(`Installed Unity Hub version: ${installedVersion.version}`);
-            let versionToInstall = null;
-            if (!version) {
-                try {
-                    versionToInstall = await this.getLatestHubVersion();
-                    if (versionToInstall) {
-                        this.logger.ci(`Latest Unity Hub version: ${versionToInstall.version}`);
-                    }
-                }
-                catch (error) {
-                    this.logger.warn(`Failed to get latest Unity Hub version: ${error}`);
-                }
-            }
-            else {
-                versionToInstall = (0, semver_1.coerce)(version);
-            }
-            if (versionToInstall === null ||
-                !versionToInstall ||
-                !(0, semver_1.valid)(versionToInstall)) {
-                if (version || process.platform !== 'linux') {
-                    throw new Error(`Invalid Unity Hub version to install: ${versionToInstall}`);
-                }
-            }
-            const mustInstall = Boolean(version) ||
-                (process.platform === 'linux' && !version) ||
-                (versionToInstall !== null && (0, semver_1.compare)(installedVersion, versionToInstall) < 0);
-            if (mustInstall) {
-                this.logger.info(`Updating Unity Hub from ${installedVersion.version} to ${versionToInstall?.version ?? 'latest'}...`);
-                if (process.platform === 'darwin') {
-                    await (0, utilities_1.Exec)('sudo', ['rm', '-rf', this.rootDirectory], { silent: true, showCommand: true });
-                    await this.installHub(version);
-                }
-                else if (process.platform === 'win32') {
-                    const uninstaller = path.join(this.rootDirectory, 'Uninstall Unity Hub.exe');
-                    await (0, utilities_1.Exec)('powershell', [
-                        '-NoProfile',
-                        '-Command',
-                        `Start-Process -FilePath '${uninstaller}' -ArgumentList '/S' -Verb RunAs -Wait`
-                    ], { silent: true, showCommand: true });
-                    await (0, utilities_1.DeleteDirectory)(this.rootDirectory);
-                    await this.installHub(version);
-                }
-                else if (process.platform === 'linux') {
-                    const hubPkg = this.unityHubAptPackageSpec(version);
-                    const linuxExecOpts = { silent: true, showCommand: true };
-                    await (0, utilities_1.Exec)('sudo', ['sh', '-c', LINUX_HUB_LINUX_UPDATE_REPO_BOOTSTRAP], linuxExecOpts);
-                    await (0, utilities_1.Exec)('sudo', ['apt-get', 'install', '-y', '--no-install-recommends', '--only-upgrade', hubPkg], linuxExecOpts);
-                    // Refresh xvfb wrapper after upgrades that move /opt → /usr/lib (Hub 3.20+).
-                    await (0, utilities_1.Exec)('sudo', ['sh', '-c', LINUX_HUB_LINUX_INSTALL_POST], linuxExecOpts);
-                    this.refreshLinuxHubPaths();
-                    this.logger.info(`Unity Hub updated successfully.`);
-                }
-                else {
-                    throw new Error(`Unsupported platform: ${process.platform}`);
-                }
-            }
-            else {
-                this.logger.info(`Unity Hub is already installed and up to date.`);
-            }
-        }
-        if (process.platform === 'linux') {
-            this.refreshLinuxHubPaths();
-        }
-        await fs.promises.access(this.executable, fs.constants.X_OK);
-        return this.executable;
-    }
-    /**
-     * APT package spec for unityhub (e.g. `unityhub` or `unityhub=3.6.0`). Validated; passed as argv, not shell-embedded.
-     */
-    unityHubAptPackageSpec(version) {
-        if (version === undefined || version === null) {
-            return 'unityhub';
-        }
-        if (typeof version === 'object' && 'version' in version) {
-            const deb = version.version;
-            if (!LINUX_HUB_DEB_VERSION_RE.test(deb)) {
-                throw new Error(`Invalid Unity Hub apt version: ${deb}`);
-            }
-            return `unityhub=${deb}`;
-        }
-        const raw = String(version).trim();
-        if (raw.length === 0) {
-            return 'unityhub';
-        }
-        const pinned = (0, semver_1.coerce)(raw);
-        if (!pinned || !(0, semver_1.valid)(pinned)) {
-            throw new Error(`Invalid Unity Hub version for apt: ${raw}`);
-        }
-        const deb = pinned.version;
-        if (!LINUX_HUB_DEB_VERSION_RE.test(deb)) {
-            throw new Error(`Invalid Unity Hub apt version: ${deb}`);
-        }
-        return `unityhub=${deb}`;
-    }
-    async installHub(version) {
-        this.logger.ci(`Installing Unity Hub${version ? ' ' + version : ''}...`);
-        if (!version) {
-            switch (process.platform) {
-                case 'win32':
-                case 'darwin':
-                    version = 'prod';
-                    break;
-            }
-        }
-        switch (process.platform) {
-            case 'win32': {
-                if (process.arch === 'arm64' && version !== 'prod') {
-                    const pinned = (0, semver_1.coerce)(version);
-                    if (!pinned || !(0, semver_1.valid)(pinned)) {
-                        throw new Error(`Invalid Unity Hub version: ${String(version)}`);
-                    }
-                    if ((0, semver_1.compare)(pinned, MIN_NATIVE_WINDOWS_ARM64_HUB_VERSION) < 0) {
-                        throw new Error(`Unity Hub ${pinned.version} does not ship a native Windows ARM64 installer ` +
-                            `(minimum ${MIN_NATIVE_WINDOWS_ARM64_HUB_VERSION.version}). ` +
-                            'Install without --hub-version to use the latest Hub, or use Windows x64 for older Hub versions.');
-                    }
-                }
-                const winArch = process.arch === 'arm64' ? 'arm64' : 'x64';
-                const setupFileName = `UnityHubSetup-${winArch}.exe`;
-                const url = `https://public-cdn.cloud.unity3d.com/hub/${version}/${setupFileName}`;
-                const downloadPath = path.join((0, utilities_1.GetTempDir)(), setupFileName);
-                await (0, utilities_1.DownloadFile)(url, downloadPath);
-                this.logger.info(`Running Unity Hub installer...`);
-                try {
-                    await (0, utilities_1.Exec)('powershell', [
-                        '-NoProfile',
-                        '-Command',
-                        `Start-Process -FilePath '${downloadPath}' -ArgumentList '/S' -Verb RunAs -Wait`
-                    ], { silent: true, showCommand: true });
-                }
-                finally {
-                    if (fs.statSync(downloadPath).isFile()) {
-                        await fs.promises.unlink(downloadPath);
-                    }
-                }
-                break;
-            }
-            case 'darwin': {
-                const baseUrl = `https://public-cdn.cloud.unity3d.com/hub/${version}`;
-                const url = `${baseUrl}/UnityHubSetup-${process.arch}.dmg`;
-                const downloadPath = path.join((0, utilities_1.GetTempDir)(), `UnityHubSetup-${process.arch}.dmg`);
-                await (0, utilities_1.DownloadFile)(url, downloadPath);
-                await fs.promises.chmod(downloadPath, 0o777);
-                let mountPoint = '';
-                this.logger.debug(`Mounting DMG...`);
-                try {
-                    const output = await (0, utilities_1.Exec)('hdiutil', ['attach', downloadPath, '-nobrowse'], { silent: true, showCommand: true });
-                    // can be "/Volumes/Unity Hub 3.13.1-arm64" or "/Volumes/Unity Hub 3.13.1"
-                    const mountPointMatch = output.match(/\/Volumes\/Unity Hub.*$/m);
-                    if (!mountPointMatch || mountPointMatch.length === 0) {
-                        throw new Error(`Failed to find mount point in hdiutil output: ${output}`);
-                    }
-                    mountPoint = mountPointMatch[0];
-                    this.logger.debug(`Mounted Unity Hub at ${mountPoint}`);
-                    const appPath = path.join(mountPoint, 'Unity Hub.app');
-                    this.logger.debug(`Copying ${appPath} to /Applications...`);
-                    await fs.promises.access(appPath, fs.constants.R_OK | fs.constants.X_OK);
-                    if (fs.existsSync('/Applications/Unity Hub.app')) {
-                        await (0, utilities_1.Exec)('sudo', ['rm', '-rf', '/Applications/Unity Hub.app'], { silent: true, showCommand: true });
-                    }
-                    await (0, utilities_1.Exec)('sudo', ['cp', '-R', appPath, '/Applications/Unity Hub.app'], { silent: true, showCommand: true });
-                    await (0, utilities_1.Exec)('sudo', ['chmod', '777', '/Applications/Unity Hub.app/Contents/MacOS/Unity Hub'], { silent: true, showCommand: true });
-                    await (0, utilities_1.Exec)('sudo', ['mkdir', '-p', '/Library/Application Support/Unity'], { silent: true, showCommand: true });
-                    await (0, utilities_1.Exec)('sudo', ['chmod', '777', '/Library/Application Support/Unity'], { silent: true, showCommand: true });
-                }
-                finally {
-                    try {
-                        if (mountPoint && mountPoint.length > 0) {
-                            await (0, utilities_1.Exec)('hdiutil', ['detach', mountPoint, '-quiet'], { silent: true, showCommand: true });
-                        }
-                    }
-                    finally {
-                        if (fs.statSync(downloadPath).isFile()) {
-                            await fs.promises.unlink(downloadPath);
-                        }
-                    }
-                }
-                break;
-            }
-            case 'linux': {
-                const hubPkg = this.unityHubAptPackageSpec(version);
-                const linuxExecOpts = { silent: true, showCommand: true };
-                await (0, utilities_1.Exec)('sudo', ['sh', '-c', LINUX_HUB_LINUX_INSTALL_BOOTSTRAP], linuxExecOpts);
-                await (0, utilities_1.Exec)('sudo', ['apt-get', 'install', '-y', '--no-install-recommends', hubPkg, ...LINUX_HUB_LINUX_APT_EXTRAS], linuxExecOpts);
-                await (0, utilities_1.Exec)('sudo', ['sh', '-c', LINUX_HUB_LINUX_INSTALL_POST], linuxExecOpts);
-                this.refreshLinuxHubPaths();
-                break;
-            }
-            default:
-                throw new Error(`Unsupported platform: ${process.platform}`);
-        }
-        await fs.promises.access(this.executable, fs.constants.X_OK);
-        const installedVersion = await this.getInstalledHubVersion();
-        this.logger.info(`Unity Hub ${installedVersion} installed successfully.`);
-    }
-    async getInstalledHubVersion() {
-        let asarPath = undefined;
-        switch (process.platform) {
-            case 'darwin': {
-                asarPath = path.join(this.rootDirectory, 'Contents', 'Resources', 'app.asar');
-                break;
-            }
-            default: {
-                asarPath = path.join(this.rootDirectory, 'resources', 'app.asar');
-                break;
-            }
-        }
-        try {
-            await fs.promises.access(asarPath, fs.constants.R_OK);
-        }
-        catch {
-            throw new Error('Unity Hub is not installed.');
-        }
-        asar.uncacheAll();
-        const fileBuffer = asar.extractFile(asarPath, 'package.json').toString('utf-8');
-        let packageJson;
-        try {
-            packageJson = JSON.parse(fileBuffer);
-        }
-        catch (error) {
-            throw new Error(`Failed to parse Unity Hub package.json: ${error}\n${fileBuffer}`);
-        }
-        const version = (0, semver_1.coerce)(packageJson.version);
-        if (!version || !(0, semver_1.valid)(version)) {
-            throw new Error(`Failed to parse Unity Hub version: ${packageJson.version}`);
-        }
-        return version;
-    }
-    async getLatestHubVersion() {
-        let url = undefined;
-        switch (process.platform) {
-            case 'win32':
-                url = 'https://public-cdn.cloud.unity3d.com/hub/prod/latest.yml';
-                break;
-            case 'darwin':
-                url = 'https://public-cdn.cloud.unity3d.com/hub/prod/latest-mac.yml';
-                break;
-            case 'linux':
-                return null;
-            default:
-                throw new Error(`Unsupported platform: ${process.platform}`);
-        }
-        const data = await (0, utilities_1.HttpsGetText)(url);
-        const parsed = yaml.parse(data);
-        const version = (0, semver_1.coerce)(parsed.version);
-        if (!version || !(0, semver_1.valid)(version)) {
-            throw new Error(`Failed to parse latest Unity Hub version: ${parsed.version}`);
-        }
-        return version;
-    }
-    /**
-     * Returns the path where the Unity editors will be installed.
-     * @returns The editor install path.
-     */
-    async GetInstallPath() {
-        const result = (await this.Exec(['install-path', '--get'])).trim();
-        if (!result || result.length === 0) {
-            throw new Error('Failed to get Unity Hub install path.');
-        }
-        return result;
-    }
-    /**
-     * Sets the path where Unity editors will be installed.
-     * @param installPath The install path to set when installing Unity editors.
-     */
-    async SetInstallPath(installPath) {
-        await fs.promises.mkdir(installPath, { recursive: true });
-        await this.Exec(['install-path', '--set', installPath]);
-    }
-    /**
-     * Locate and associate an installed editor from a stipulated path.
-     * @param editorPath The path to the Unity Editor installation.
-     */
-    async AddEditor(editorPath) {
-        await fs.promises.access(editorPath, fs.constants.R_OK | fs.constants.X_OK);
-        await this.Exec(['editors', '--add', editorPath]);
-    }
-    /**
-     * Attempts to find or install the specified Unity Editor version with the requested modules.
-     * @param unityVersion The Unity version to find or install.
-     * @param modules The modules to install alongside the editor.
-     * @param channels The channels to consider when searching for the editor. Can be 'f' (final), 'p' (patch), 'b' (beta), 'a' (alpha), or 'x' (experimental). Default is ['f'].
-     * @returns The path to the Unity Editor executable.
-     */
-    async GetEditor(unityVersion, modules = [], channels = ['f']) {
-        const retryErrorMessages = [
-            'Editor already installed in this location',
-            'failed to download. Error given: Request timeout'
-        ];
-        this.logger.ci(`Getting release info for Unity ${unityVersion.toString()}...`);
-        let resolvedVersion = unityVersion;
-        if (!resolvedVersion.isLegacy()) {
-            // Hub list is a fast path only. Misses must fall through to the Releases API —
-            // do not fail-closed until both Hub match and API resolution have failed.
-            if (!resolvedVersion.isFullyQualified()) {
-                try {
-                    const releases = await this.ListAvailableReleases();
-                    logging_1.Logger.instance.debug(`Found ${releases.length} available Unity releases, searching channels: ${channels.join(', ')}`);
-                    resolvedVersion = resolvedVersion.findMatch(releases, channels);
-                }
-                catch (hubMatchError) {
-                    this.logger.debug(`No Hub list match for ${resolvedVersion.toString()} (channels: ${channels.join(', ')}); trying Releases API...\n${hubMatchError}`);
-                }
-            }
-            if (!resolvedVersion.changeset) {
-                try {
-                    const unityReleaseInfo = await this.GetEditorReleaseInfo(resolvedVersion, channels);
-                    resolvedVersion = new unity_version_1.UnityVersion(unityReleaseInfo.version, unityReleaseInfo.shortRevision, resolvedVersion.architecture);
-                }
-                catch (error) {
-                    // Fail closed for partial versions: never Hub-install "6000.6" and hope it picks a beta.
-                    if (!resolvedVersion.isFullyQualified()) {
-                        const msg = error instanceof Error ? error.message : String(error);
-                        throw new Error(`Failed to resolve Unity ${unityVersion.toString()} for channel(s) [${channels.join(', ')}]: ${msg}`);
-                    }
-                    this.logger.warn(`Failed to get Unity release info for ${resolvedVersion.toString()}! falling back to legacy search...\n${error}`);
-                    try {
-                        resolvedVersion = await this.fallbackVersionLookup(resolvedVersion);
-                    }
-                    catch (fallbackError) {
-                        this.logger.warn(`Failed to lookup changeset for Unity ${resolvedVersion.toString()}!\n${fallbackError}`);
-                    }
-                }
-            }
-        }
-        if (!resolvedVersion.isLegacy() && !resolvedVersion.isFullyQualified()) {
-            throw new Error(`Refusing to install non-fully-qualified Unity version ${resolvedVersion.toString()} without a resolved release. ` +
-                `Use a fully-qualified version or --channel matching an available stream.`);
-        }
-        const allowPartialMatches = !resolvedVersion.isFullyQualified();
-        let editorPath = await this.checkInstalledEditors(resolvedVersion, false, undefined, allowPartialMatches);
-        unityVersion = resolvedVersion;
-        let installDir = undefined;
-        if (!editorPath) {
-            try {
-                installDir = await this.installUnity(unityVersion, modules);
-            }
-            catch (error) {
-                const errMessage = error instanceof Error ? error.message : String(error);
-                if (retryErrorMessages.some((msg) => errMessage.includes(msg))) {
-                    if (editorPath) {
-                        await (0, utilities_1.DeleteDirectory)(editorPath);
-                    }
-                    if (installDir) {
-                        await (0, utilities_1.DeleteDirectory)(installDir);
-                    }
-                    installDir = await this.installUnity(unityVersion, modules);
-                }
-                else {
-                    throw error;
-                }
-            }
-            editorPath = await this.checkInstalledEditors(unityVersion, true, installDir);
-        }
-        if (!editorPath) {
-            throw new Error(`Failed to find or install Unity Editor: ${unityVersion.toString()}`);
-        }
-        await fs.promises.access(editorPath, fs.constants.X_OK);
-        await this.patchBeeBackend(editorPath);
-        if (unityVersion.isLegacy() || modules.length === 0) {
-            return new unity_editor_1.UnityEditor(path.normalize(editorPath), unityVersion);
-        }
-        try {
-            this.logger.info(`Validating installed modules for Unity ${unityVersion.toString()}...`);
-            const [installedModules, additionalModules] = await this.checkEditorModules(editorPath, unityVersion, modules);
-            if (installedModules && installedModules.length > 0) {
-                this.logger.info(`Installed Modules:`);
-                for (const module of installedModules) {
-                    this.logger.info(`  > ${module}`);
-                }
-            }
-            if (additionalModules && additionalModules.length > 0) {
-                this.logger.info(`Additional Modules:`);
-                for (const module of additionalModules) {
-                    this.logger.info(`  > ${module}`);
-                }
-            }
-        }
-        catch (error) {
-            const errMessage = error instanceof Error ? error.message : String(error);
-            if (errMessage.includes(`No modules found`)) {
-                await (0, utilities_1.DeleteDirectory)(editorPath);
-                await this.GetEditor(unityVersion, modules);
-            }
-            else {
-                throw error;
-            }
-        }
-        return new unity_editor_1.UnityEditor(path.normalize(editorPath), unityVersion);
-    }
-    /**
-     * Lists the installed Unity Editors.
-     * @returns A list of installed Unity Editor versions and their paths.
-     */
-    async ListInstalledEditors() {
-        const output = await this.Exec(['editors', '-i']);
-        return this.parseInstalledEditorsFromHubText(output);
-    }
-    /**
-     * Lists the available Unity releases.
-     * @returns A list of available Unity release versions.
-     */
-    async ListAvailableReleases() {
-        const output = await this.Exec(['editors', '--releases']);
-        return this.parseAvailableReleasesFromHubText(output);
-    }
-    async checkInstalledEditors(unityVersion, failOnEmpty, installDir = undefined, allowPartialMatches = true) {
-        let editorPath = undefined;
-        if (!installDir) {
-            const editors = await this.ListInstalledEditors();
-            if (editors && editors.length > 0) {
-                // Prefer exact version match first
-                const exactEditor = editors.find(e => e.version && e.version.version === unityVersion.version);
-                if (exactEditor) {
-                    editorPath = exactEditor.editorPath;
-                }
-                else if (allowPartialMatches) {
-                    // Fallback: semver satisfies
-                    const versionEditors = editors.filter(e => e.version && unityVersion.satisfies(e.version));
-                    if (versionEditors.length === 0) {
-                        return undefined;
-                    }
-                    // ListInstalledEditors already returns editors sorted descending by version.
-                    for (const editor of versionEditors) {
-                        if (!editor.version || !editor.editorPath) {
-                            continue;
-                        }
-                        // If no architecture requested or editor has no arch info, accept it
-                        if (!unityVersion.architecture || !editor.version.architecture) {
-                            editorPath = editor.editorPath;
-                            break;
-                        }
-                        // Exact architecture match
-                        if (unityVersion.architecture === editor.version.architecture) {
-                            editorPath = editor.editorPath;
-                            break;
-                        }
-                        // Fallback: check for architecture suffix in path (e.g., -arm64)
-                        if (unityVersion.architecture && editor.editorPath.toLowerCase().includes(`-${unityVersion.architecture.toLowerCase()}`)) {
-                            editorPath = editor.editorPath;
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-        else {
-            if (process.platform == 'win32') {
-                editorPath = path.join(installDir, 'Unity.exe');
-            }
-            else {
-                editorPath = installDir;
-            }
-        }
-        if (!editorPath) {
-            if (failOnEmpty) {
-                throw new Error(`Failed to find installed Unity Editor: ${unityVersion.toString()}`);
-            }
-            else {
-                return undefined;
-            }
-        }
-        if (process.platform === 'darwin') {
-            editorPath = path.join(editorPath, '/Contents/MacOS/Unity');
-        }
-        try {
-            await fs.promises.access(editorPath, fs.constants.R_OK | fs.constants.X_OK);
-        }
-        catch (error) {
-            throw new Error(`Failed to find installed Unity Editor: ${unityVersion.toString()}\n  > ${error}`);
-        }
-        this.logger.debug(`Found installed editor: "${editorPath}"`);
-        return editorPath;
-    }
-    /**
-     * 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');
-            if (fs.existsSync(beeBackend) && !fs.existsSync(dotBeeBackend)) {
-                this.logger.ci(`Patching Unity Linux Editor for Bee Backend...`);
-                await fs.promises.rename(beeBackend, dotBeeBackend);
-                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[@]}"`;
-                await fs.promises.writeFile(beeBackend, wrapperSource, { encoding: 'utf-8', mode: 0o755 });
-            }
-        }
-    }
-    /**
-     * 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.
-     */
-    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',
-            }
-        };
-        this.logger.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}`);
-            });
-            const latest = releases[0].unityRelease;
-            return latest;
-        }
-        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}`);
-        }
-    }
-    async fallbackVersionLookup(unityVersion) {
-        if (!unityVersion.isFullyQualified()) {
-            throw new Error(`Cannot lookup changeset for non-fully-qualified Unity version: ${unityVersion.toString()}`);
-        }
-        const url = `https://unity.com/releases/editor/whats-new/${unityVersion.version}`;
-        this.logger.debug(`Fetching release page: "${url}"`);
-        let response;
-        try {
-            response = await fetch(url);
-        }
-        catch (error) {
-            this.logger.warn(`Failed to fetch changeset for Unity ${unityVersion.toString()}: ${error}`);
-            return unityVersion;
-        }
-        const responseText = await response.text();
-        if (!response.ok) {
-            this.logger.info(responseText);
-        }
-        if (!response.ok) {
-            throw new Error(`Failed to fetch changeset for Unity ${unityVersion.toString()} [${response.status}] "${url}"`);
-        }
-        this.logger.debug(`Release page content: \n${responseText}`);
-        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);
-        }
-        this.logger.error(`Failed to find changeset for Unity ${unityVersion.toString()}`);
-        return unityVersion;
-    }
-    async checkEditorModules(editorPath, unityVersion, modules) {
-        let args = ['install-modules', '--version', unityVersion.version];
-        if (unityVersion.architecture) {
-            args.push('-a', unityVersion.architecture.toLowerCase());
-        }
-        for (const module of modules) {
-            args.push('-m', module);
-        }
-        const editorRootPath = unity_editor_1.UnityEditor.GetEditorRootPath(editorPath);
-        const modulesPath = path.join(editorRootPath, 'modules.json');
-        this.logger.debug(`Editor Modules Manifest:\n  > "${modulesPath}"`);
-        const output = await this.Exec([...args, '--cm'], { showCommand: true, silent: false });
-        const moduleMatches = output.matchAll(/Omitting module (?<module>.+) because it's already installed/g);
-        if (moduleMatches) {
-            const omittedModules = [...moduleMatches].map(match => match.groups?.module);
-            for (const module of omittedModules) {
-                if (module && !modules.includes(module)) {
-                    modules.push(module);
-                }
-            }
-        }
-        const installedModules = [...modules];
-        const additionalModules = [];
-        const additionalModulesJson = await this.getModulesContent(modulesPath);
-        if (additionalModulesJson.length > 0) {
-            for (const module of additionalModulesJson) {
-                if (module.category === "Platforms" && module.visible === true) {
-                    if (!installedModules.includes(module.id)) {
-                        additionalModules.push(module.id);
-                    }
-                }
-            }
-        }
-        return [installedModules, additionalModules];
-    }
-    async getModulesContent(modulesPath) {
-        const modulesContent = await (0, utilities_1.ReadFileContents)(modulesPath);
-        return JSON.parse(modulesContent);
-    }
-    async installUnity(unityVersion, modules) {
-        if (unityVersion.isLegacy()) {
-            return await this.installUnity4x(unityVersion);
-        }
-        if (process.platform === 'linux') {
-            const arch = process.arch === 'x64' ? 'amd64' : process.arch === 'arm64' ? 'arm64' : process.arch;
-            // install older versions of libssl for older Unity versions
-            if (['2019.1', '2019.2'].some(v => unityVersion.version.startsWith(v))) {
-                const url = `https://archive.ubuntu.com/ubuntu/pool/main/o/openssl/libssl1.0.0_1.0.2g-1ubuntu4.20_${arch}.deb`;
-                const downloadPath = path.join((0, utilities_1.GetTempDir)(), `libssl1.0.0_1.0.2g-1ubuntu4.20_${arch}.deb`);
-                await (0, utilities_1.DownloadFile)(url, downloadPath);
-                try {
-                    await (0, utilities_1.Exec)('sudo', ['dpkg', '-i', downloadPath]);
-                }
-                finally {
-                    fs.promises.unlink(downloadPath);
-                }
-            }
-            else if (['2019.3', '2019.4'].some(v => unityVersion.version.startsWith(v)) ||
-                unityVersion.version.startsWith('2020.') ||
-                unityVersion.version.startsWith('2021.')) {
-                const url = `https://archive.ubuntu.com/ubuntu/pool/main/o/openssl/libssl1.1_1.1.0g-2ubuntu4_${arch}.deb`;
-                const downloadPath = path.join((0, utilities_1.GetTempDir)(), `libssl1.1_1.1.0g-2ubuntu4_${arch}.deb`);
-                await (0, utilities_1.DownloadFile)(url, downloadPath);
-                try {
-                    await (0, utilities_1.Exec)('sudo', ['dpkg', '-i', downloadPath]);
-                }
-                finally {
-                    fs.promises.unlink(downloadPath);
-                }
-            }
-        }
-        this.logger.ci(`Installing Unity ${unityVersion.toString()}...`);
-        const args = ['install', '--version', unityVersion.version];
-        if (unityVersion.changeset) {
-            args.push('--changeset', unityVersion.changeset);
-        }
-        if (unityVersion.architecture) {
-            args.push('-a', unityVersion.architecture.toLowerCase());
-        }
-        if (modules.length > 0) {
-            for (const module of modules) {
-                this.logger.ci(`  > with module: ${module}`);
-                args.push('-m', module);
-            }
-            args.push('--cm');
-        }
-        const output = await this.Exec(args, { showCommand: true, silent: false });
-        if (output.includes(`Error while installing an editor or a module from changeset`) ||
-            output.includes(`failed to download.`)) {
-            throw new Error(`Failed to install Unity ${unityVersion.toString()}`);
-        }
-    }
-    async installUnity4x(unityVersion) {
-        this.logger.ci(`Installing Unity ${unityVersion.toString()}...`);
-        const hubInstallDir = await this.GetInstallPath();
-        switch (process.platform) {
-            case 'win32': {
-                const installDir = path.join(hubInstallDir, `Unity ${unityVersion.version}`);
-                const installPath = path.join(installDir, 'Unity.exe');
-                if (!fs.existsSync(installPath)) {
-                    const url = `https://beta.unity3d.com/download/UnitySetup-${unityVersion.version}.exe`;
-                    const installerPath = path.join((0, utilities_1.GetTempDir)(), `UnitySetup-${unityVersion.version}.exe`);
-                    await (0, utilities_1.DownloadFile)(url, installerPath);
-                    this.logger.info(`Running Unity ${unityVersion.toString()} installer...`);
-                    try {
-                        await (0, utilities_1.Exec)('powershell', [
-                            '-Command',
-                            `Start-Process -FilePath \"${installerPath}\" -ArgumentList \"/S /D=${installDir}\" -Wait`
-                        ], { silent: true, showCommand: true });
-                    }
-                    catch (error) {
-                        this.logger.error(`Failed to install Unity ${unityVersion.toString()}: ${error}`);
-                    }
-                    finally {
-                        fs.promises.unlink(installerPath);
-                    }
-                }
-                await fs.promises.access(installDir, fs.constants.R_OK | fs.constants.X_OK);
-                return installDir;
-            }
-            case 'darwin': {
-                const installDir = path.join(hubInstallDir, `Unity ${unityVersion.version}`, 'Unity.app');
-                if (!fs.existsSync(installDir)) {
-                    const url = `https://beta.unity3d.com/download/unity-${unityVersion.version}.dmg`;
-                    const installerPath = path.join((0, utilities_1.GetTempDir)(), `UnitySetup-${unityVersion.version}.dmg`);
-                    await (0, utilities_1.DownloadFile)(url, installerPath);
-                    this.logger.info(`Running Unity ${unityVersion.toString()} installer...`);
-                    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];
-                        this.logger.debug(`Mounted Unity Installer at ${mountPoint}`);
-                        const pkgPath = path.join(mountPoint, 'Unity.pkg');
-                        await fs.promises.access(pkgPath, fs.constants.R_OK);
-                        this.logger.debug(`Found .pkg installer: ${pkgPath}`);
-                        await (0, utilities_1.Exec)('sudo', ['installer', '-pkg', pkgPath, '-target', '/', '-verboseR'], { silent: true, showCommand: true });
-                        const unityAppPath = path.join('/Applications', 'Unity');
-                        const targetPath = path.join(hubInstallDir, `Unity ${unityVersion.version}`);
-                        if (fs.existsSync(unityAppPath)) {
-                            this.logger.debug(`Moving ${unityAppPath} to ${targetPath}...`);
-                            await fs.promises.mkdir(path.dirname(targetPath), { recursive: true });
-                            const items = await fs.promises.readdir(unityAppPath);
-                            for (const item of items) {
-                                if (item !== 'Hub') {
-                                    const src = path.join(unityAppPath, item);
-                                    const dest = path.join(targetPath, item);
-                                    this.logger.debug(`  > Moving ${src} to ${dest}`);
-                                    await fs.promises.cp(src, dest, { recursive: true });
-                                    await fs.promises.rm(src, { recursive: true, force: true });
-                                }
-                            }
-                            await fs.promises.chmod(targetPath, 0o777);
-                        }
-                        else {
-                            throw new Error(`Failed to find Unity.app after installation.`);
-                        }
-                    }
-                    catch (error) {
-                        this.logger.error(`Failed to mount Unity ${unityVersion.toString()} installer: ${error}`);
-                    }
-                    finally {
-                        try {
-                            if (mountPoint && mountPoint.length > 0) {
-                                await (0, utilities_1.Exec)('hdiutil', ['detach', mountPoint, '-quiet'], { silent: true, showCommand: true });
-                            }
-                        }
-                        finally {
-                            await fs.promises.unlink(installerPath);
-                        }
-                    }
-                }
-                await fs.promises.access(installDir, fs.constants.R_OK | fs.constants.X_OK);
-                return installDir;
-            }
-            default:
-                throw new Error(`Unity ${unityVersion.toString()} is not supported on ${process.platform}`);
-        }
-    }
-    /**
-     * 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();
-        let moduleMap;
-        switch (osType) {
-            case 'Linux':
-                moduleMap = {
-                    "StandaloneLinux64": "linux-il2cpp",
-                    "Android": "android",
-                    "WebGL": "webgl",
-                    "iOS": "ios",
-                };
-                break;
-            case 'Darwin':
-                moduleMap = {
-                    "StandaloneOSX": "mac-il2cpp",
-                    "iOS": "ios",
-                    "Android": "android",
-                    "tvOS": "appletv",
-                    "StandaloneLinux64": "linux-il2cpp",
-                    "WebGL": "webgl",
-                    "VisionOS": "visionos"
-                };
-                break;
-            case 'Windows_NT':
-                moduleMap = {
-                    "StandaloneWindows64": "windows-il2cpp",
-                    "WSAPlayer": "universal-windows-platform",
-                    "Android": "android",
-                    "iOS": "ios",
-                    "tvOS": "appletv",
-                    "StandaloneLinux64": "linux-il2cpp",
-                    "Lumin": "lumin",
-                    "WebGL": "webgl",
-                };
-                break;
-            default:
-                throw Error(`${osType} not supported`);
-        }
-        return moduleMap;
-    }
-    /**
-     * Returns the path to the Unity Hub log file.
-     * @see https://docs.unity.com/en-us/licensing-server/troubleshooting-client#logs
-     * @returns The Unity Hub log file path.
-     */
-    static LogPath() {
-        switch (process.platform) {
-            case 'win32':
-                // %APPDATA%\UnityHub\logs\info-log.json
-                return path.join(process.env.APPDATA || '', 'UnityHub', 'logs', 'info-log.json');
-            case 'darwin':
-                // ~/Library/Application Support/UnityHub/logs/info-log.json
-                return path.join(process.env.HOME || '', 'Library', 'Application Support', 'UnityHub', 'logs', 'info-log.json');
-            case 'linux':
-                // ~/.config/UnityHub/logs/info-log.json
-                return path.join(process.env.HOME || '', '.config', 'UnityHub', 'logs', 'info-log.json');
-            default:
-                throw new Error(`Unsupported platform: ${process.platform}`);
-        }
-    }
-    /**
-     * Returns the path to the Unity Package Manager log file.
-     * @see https://docs.unity3d.com/Manual/LogFiles.html
-     * @returns The Unity Package Manager log file path.
-     */
-    static PackageManagerLogsPath() {
-        switch (process.platform) {
-            case 'win32':
-                // C:\Users\username\AppData\Local\Unity\Editor\upm.log
-                return path.join(process.env.LOCALAPPDATA || '', 'Unity', 'Editor', 'upm.log');
-            case 'darwin':
-                // ~/Library/Logs/Unity/upm.log
-                return path.join(process.env.HOME || '', 'Library', 'Logs', 'Unity', 'upm.log');
-            case 'linux':
-                // ~/.config/unity3d/upm.log
-                return path.join(process.env.HOME || '', '.config', 'unity3d', 'upm.log');
-            default:
-                throw new Error(`Unsupported platform: ${process.platform}`);
-        }
-    }
-}
-exports.UnityHub = UnityHub;
-//# sourceMappingURL=unity-hub.js.map