@atelierai/uco 1.0.0

package/dist/devops/utils/unity-hub.js

@@ -0,0 +1,696 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { execFileSync, execSync, spawn } from 'child_process';
+import { platform } from 'os';
+import { get as httpsGet } from 'https';
+import { get as httpGet } from 'http';
+import * as ui from './ui.js';
+function createSilentSpinner(initialText) {
+    let text = initialText;
+    const spinner = {
+        start: () => spinner,
+        stop: () => spinner,
+        success: () => spinner,
+        error: () => spinner,
+        warning: () => spinner,
+        info: () => spinner,
+        clear: () => spinner,
+        get text() { return text; },
+        set text(value) { text = value; },
+        get isSpinning() { return false; },
+        get color() { return 'cyan'; },
+        set color(_value) { },
+    };
+    return spinner;
+}
+const defaultUnityHubOutput = {
+    verbose: ui.verbose,
+    info: ui.info,
+    warn: ui.warn,
+    success: ui.success,
+    label: ui.label,
+    startSpinner: ui.startSpinner,
+    createProgressBar: ui.createProgressBar,
+};
+/** A per-operation sink for JSON/library callers; it never touches process streams. */
+export const silentUnityHubOutput = {
+    verbose: () => undefined,
+    info: () => undefined,
+    warn: () => undefined,
+    success: () => undefined,
+    label: () => undefined,
+    startSpinner: createSilentSpinner,
+    createProgressBar: () => ({
+        update: () => undefined,
+        complete: () => undefined,
+        fail: () => undefined,
+    }),
+};
+function outputFor(options) {
+    return options.output ?? defaultUnityHubOutput;
+}
+const UNITY_HUB_DOWNLOAD_URLS = {
+    win32: 'https://public-cdn.cloud.unity3d.com/hub/prod/UnityHubSetup.exe',
+    darwin: 'https://public-cdn.cloud.unity3d.com/hub/prod/UnityHubSetup.dmg',
+    linux: 'https://public-cdn.cloud.unity3d.com/hub/prod/UnityHub.AppImage',
+};
+/**
+ * Detect the Unity Hub installation path based on the current platform.
+ * Returns the path if found, or null.
+ */
+export function findUnityHub(options = {}) {
+    const startedAt = Date.now();
+    const output = outputFor(options);
+    const plat = platform();
+    const candidates = [];
+    switch (plat) {
+        case 'win32':
+            candidates.push(path.join(process.env['PROGRAMFILES'] ?? 'C:\\Program Files', 'Unity Hub', 'Unity Hub.exe'), ...(process.env['LOCALAPPDATA'] ? [path.join(process.env['LOCALAPPDATA'], 'Programs', 'Unity Hub', 'Unity Hub.exe')] : []));
+            break;
+        case 'darwin':
+            candidates.push('/Applications/Unity Hub.app/Contents/MacOS/Unity Hub');
+            break;
+        case 'linux':
+            candidates.push('/usr/bin/unity-hub', '/snap/bin/unity-hub', ...(process.env['HOME'] ? [path.join(process.env['HOME'], 'Applications', 'Unity Hub.AppImage')] : []));
+            break;
+    }
+    for (const candidate of candidates) {
+        const candidateStartedAt = Date.now();
+        output.verbose(`Checking Unity Hub candidate: ${candidate}`);
+        if (candidate && fs.existsSync(candidate)) {
+            output.verbose(`Found Unity Hub at: ${candidate} (${Date.now() - candidateStartedAt}ms for candidate, ${Date.now() - startedAt}ms total)`);
+            return candidate;
+        }
+        output.verbose(`Unity Hub candidate missing: ${candidate} (${Date.now() - candidateStartedAt}ms)`);
+    }
+    output.verbose(`Unity Hub not found in any candidate location (${Date.now() - startedAt}ms total)`);
+    return null;
+}
+/**
+ * Download a file from a URL, following redirects.
+ */
+function downloadFile(url, destPath) {
+    return new Promise((resolve, reject) => {
+        const doGet = url.startsWith('https') ? httpsGet : httpGet;
+        doGet(url, (response) => {
+            // Follow redirects
+            if (response.statusCode && response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+                downloadFile(new URL(response.headers.location, url).toString(), destPath).then(resolve, reject);
+                return;
+            }
+            if (response.statusCode && response.statusCode !== 200) {
+                reject(new Error(`Download failed with status ${response.statusCode}`));
+                return;
+            }
+            const file = fs.createWriteStream(destPath);
+            response.pipe(file);
+            file.on('finish', () => { file.close(); resolve(); });
+            file.on('error', reject);
+        }).on('error', reject);
+    });
+}
+/**
+ * Download and install Unity Hub silently.
+ * Supports Windows, macOS, and Linux.
+ */
+export async function installUnityHub(options = {}) {
+    const plat = platform();
+    const output = outputFor(options);
+    const runFileSync = options.processAdapter?.execFileSync ?? execFileSync;
+    const runSync = options.processAdapter?.execSync ?? execSync;
+    const url = UNITY_HUB_DOWNLOAD_URLS[plat];
+    if (!url) {
+        throw new Error(`Unsupported platform for Unity Hub installation: ${plat}`);
+    }
+    const tmpDir = os.tmpdir();
+    switch (plat) {
+        case 'win32': {
+            const installerPath = path.join(tmpDir, 'UnityHubSetup.exe');
+            const spinner = output.startSpinner('Downloading Unity Hub installer...');
+            try {
+                await downloadFile(url, installerPath);
+            }
+            catch (err) {
+                spinner.error('Failed to download Unity Hub installer');
+                throw err;
+            }
+            spinner.success('Unity Hub installer downloaded');
+            output.info('Installing Unity Hub silently (may require administrator privileges)...');
+            try {
+                runFileSync(installerPath, ['/S'], {
+                    timeout: 300000,
+                    stdio: options.output === undefined ? 'inherit' : 'pipe',
+                });
+            }
+            finally {
+                try {
+                    fs.unlinkSync(installerPath);
+                }
+                catch { /* ignore */ }
+            }
+            const hubPath = findUnityHub(options);
+            if (!hubPath) {
+                throw new Error('Unity Hub was installed but could not be found. Try restarting your terminal.');
+            }
+            return hubPath;
+        }
+        case 'darwin': {
+            const dmgPath = path.join(tmpDir, 'UnityHubSetup.dmg');
+            const spinner = output.startSpinner('Downloading Unity Hub installer...');
+            try {
+                await downloadFile(url, dmgPath);
+            }
+            catch (err) {
+                spinner.error('Failed to download Unity Hub installer');
+                throw err;
+            }
+            spinner.success('Unity Hub installer downloaded');
+            const installSpinner = output.startSpinner('Installing Unity Hub...');
+            try {
+                const mountOutput = runSync(`hdiutil attach -nobrowse -noverify "${dmgPath}"`, { encoding: 'utf-8' });
+                const mountMatch = mountOutput.match(/\/Volumes\/.+/);
+                if (!mountMatch)
+                    throw new Error('Failed to mount Unity Hub DMG');
+                const mountPoint = mountMatch[0].trim();
+                try {
+                    runSync(`cp -R "${mountPoint}/Unity Hub.app" /Applications/`, {
+                        stdio: options.output === undefined ? 'inherit' : 'pipe',
+                    });
+                }
+                finally {
+                    runSync(`hdiutil detach "${mountPoint}" -quiet`, { stdio: 'ignore' });
+                }
+                installSpinner.success('Unity Hub installed');
+            }
+            catch (err) {
+                installSpinner.error('Unity Hub installation failed');
+                throw err;
+            }
+            finally {
+                try {
+                    fs.unlinkSync(dmgPath);
+                }
+                catch { /* ignore */ }
+            }
+            const hubPath = findUnityHub(options);
+            if (!hubPath) {
+                throw new Error('Unity Hub was installed but could not be found.');
+            }
+            return hubPath;
+        }
+        case 'linux': {
+            const appDir = path.join(process.env['HOME'] ?? '', 'Applications');
+            const appImagePath = path.join(appDir, 'UnityHub.AppImage');
+            const spinner = output.startSpinner('Downloading Unity Hub AppImage...');
+            fs.mkdirSync(appDir, { recursive: true });
+            try {
+                await downloadFile(url, appImagePath);
+            }
+            catch (err) {
+                spinner.error('Failed to download Unity Hub AppImage');
+                throw err;
+            }
+            fs.chmodSync(appImagePath, 0o755);
+            spinner.success(`Unity Hub installed at: ${appImagePath}`);
+            return appImagePath;
+        }
+        default:
+            throw new Error(`Unsupported platform: ${plat}`);
+    }
+}
+/**
+ * Find Unity Hub, or install it automatically if not found.
+ */
+export async function ensureUnityHub(options = {}) {
+    const startedAt = Date.now();
+    const output = outputFor(options);
+    const hubPath = findUnityHub(options);
+    if (hubPath) {
+        output.verbose(`ensureUnityHub reused existing installation in ${Date.now() - startedAt}ms`);
+        return hubPath;
+    }
+    output.warn('Unity Hub not found. Installing automatically...');
+    const installedHubPath = await installUnityHub(options);
+    output.verbose(`ensureUnityHub installed Unity Hub in ${Date.now() - startedAt}ms`);
+    return installedHubPath;
+}
+/**
+ * Pull the `stderr` capture off an `execFileSync` error and merge it
+ * into the error message. Returns the bare `err.message` when no
+ * stderr was captured (e.g. spawn failures before the child ran).
+ */
+function formatExecError(err) {
+    const message = err.message;
+    const stderr = err.stderr;
+    if (!stderr)
+        return message;
+    const text = (Buffer.isBuffer(stderr) ? stderr.toString('utf-8') : stderr).trim();
+    return text ? `${message}\n${text}` : message;
+}
+/**
+ * List installed Unity editors via Unity Hub CLI.
+ */
+/**
+ * Parse a single line from Unity Hub `--installed` output into an InstalledEditor entry.
+ * Handles formats such as:
+ *   "2022.3.62f3 , installed at /path/to/editor"
+ *   "6000.3.11f1 (Apple silicon) installed at /path/to/editor"
+ *   "6000.3.11f1 (Apple silicon), installed at /path/to/editor"
+ * Returns null if the line does not match the expected format.
+ */
+export function parseInstalledEditorsLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return null;
+    const match = trimmed.match(/^([\d.]+\w*)\s*(?:\([^)]*\)\s*)?(?:,\s*)?installed at\s+(.+)$/i);
+    if (match) {
+        return { version: match[1], path: match[2].trim() };
+    }
+    return null;
+}
+export function listInstalledEditors(hubPath, options = {}) {
+    const output = outputFor(options);
+    const spinner = output.startSpinner('Listing installed editors...');
+    const runFileSync = options.processAdapter?.execFileSync ?? execFileSync;
+    const startedAt = Date.now();
+    try {
+        output.verbose(`listInstalledEditors invoking Unity Hub CLI: ${hubPath} -- --headless editors --installed`);
+        const execStartedAt = Date.now();
+        // stdio: pipe stderr instead of inheriting it — Unity Hub is an
+        // Electron app and Chromium routinely logs benign quota_database
+        // errors to stderr that would otherwise pollute the CLI output.
+        // The catch block re-surfaces captured stderr on real failures.
+        const commandOutput = runFileSync(hubPath, ['--', '--headless', 'editors', '--installed'], {
+            encoding: 'utf-8',
+            timeout: 120000,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        output.verbose(`listInstalledEditors Unity Hub CLI returned in ${Date.now() - execStartedAt}ms`);
+        const parseStartedAt = Date.now();
+        const editors = [];
+        for (const line of commandOutput.split('\n')) {
+            const editor = parseInstalledEditorsLine(line);
+            if (editor) {
+                editors.push(editor);
+            }
+        }
+        if (options.strictInventory && editors.length === 0 && commandOutput.trim()) {
+            throw new Error('Unity Hub returned non-empty installed-editor output that could not be parsed.');
+        }
+        output.verbose(`listInstalledEditors parsed ${editors.length} editor(s) in ${Date.now() - parseStartedAt}ms`);
+        spinner.success(`Found ${editors.length} installed editor${editors.length !== 1 ? 's' : ''}`);
+        output.verbose(`listInstalledEditors completed in ${Date.now() - startedAt}ms`);
+        return editors;
+    }
+    catch (err) {
+        spinner.error(`Failed to list installed editors: ${formatExecError(err)}`);
+        output.verbose(`listInstalledEditors failed after ${Date.now() - startedAt}ms`);
+        if (options.strictInventory) {
+            throw new Error(`Failed to list installed Unity editors: ${formatExecError(err)}`, {
+                cause: err,
+            });
+        }
+        return [];
+    }
+}
+/**
+ * Parse a Unity version string into comparable numeric parts.
+ * Handles formats like "2022.3.62f1", "6000.3.1f1", "2019.4.40f1".
+ */
+function parseUnityVersion(version) {
+    // Split on dots and letter boundaries: "2022.3.62f1" -> [2022, 3, 62, 1]
+    return version.split(/[.\-]/).flatMap(part => {
+        const sub = part.match(/^(\d+)([a-zA-Z]+)(\d+)$/);
+        if (sub)
+            return [parseInt(sub[1], 10), parseInt(sub[3], 10)];
+        const num = parseInt(part, 10);
+        return isNaN(num) ? [] : [num];
+    });
+}
+/**
+ * Compare two Unity version strings. Returns positive if a > b, negative if a < b, 0 if equal.
+ */
+function compareUnityVersions(a, b) {
+    const partsA = parseUnityVersion(a);
+    const partsB = parseUnityVersion(b);
+    const len = Math.max(partsA.length, partsB.length);
+    for (let i = 0; i < len; i++) {
+        const diff = (partsA[i] ?? 0) - (partsB[i] ?? 0);
+        if (diff !== 0)
+            return diff;
+    }
+    return 0;
+}
+/**
+ * Find the installed editor with the highest version number.
+ */
+export function findHighestEditor(editors) {
+    return editors.reduce((highest, current) => compareUnityVersions(current.version, highest.version) > 0 ? current : highest);
+}
+/**
+ * List available Unity editor releases from Unity Hub CLI.
+ */
+export function listAvailableReleases(hubPath, options = {}) {
+    const output = outputFor(options);
+    const spinner = output.startSpinner('Fetching available releases...');
+    const runFileSync = options.processAdapter?.execFileSync ?? execFileSync;
+    try {
+        // Same stderr suppression rationale as listInstalledEditors above.
+        const commandOutput = runFileSync(hubPath, ['--', '--headless', 'editors', '--releases'], {
+            encoding: 'utf-8',
+            timeout: 120000,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const releases = [];
+        for (const line of commandOutput.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            // Extract version from line (may also contain "installed at ..." suffix)
+            const match = trimmed.match(/^([\d.]+[a-zA-Z]\d+)/);
+            if (match) {
+                const version = match[1];
+                const isStable = /f\d+$/.test(version);
+                releases.push({ version, isStable });
+            }
+        }
+        if (options.strictInventory && releases.length === 0 && commandOutput.trim()) {
+            throw new Error('Unity Hub returned non-empty release output that could not be parsed.');
+        }
+        spinner.success(`Found ${releases.length} available release${releases.length !== 1 ? 's' : ''}`);
+        return releases;
+    }
+    catch (err) {
+        spinner.error(`Failed to fetch available releases: ${formatExecError(err)}`);
+        if (options.strictInventory) {
+            throw new Error(`Failed to list available Unity releases: ${formatExecError(err)}`, {
+                cause: err,
+            });
+        }
+        return [];
+    }
+}
+/**
+ * Find the latest stable (f-suffix) release from the available releases.
+ */
+export function findLatestStableRelease(releases) {
+    const stable = releases.filter(r => r.isStable);
+    if (stable.length === 0)
+        return null;
+    return stable.reduce((highest, current) => compareUnityVersions(current.version, highest.version) > 0 ? current : highest);
+}
+const FETCH_TIMEOUT_MS = 10000;
+const FETCH_MAX_REDIRECTS = 5;
+/**
+ * Fetch a URL and return the response body as a string.
+ * Supports redirect following up to FETCH_MAX_REDIRECTS deep, and enforces a
+ * FETCH_TIMEOUT_MS request timeout to prevent indefinite hangs.
+ */
+function fetchUrl(url, redirectsRemaining = FETCH_MAX_REDIRECTS) {
+    return new Promise((resolve, reject) => {
+        const controller = new AbortController();
+        const timer = setTimeout(() => {
+            controller.abort();
+            reject(new Error(`Request timed out after ${FETCH_TIMEOUT_MS}ms: ${url}`));
+        }, FETCH_TIMEOUT_MS);
+        const doGet = url.startsWith('https') ? httpsGet : httpGet;
+        const req = doGet(url, { signal: controller.signal }, (response) => {
+            if (response.statusCode && response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+                clearTimeout(timer);
+                if (redirectsRemaining <= 0) {
+                    response.resume();
+                    reject(new Error(`Too many redirects (max ${FETCH_MAX_REDIRECTS}) fetching: ${url}`));
+                    return;
+                }
+                response.resume();
+                fetchUrl(new URL(response.headers.location, url).toString(), redirectsRemaining - 1).then(resolve, reject);
+                return;
+            }
+            if (response.statusCode && response.statusCode !== 200) {
+                clearTimeout(timer);
+                response.resume();
+                reject(new Error(`HTTP ${response.statusCode}`));
+                return;
+            }
+            const chunks = [];
+            response.on('data', (chunk) => chunks.push(chunk));
+            response.on('end', () => { clearTimeout(timer); resolve(Buffer.concat(chunks).toString('utf-8')); });
+            response.on('error', (err) => { clearTimeout(timer); reject(err); });
+        });
+        req.on('error', (err) => { clearTimeout(timer); reject(err); });
+    });
+}
+/**
+ * Resolve the changeset hash for a Unity version by scraping the release notes page.
+ * Returns the changeset string, or null if not found.
+ */
+// Unity version format: major.minor.patchSuffix (e.g. 2022.3.62f3, 6000.3.1f1)
+const UNITY_VERSION_RE = /^\d+\.\d+\.\d+[a-zA-Z]\d+$/;
+export function isValidUnityVersion(version) {
+    return UNITY_VERSION_RE.test(version);
+}
+export async function resolveChangeset(version) {
+    if (!isValidUnityVersion(version))
+        return null;
+    const url = `https://unity.com/releases/editor/whats-new/${version}`;
+    try {
+        const html = await fetchUrl(url);
+        // Look for unityhub://VERSION/CHANGESET pattern
+        const match = html.match(/unityhub:\/\/[^/]+\/([a-f0-9]{12})/);
+        if (match)
+            return match[1];
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Parse Unity Hub CLI stdout and update the progress bar accordingly.
+ * Hub output lines look like:
+ *   [Unity (6000.3.11f1)] downloading 50.54%
+ *   [Unity (6000.3.11f1)] validating download...
+ *   [Unity (6000.3.11f1)] installing...
+ *   [Unity (6000.3.11f1)] installed successfully.
+ */
+export function parseHubProgress(line) {
+    const trimmed = line.replace(/\x1b\[[0-9;]*[A-Za-z]/g, '').trim();
+    if (!trimmed || trimmed === 'Progress:' || trimmed === 'All Tasks Completed Successfully.')
+        return null;
+    // Match: [Unity (VERSION)] STATUS
+    const match = trimmed.match(/^\[.+?\]\s+(.+)$/);
+    if (!match)
+        return null;
+    const status = match[1];
+    // "downloading 50.54%"
+    const dlMatch = status.match(/^downloading\s+([\d.]+)%$/);
+    if (dlMatch) {
+        return { percent: parseFloat(dlMatch[1]), status: 'Downloading' };
+    }
+    // Map known phases to approximate progress
+    if (status.includes('validating download'))
+        return { percent: 0, status: 'Validating download' };
+    if (status.includes('in progress'))
+        return { percent: 0, status: 'Starting download' };
+    if (status.includes('finished downloading'))
+        return { percent: 100, status: 'Download complete' };
+    if (status.includes('queued for install'))
+        return { percent: 100, status: 'Queued for install' };
+    if (status.includes('validating installation'))
+        return { percent: 100, status: 'Validating installation' };
+    if (status.includes('installing'))
+        return { percent: 100, status: 'Installing' };
+    if (status.includes('installed successfully'))
+        return { percent: 100, status: 'Installed' };
+    return { percent: 0, status };
+}
+/**
+ * Run Unity Hub install command with a progress bar.
+ * Spawns the process and parses stdout to display download/install progress.
+ */
+function runHubInstallWithProgress(hubPath, args, version, options) {
+    return new Promise((resolve, reject) => {
+        const output = outputFor(options);
+        const progress = output.createProgressBar();
+        let activeSpinner = output.startSpinner(`Preparing Unity Editor ${version}...`);
+        let isDownloading = false;
+        const spawnProcess = options.processAdapter?.spawn ?? spawn;
+        const proc = spawnProcess(hubPath, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+        let stderr = '';
+        function stopActiveSpinner(msg) {
+            if (activeSpinner) {
+                activeSpinner.success(msg);
+                activeSpinner = null;
+            }
+        }
+        function startPhaseSpinner(status) {
+            stopActiveSpinner(activeSpinner?.text ?? '');
+            activeSpinner = output.startSpinner(`${status}...`);
+        }
+        let stdoutBuffer = '';
+        proc.stdout.on('data', (data) => {
+            const text = stdoutBuffer + data.toString('utf-8');
+            const lines = text.split('\n');
+            stdoutBuffer = lines.pop() ?? '';
+            for (const line of lines) {
+                const parsed = parseHubProgress(line);
+                if (!parsed)
+                    continue;
+                if (parsed.status === 'Downloading' || parsed.status === 'Starting download') {
+                    if (!isDownloading) {
+                        isDownloading = true;
+                        stopActiveSpinner(`Downloading Unity Editor ${version}`);
+                    }
+                    progress.update(parsed.percent, `Downloading Unity Editor ${version}`);
+                }
+                else if (parsed.status === 'Download complete') {
+                    if (isDownloading) {
+                        progress.complete(`Unity Editor ${version} downloaded`);
+                        isDownloading = false;
+                    }
+                }
+                else if (parsed.status === 'Installed') {
+                    stopActiveSpinner(`Unity Editor ${version} installed`);
+                }
+                else {
+                    // Post-download phases: show as a spinner so the user sees activity
+                    if (!isDownloading) {
+                        startPhaseSpinner(parsed.status);
+                    }
+                }
+            }
+        });
+        proc.stderr.on('data', (data) => { stderr += data.toString('utf-8'); });
+        proc.on('close', (code) => {
+            if (activeSpinner)
+                activeSpinner.stop();
+            if (code === 0) {
+                if (isDownloading) {
+                    progress.complete(`Unity Editor ${version} downloaded`);
+                }
+                resolve();
+            }
+            else {
+                if (isDownloading) {
+                    progress.fail(`Download failed for Unity Editor ${version}`);
+                }
+                reject(new Error(`Failed to install Unity Editor ${version} (exit code ${code})` +
+                    (stderr ? `:\n${stderr.trim()}` : '')));
+            }
+        });
+        proc.on('error', (err) => {
+            if (activeSpinner)
+                activeSpinner.stop();
+            reject(new Error(`Failed to install Unity Editor ${version}: ${err.message}`));
+        });
+    });
+}
+/**
+ * Install a Unity editor version via Unity Hub CLI.
+ * Automatically resolves changeset for versions not in the promoted releases list.
+ * Shows a progress bar during download and status during installation.
+ */
+export async function installEditor(hubPath, version, prefetchedReleases, options = {}) {
+    // Use pre-fetched releases when available to avoid a duplicate Hub CLI call
+    const output = outputFor(options);
+    const releases = prefetchedReleases ?? listAvailableReleases(hubPath, options);
+    const isPromoted = releases.some(r => r.version === version);
+    const baseArgs = ['--', '--headless', 'install', '--version', version];
+    if (isPromoted) {
+        await runHubInstallWithProgress(hubPath, baseArgs, version, options);
+        return;
+    }
+    // Version not in releases — resolve changeset
+    const changesetSpinner = output.startSpinner(`Resolving changeset for ${version}...`);
+    const changeset = await resolveChangeset(version);
+    if (!changeset) {
+        changesetSpinner.error(`Could not resolve changeset for ${version}`);
+        throw new Error(`Unity Editor ${version} is not in the promoted releases list and its changeset could not be resolved. ` +
+            `You can provide a changeset manually: unity-hub -- --headless install --version ${version} --changeset <hash>`);
+    }
+    changesetSpinner.success(`Resolved changeset: ${changeset}`);
+    await runHubInstallWithProgress(hubPath, [...baseArgs, '--changeset', changeset], version, options);
+}
+/**
+ * Resolve the Unity Editor executable path from an editor install path.
+ * The path from Unity Hub may already point to the executable (e.g. .../Editor/Unity.exe)
+ * or to the install root directory. This function handles both cases.
+ */
+function resolveEditorExecutable(editorPath) {
+    // If the path already points to an existing executable, use it directly
+    const basename = path.basename(editorPath).toLowerCase();
+    if (basename === 'unity.exe' || (basename === 'unity' && !fs.statSync(editorPath, { throwIfNoEntry: false })?.isDirectory())) {
+        if (fs.existsSync(editorPath)) {
+            return editorPath;
+        }
+    }
+    // Otherwise, build the path from the install root
+    const os = platform();
+    const candidates = [];
+    switch (os) {
+        case 'win32':
+            candidates.push(path.join(editorPath, 'Editor', 'Unity.exe'), path.join(editorPath, 'Unity.exe'));
+            break;
+        case 'darwin':
+            // If path already ends with .app, go directly into Contents/MacOS/Unity
+            if (editorPath.endsWith('.app')) {
+                candidates.push(path.join(editorPath, 'Contents', 'MacOS', 'Unity'));
+            }
+            candidates.push(path.join(editorPath, 'Unity.app', 'Contents', 'MacOS', 'Unity'), path.join(editorPath, 'Contents', 'MacOS', 'Unity'));
+            break;
+        default:
+            candidates.push(path.join(editorPath, 'Editor', 'Unity'), path.join(editorPath, 'Unity'));
+            break;
+    }
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    // Fallback: return the first candidate and let the caller handle the error
+    return candidates[0];
+}
+/**
+ * Create a new Unity project using the Unity Editor directly.
+ * Unity Hub's headless CLI does not support a 'create' command in newer versions,
+ * so we invoke the editor binary with -createProject -quit -batchmode instead.
+ */
+export function createProject(hubPath, projectPath, editorVersion, options = {}) {
+    const output = outputFor(options);
+    const runFileSync = options.processAdapter?.execFileSync ?? execFileSync;
+    // Find the editor install path
+    const editors = listInstalledEditors(hubPath, options);
+    if (editors.length === 0) {
+        throw new Error('No Unity editors installed. Install one with: unity-mcp-cli install-unity [version]');
+    }
+    let editor;
+    if (editorVersion) {
+        editor = editors.find(e => e.version === editorVersion);
+        if (!editor) {
+            throw new Error(`Unity Editor ${editorVersion} not found. Installed versions: ${editors.map(e => e.version).join(', ')}`);
+        }
+    }
+    else {
+        editor = findHighestEditor(editors);
+    }
+    const editorExe = resolveEditorExecutable(editor.path);
+    if (!fs.existsSync(editorExe)) {
+        throw new Error(`Unity Editor executable not found at: ${editorExe}`);
+    }
+    const args = ['-createProject', projectPath, '-quit', '-batchmode'];
+    output.info(`Creating Unity project at: ${projectPath}`);
+    output.label('Unity Editor', `${editor.version} (${editorExe})`);
+    try {
+        runFileSync(editorExe, args, {
+            encoding: 'utf-8',
+            timeout: 120000,
+            stdio: options.output === undefined ? 'inherit' : ['ignore', 'pipe', 'pipe'],
+        });
+        output.success('Project created successfully.');
+    }
+    catch (err) {
+        throw new Error(`Failed to create project: ${err.message}`);
+    }
+}
+//# sourceMappingURL=unity-hub.js.map