windows-development-sandbox 1.25.0 → 1.25.1

package/dist/guest/apps/resolvers-gamedev.js

@@ -1 +1,55 @@
-export const GAMEDEV_RESOLVERS = {};
+// Where the latest version of the game-development apps (catalogue-gamedev.ts) is, when it is not a plain GitHub
+// release: Krita (download.kde.org, with the SHA-256 its mirror publishes beside each file), Inkscape (inkscape.org's
+// portable 7z and its .sha256) and RenderDoc (renderdoc.org's portable zip; it publishes no checksum, the download is
+// HTTPS from renderdoc.org).
+import { fetchText } from '../../shared/download/index.js';
+const firstHash = (text) => /\b([0-9a-f]{64})\b/i.exec(text)?.[1].toLowerCase() ?? null;
+const byVersion = (a, b) => {
+    const x = a.split('.').map(Number);
+    const y = b.split('.').map(Number);
+    for (let i = 0; i < Math.max(x.length, y.length); i++)
+        if ((x[i] ?? 0) !== (y[i] ?? 0))
+            return (x[i] ?? 0) - (y[i] ?? 0);
+    return 0;
+};
+/** The newest Krita release folder that has the portable Windows zip (a hotfix folder may have only some files). */
+async function krita() {
+    const base = 'https://download.kde.org/stable/krita/';
+    const versions = [...(await fetchText(base)).matchAll(/href="(\d+\.\d+\.\d+(?:\.\d+)?)\/"/g)]
+        .map((m) => m[1])
+        .sort(byVersion)
+        .reverse()
+        .slice(0, 4);
+    for (const v of versions) {
+        const file = 'krita-x64-' + v + '.zip';
+        if (!(await fetchText(base + v + '/')).includes('href="' + file + '"'))
+            continue;
+        const url = base + v + '/' + file;
+        return { url, fileName: file, sha256: firstHash(await fetchText(url + '.sha256').catch(() => '')) };
+    }
+    throw new Error('no portable Krita zip on download.kde.org');
+}
+async function inkscape() {
+    const release = await fetchText('https://inkscape.org/release/');
+    const v = /\/release\/inkscape-(\d+\.\d+(?:\.\d+)?)\//.exec(release)?.[1];
+    if (!v)
+        throw new Error('could not find the latest Inkscape release');
+    const page = await fetchText('https://inkscape.org/release/inkscape-' + v + '/windows/64-bit/compressed-7z/dl/');
+    const item = /\/gallery\/item\/\d+\/inkscape-[\w.-]+-x64[\w-]*\.7z/.exec(page);
+    const sums = /https:\/\/media\.inkscape\.org\/media\/resources\/sigs\/[\w.-]+\.sha256/.exec(page)?.[0];
+    if (!item)
+        throw new Error('no portable Inkscape 7z for ' + v);
+    return {
+        url: 'https://inkscape.org' + item[0],
+        fileName: 'inkscape-' + v + '-x64.7z',
+        sha256: sums ? firstHash(await fetchText(sums).catch(() => '')) : null,
+    };
+}
+async function renderdoc() {
+    const page = await fetchText('https://renderdoc.org/builds');
+    const hit = /https:\/\/renderdoc\.org\/stable\/([\d.]+)\/RenderDoc_[\d.]+_64\.zip/.exec(page);
+    if (!hit)
+        throw new Error('could not find the RenderDoc download on renderdoc.org');
+    return { url: hit[0], fileName: 'RenderDoc_' + hit[1] + '_64.zip' };
+}
+export const GAMEDEV_RESOLVERS = { krita, inkscape, renderdoc };

package/dist/guest/boot/boot.js

@@ -52,7 +52,20 @@ import { setBackgroundWork, setSandboxStatus } from '../runtime/status.js';
 import { errMsg } from '../../core/util/errors.js';
 const PRIMARY_POLLS = 600;
 const POLL_MS = 500;
-const VSCODE_LANGUAGES = ['python', 'java', 'go', 'rust', 'cpp', 'msvc', 'dotnet', 'ruby', 'php', 'deno', 'pwsh'];
+const VSCODE_LANGUAGES = [
+    'python',
+    'java',
+    'go',
+    'rust',
+    'cpp',
+    'msvc',
+    'unreal',
+    'dotnet',
+    'ruby',
+    'php',
+    'deno',
+    'pwsh',
+];
 function startDaemon(env, secrets) {
     spawn(process.execPath, [path.join(path.dirname(process.argv[1]), 'daemon.js')], {
         detached: true,

package/dist/guest/boot/guide.js

@@ -7,6 +7,10 @@ import { dataDir, launchDir, logsDir, toolsDir } from '../runtime/paths.js';
 import { addonGuideLine, APPS, headroomGuideLine, RTK_GUIDE_LINE } from '../../shared/apps/index.js';
 import { installedAddon, installedRtk } from '../setup/agent-addons.js';
 import { projectFolderLines, toolLines } from './guide-lines.js';
+import { sandboxScriptsDir } from '../../shared/scripts.js';
+import { findUproject, unrealGuideLines } from '../../shared/unreal/index.js';
+import { DISK } from '../toolchains/engines/unreal-engines.js';
+import { readUnrealStatus } from '../toolchains/engines/unreal-status.js';
 const BEGIN = '<!-- agent-sandbox:begin (generated every boot, do not edit) -->';
 const END = '<!-- agent-sandbox:end -->';
 /** Drives other than C: are subst drives onto C:\Mirror\<letter> (mapped folders shown at their PC paths). */
@@ -25,6 +29,25 @@ const mirrorLine = () => {
 };
 /** Folders mapped for other projects at boot; launch folders from before mappedProjects only list the guest side. */
 const mappedFolders = () => session.mappedProjects ?? (session.roots ?? []).map((guest) => ({ host: 'a folder on the PC', guest }));
+/** The Mixamo import template, when this version ships one. */
+function mixamoScript() {
+    const file = path.join(sandboxScriptsDir(), 'templates', 'unreal', 'import_mixamo.py');
+    return fs.existsSync(file) ? file : null;
+}
+/** The Unreal lines (engine per project, build/test/package/debug commands) when the sandbox is set up for Unreal. */
+function unrealLines(projects) {
+    const any = session.toolchains.unreal.enabled === true || projects.some((p) => p.tools?.some((t) => /^unreal/.test(t)));
+    if (!any)
+        return [];
+    const status = readUnrealStatus();
+    if (!status.updatedAt)
+        return [];
+    const folders = [workspace, ...projects.map((p) => p.guest)];
+    return unrealGuideLines(status, folders
+        .filter((f, i) => folders.findIndex((g) => g.toLowerCase() === f.toLowerCase()) === i)
+        .filter((f) => status.projects.some((p) => p.workspace.toLowerCase() === f.toLowerCase()))
+        .map((f) => ({ workspace: f, uproject: findUproject(f, DISK) })), { mixamo: { downloads: path.join(dataDir, 'downloads'), script: mixamoScript() } });
+}
 /** Deliberately tiny: it is loaded into every conversation. */
 export function sandboxGuide(toolSummary, lan = 'blocked', projects = [], addons = []) {
     return [
@@ -45,6 +68,7 @@ export function sandboxGuide(toolSummary, lan = 'blocked', projects = [], addons
         '- RO: `' + launchDir + "` (this boot's scripts) · lost on close: everything else, incl. `C:\\nvm` (Node symlink)",
         ...mirrorLine(),
         ...toolLines(session.project, toolSummary, projects),
+        ...unrealLines(projects),
         // Agent add-ons that change how the agent works (rtk, Headroom, MCP servers, ccusage).
         ...addons,
         '- Persistent installs: `npm i -g` (per nvm version), `pip`, `cargo install`, `dotnet tool -g`, `uv tool`, `bun add -g`. Real installers must re-run each boot via a hook (ask the user).',

package/dist/guest/daemon/daemon.js

@@ -12,6 +12,7 @@ import { liveFolders } from './live.js';
 import { warn } from '../runtime/log.js';
 import { errMsg } from '../../core/util/errors.js';
 import { flushAccounts } from './accounts.js';
+import { captureLauncherEngines } from '../toolchains/engines/unreal-engines.js';
 const POLL_MS = 400;
 const MEM_SAVE_MS = 120000;
 export class Daemon {
@@ -47,6 +48,8 @@ export class Daemon {
             safely('claude-mem save', saveClaudeMem);
             safely('agent databases save', saveLocalState);
             void flushAccounts();
+            // Engines the Epic Games Launcher installed on the data disk since: kept for the next sandbox.
+            void captureLauncherEngines().catch((e) => warn('Unreal launcher save: ' + errMsg(e)));
         }
     }
     handle(req) {

package/dist/guest/setup/addon-mcp.d.ts

@@ -1,2 +1,9 @@
+/** The Unreal editor's MCP server (Unreal 5.8's ModelContextProtocol plugin), set by the Unreal engines step. */
+export declare const UNREAL_MCP_NAME = "sbx-unreal-editor";
+/**
+ * Adds the Unreal editor's MCP server (its address) to the next writeAddonMcpServers, or takes it away (null). It only
+ * answers while the editor runs with the plugin on; until then Claude Code lists it as not connected.
+ */
+export declare function setUnrealMcp(url: string | null): void;
 /** Sets the add-ons' MCP servers in the sandbox's .claude.json (and Codex's config.toml); the names that are on. */
 export declare function writeAddonMcpServers(): string[];

package/dist/guest/setup/addon-mcp.js

@@ -13,8 +13,18 @@ import { dryRun } from '../runtime/paths.js';
 import { claudeDir, session, stateDir } from '../runtime/session.js';
 import { log, warn } from '../runtime/log.js';
 import { installedMcpAddons } from './agent-addons.js';
-/** The names of every MCP server an add-on can add (the ones the sandbox may remove). */
-const ADDON_MCP_NAMES = APPS.flatMap((a) => (a.mcp ? [a.mcp.name] : []));
+/** The Unreal editor's MCP server (Unreal 5.8's ModelContextProtocol plugin), set by the Unreal engines step. */
+export const UNREAL_MCP_NAME = 'sbx-unreal-editor';
+let unrealMcp = null;
+/** The names of every MCP server the sandbox can add (the ones it may remove). */
+const ADDON_MCP_NAMES = [...APPS.flatMap((a) => (a.mcp ? [a.mcp.name] : [])), UNREAL_MCP_NAME];
+/**
+ * Adds the Unreal editor's MCP server (its address) to the next writeAddonMcpServers, or takes it away (null). It only
+ * answers while the editor runs with the plugin on; until then Claude Code lists it as not connected.
+ */
+export function setUnrealMcp(url) {
+    unrealMcp = url ? { type: 'http', url } : null;
+}
 /** Variables only this sandbox can tell an add-on's server (where Comet is). */
 function placeEnv(id) {
     if (id !== 'comet-mcp')
@@ -34,7 +44,10 @@ function addonServers() {
 export function writeAddonMcpServers() {
     const on = addonServers();
     writeCodexAddonMcpServers(on);
-    const servers = Object.fromEntries(on.map(({ mcp, server }) => [mcp.name, server]));
+    const servers = {
+        ...Object.fromEntries(on.map(({ mcp, server }) => [mcp.name, server])),
+        ...(unrealMcp ? { [UNREAL_MCP_NAME]: unrealMcp } : {}),
+    };
     const file = path.join(claudeDir, '.claude.json');
     let state = {};
     if (fs.existsSync(file)) {
@@ -72,10 +85,12 @@ function writeCodexAddonMcpServers(on) {
     const servers = Object.fromEntries(on
         .filter(({ mcp }) => mcp.codex)
         .map(({ mcp, server }) => [mcp.name, { ...server, ...(mcp.envVars?.length ? { envVars: mcp.envVars } : {}) }]));
+    if (unrealMcp)
+        servers[UNREAL_MCP_NAME] = unrealMcp;
     const before = exists(file) ? fs.readFileSync(file, 'utf8') : '';
     if (!before && !Object.keys(servers).length)
         return;
-    const known = APPS.flatMap((a) => (a.mcp?.codex ? [a.mcp.name] : []));
+    const known = [...APPS.flatMap((a) => (a.mcp?.codex ? [a.mcp.name] : [])), UNREAL_MCP_NAME];
     const result = codexWithAddonMcpServers(before, servers, known);
     for (const name of result.skipped)
         warn('Codex MCP servers from Apps: ' + name + ' is already in config.toml in another form, left as it is');

package/dist/guest/setup/browser-gpu.js

@@ -1,18 +1,21 @@
-// Browsers in the sandbox draw without the GPU (Edge and Chrome machine policy, written every boot). With sandbox.vGpu
-// the sandbox shares this PC's graphics card through one virtual GPU: a browser's GPU process starting next to a game
-// or other Direct3D program there has taken the whole sandbox down. Pages still render, WebGL included, in software;
-// programs that need the GPU keep it. Without vGPU nothing changes (there is no GPU to use).
+// Browsers in the sandbox (Edge and Chrome machine policy, written every boot) draw without the GPU, and download to
+// C:\AgentData\downloads, which is kept between sandboxes. With sandbox.vGpu the sandbox shares this PC's graphics card
+// through one virtual GPU: a browser's GPU process starting next to a game or other Direct3D program there has taken
+// the whole sandbox down. Pages still render, WebGL included, in software; programs that need the GPU keep it. Without
+// vGPU there is no GPU to use, so only the download folder matters.
+import path from 'node:path';
 import { SYSTEM } from '../../shared/system.js';
-import { dryRun, isWin } from '../runtime/paths.js';
+import { browserPolicies } from '../../shared/browser-policy.js';
+import { dataDir, dryRun, isWin } from '../runtime/paths.js';
 import { exec } from '../runtime/process.js';
 import { log } from '../runtime/log.js';
-const POLICY_KEYS = ['HKLM\\SOFTWARE\\Policies\\Microsoft\\Edge', 'HKLM\\SOFTWARE\\Policies\\Google\\Chrome'];
+import { mkdirp } from '../runtime/fs.js';
 export function keepBrowsersOffGpu() {
     if (dryRun || !isWin)
         return;
-    for (const key of POLICY_KEYS)
-        exec(SYSTEM.reg(), ['add', key, '/v', 'HardwareAccelerationModeEnabled', '/t', 'REG_DWORD', '/d', '0', '/f'], {
-            stdio: 'ignore',
-        });
-    log('Browsers draw without the GPU (Edge and Chrome policy).');
+    const downloads = path.join(dataDir, 'downloads');
+    mkdirp(downloads);
+    for (const p of browserPolicies({ downloads }))
+        exec(SYSTEM.reg(), ['add', p.key, '/v', p.name, '/t', p.type, '/d', p.data, '/f'], { stdio: 'ignore' });
+    log('Browsers draw without the GPU and download to ' + downloads + '.');
 }

package/dist/guest/setup/headroom.js

@@ -5,6 +5,7 @@ import fs from 'node:fs';
 import http from 'node:http';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
+import { rotateLog } from '../../shared/io/index.js';
 import { HEADROOM_PORT, headroomArgs, headroomEnv, headroomUrl } from '../../shared/apps/index.js';
 import { logsDir } from '../runtime/paths.js';
 import { portOpen, waitForPort } from '../runtime/ports.js';
@@ -12,6 +13,8 @@ import { log } from '../runtime/log.js';
 import { installedAddon } from './agent-addons.js';
 /** The proxy's log (it redacts keys and tokens in what it logs). */
 export const HEADROOM_LOG = path.join(logsDir, 'headroom.log');
+/** The proxy logs every request and the file lives on the data disk: past this it is kept as headroom.log.1. */
+const HEADROOM_LOG_LIMIT = 20 * 1024 * 1024;
 /** Whether Headroom's own health check answers on the port (not some other program that took it). */
 function answersAsHeadroom(port) {
     return new Promise((resolve) => {
@@ -53,6 +56,7 @@ async function startProxy(env) {
         return false;
     if (await portOpen(HEADROOM_PORT))
         return true;
+    rotateLog(HEADROOM_LOG, HEADROOM_LOG_LIMIT);
     const out = fs.openSync(HEADROOM_LOG, 'a');
     try {
         spawn(exe, headroomArgs(HEADROOM_PORT), {

package/dist/guest/toolchains/engines/epic-launcher.d.ts

@@ -0,0 +1,26 @@
+import { type LauncherEntry } from '../../../shared/unreal/index.js';
+/** The launcher's program (launcher 17+ is 64-bit; older ones were in Win32). */
+export declare function launcherExe(): string | null;
+/** Downloads the launcher's MSI ahead of the install (once). */
+export declare function fetchLauncher(): Promise<void>;
+/** Installs the launcher when this sandbox does not have it yet (the MSI, quietly). Returns its program. */
+export declare function ensureLauncher(): Promise<string>;
+export interface LauncherPlaceResult {
+    readonly installLocation: string | null;
+    readonly problem: string | null;
+    readonly freeBytes: number | null;
+    readonly needBytes: number;
+}
+/** Points the launcher's default install folder at tools\unreal\engines (every settings file it may read). */
+export declare function placeEngines(persist: boolean): LauncherPlaceResult;
+/** The saved LauncherInstalled.dat entries of engines in tools\unreal\engines whose folder is still there. */
+export declare function savedEntries(): LauncherEntry[];
+/** Puts the saved manifests back where the launcher reads them; the engine folders they name. */
+export declare function restoreLauncherItems(): string[];
+/** Merges these entries into the launcher's LauncherInstalled.dat (foreign entries kept). */
+export declare function writeLauncherEntries(entries: readonly LauncherEntry[]): void;
+/**
+ * Saves what the launcher knows about engines it installed into tools\unreal\engines (new or changed manifests, its
+ * LauncherInstalled.dat entries). Cheap: a few small files. Returns whether something new was saved.
+ */
+export declare function saveLauncherState(): boolean;

package/dist/guest/toolchains/engines/epic-launcher.js

@@ -0,0 +1,127 @@
+// The Epic Games Launcher in the sandbox: installed every boot from its MSI (downloaded once into tools\unreal, run
+// only when Epic's signature checks out; a sandbox loses Program Files), pointed at the data disk for engines
+// (GameUserSettings.ini [Launcher] DefaultAppInstallLocation, in the encoding the file has), and given back what it
+// knew about the engines it installed there: their .item manifests and LauncherInstalled.dat entries are saved on the
+// data disk while the sandbox runs (the daemon calls saveLauncherState) and put back at the next boot.
+import fs from 'node:fs';
+import path from 'node:path';
+import { z } from 'zod';
+import { readBoundedFile } from '../../../shared/io/bounded.js';
+import { readValid, writeJsonAtomic } from '../../../shared/io/json.js';
+import { SYSTEM } from '../../../shared/system.js';
+import { enginePlaceProblem, ENGINE_NEED_BYTES, entriesUnder, launcherInstalledFile, launcherManifestsDir, launcherSettingsFiles, MAX_LAUNCHER_FILE_BYTES, mergeLauncherInstalled, restoreItems, saveItems, setLauncherInstallLocation, } from '../../../shared/unreal/index.js';
+import { errMsg } from '../../../core/util/errors.js';
+import { runInstaller } from '../../runtime/pools.js';
+import { exists, mkdirp } from '../../runtime/fs.js';
+import { log } from '../../runtime/log.js';
+import { SIGNERS, signedInstaller } from '../installers.js';
+import { ENGINES_DIR, SAVED_DIR, UNREAL_DIR } from './unreal-status.js';
+const MSI_URL = 'https://launcher-public-service-prod06.ol.epicgames.com/launcher/api/installer/download/EpicGamesLauncherInstaller.msi';
+const MSI_FILE = path.join(UNREAL_DIR, 'EpicGamesLauncherInstaller.msi');
+const SAVED_MANIFESTS = path.join(SAVED_DIR, 'Manifests');
+const SAVED_ENTRIES = path.join(SAVED_DIR, 'LauncherInstalled.json');
+const programData = () => process.env.ProgramData ?? 'C:\\ProgramData';
+const localAppData = () => process.env.LOCALAPPDATA ?? '';
+/** The launcher's program (launcher 17+ is 64-bit; older ones were in Win32). */
+export function launcherExe() {
+    const root = path.join(process.env['ProgramFiles(x86)'] ?? 'C:\\Program Files (x86)', 'Epic Games', 'Launcher');
+    for (const arch of ['Win64', 'Win32']) {
+        const exe = path.join(root, 'Portal', 'Binaries', arch, 'EpicGamesLauncher.exe');
+        if (exists(exe))
+            return exe;
+    }
+    return null;
+}
+/** Downloads the launcher's MSI ahead of the install (once). */
+export async function fetchLauncher() {
+    if (!launcherExe())
+        await launcherMsi();
+}
+const launcherMsi = () => signedInstaller(MSI_URL, MSI_FILE, 'the Epic Games Launcher (~250 MB once)', SIGNERS.epic);
+/** Installs the launcher when this sandbox does not have it yet (the MSI, quietly). Returns its program. */
+export async function ensureLauncher() {
+    const have = launcherExe();
+    if (have)
+        return have;
+    const msi = await launcherMsi();
+    log('Installing the Epic Games Launcher ...');
+    const code = await runInstaller(SYSTEM.msiexec(), ['/i', msi, '/qn', '/norestart']);
+    const exe = launcherExe();
+    if ((code !== 0 && code !== 3010) || !exe)
+        throw new Error('the Epic Games Launcher installer failed (msiexec exit ' + code + ')');
+    return exe;
+}
+/** Points the launcher's default install folder at tools\unreal\engines (every settings file it may read). */
+export function placeEngines(persist) {
+    let error;
+    if (persist)
+        try {
+            mkdirp(ENGINES_DIR);
+            for (const file of launcherSettingsFiles(localAppData()))
+                setLauncherInstallLocation(file, ENGINES_DIR);
+        }
+        catch (e) {
+            error = "could not write the launcher's settings (" + errMsg(e) + ')';
+        }
+    else
+        error = 'toolchains.unreal.persistEngines is off';
+    const set = persist && !error;
+    const { problem, freeBytes } = enginePlaceProblem(set ? { set } : { set, error: error }, ENGINES_DIR);
+    return { installLocation: set ? ENGINES_DIR : null, problem, freeBytes, needBytes: ENGINE_NEED_BYTES };
+}
+const SavedEntriesSchema = z.object({
+    entries: z
+        .array(z.object({
+        InstallLocation: z.string().max(1024),
+        NamespaceId: z.string().max(200),
+        ItemId: z.string().max(200),
+        ArtifactId: z.string().max(200),
+        AppVersion: z.string().max(200),
+        AppName: z.string().max(200),
+    }))
+        .max(64),
+});
+/** The saved LauncherInstalled.dat entries of engines in tools\unreal\engines whose folder is still there. */
+export function savedEntries() {
+    return (readValid(SavedEntriesSchema, SAVED_ENTRIES)?.entries ?? []).filter((e) => e.InstallLocation.toLowerCase().startsWith(ENGINES_DIR.toLowerCase() + '\\') && exists(e.InstallLocation));
+}
+/** Puts the saved manifests back where the launcher reads them; the engine folders they name. */
+export function restoreLauncherItems() {
+    return restoreItems(SAVED_MANIFESTS, launcherManifestsDir(programData()), ENGINES_DIR, exists);
+}
+/** Merges these entries into the launcher's LauncherInstalled.dat (foreign entries kept). */
+export function writeLauncherEntries(entries) {
+    if (!entries.length)
+        return;
+    const file = launcherInstalledFile(programData());
+    const bytes = readBoundedFile(file, MAX_LAUNCHER_FILE_BYTES);
+    if (!bytes && fs.existsSync(file))
+        throw new Error(file + ' is too big to read');
+    const next = mergeLauncherInstalled(bytes ? bytes.toString('utf8') : null, entries);
+    mkdirp(path.dirname(file));
+    fs.writeFileSync(file, next, 'utf8');
+}
+/**
+ * Saves what the launcher knows about engines it installed into tools\unreal\engines (new or changed manifests, its
+ * LauncherInstalled.dat entries). Cheap: a few small files. Returns whether something new was saved.
+ */
+export function saveLauncherState() {
+    if (!exists(ENGINES_DIR))
+        return false;
+    const items = saveItems(launcherManifestsDir(programData()), SAVED_MANIFESTS, ENGINES_DIR);
+    const bytes = readBoundedFile(launcherInstalledFile(programData()), MAX_LAUNCHER_FILE_BYTES);
+    const live = bytes ? entriesUnder(bytes.toString('utf8'), ENGINES_DIR) : [];
+    const old = readValid(SavedEntriesSchema, SAVED_ENTRIES)?.entries ?? [];
+    const merged = [
+        ...old.filter((o) => !live.some((l) => l.InstallLocation.toLowerCase() === o.InstallLocation.toLowerCase())),
+        ...live,
+    ].filter((e) => exists(e.InstallLocation));
+    const changed = JSON.stringify(merged) !== JSON.stringify(old);
+    if (changed) {
+        mkdirp(SAVED_DIR);
+        writeJsonAtomic(SAVED_ENTRIES, { entries: merged.slice(0, 64) });
+    }
+    if (items.length || changed)
+        log('Unreal: saved what the Epic Games Launcher knows about its engines on the data disk');
+    return items.length > 0 || changed;
+}

package/dist/guest/toolchains/engines/unreal-engines.d.ts

@@ -1,4 +1,24 @@
+import { type EngineFs, type LauncherEntry, type MappedEngine, type UnrealEngine } from '../../../shared/unreal/index.js';
 import type { Toolchains } from '../../../core/types.js';
 import type { ToolCtx } from '../step.js';
 import type { ToolEnv } from '../tool-env.js';
-export declare function setupUnrealEngines(env: ToolEnv, _config: Toolchains['unreal'], _ctx: ToolCtx): Promise<void>;
+/** The real disk, read bounded. */
+export declare const DISK: EngineFs;
+/** This PC's engines the host mapped (session.json's pcInstalls). */
+export declare function mappedEngines(ctx: Pick<ToolCtx, 'pcInstalls'>): MappedEngine[];
+/** Every engine this sandbox has (an install the launcher has not finished is not one yet). */
+export declare function sandboxEngines(ctx: Pick<ToolCtx, 'pcInstalls'>, disk?: EngineFs): UnrealEngine[];
+/** The LauncherInstalled.dat entries for the installed builds: the launcher's own saved ones, else made from them. */
+export declare function launcherEntries(engines: readonly UnrealEngine[], ctx: Pick<ToolCtx, 'pcInstalls'>): LauncherEntry[];
+/** Registers the engines machine-wide: the registry, LauncherInstalled.dat, the .uproject file association. */
+export declare function registerEngines(engines: readonly UnrealEngine[], selectorFrom: UnrealEngine | null, ctx: Pick<ToolCtx, 'pcInstalls'>, aliases?: readonly {
+    readonly id: string;
+    readonly dir: string;
+}[]): Promise<void>;
+/**
+ * While the sandbox runs (the daemon, every few minutes): saves what the launcher learned about engines it installed
+ * on the data disk and, when something is new, registers them and lists them for the Unreal page.
+ */
+export declare function captureLauncherEngines(): Promise<void>;
+/** The project's engine on PATH, its variables, the guide's facts; the engines registered. */
+export declare function setupUnrealEngines(env: ToolEnv, config: Toolchains['unreal'], ctx: ToolCtx): Promise<void>;

package/dist/guest/toolchains/engines/unreal-engines.js

@@ -1,4 +1,164 @@
-import { notAvailableYet } from '../not-yet.js';
-export async function setupUnrealEngines(env, _config, _ctx) {
-    notAvailableYet(env, 'Unreal engines');
+// Unreal engines, for each project: every engine the sandbox has (this PC's, mapped read-only or as folders you
+// registered; the launcher's and other folders in tools\unreal\engines; source builds in project roots) is registered
+// (the registry, the launcher's LauncherInstalled.dat, the .uproject file association), and the engine the project's
+// .uproject names (else the newest) goes on its PATH with UE_ROOT, the derived data cache on the data disk and, with
+// Unreal 5.8's MCP plugin, the editor's MCP server in Claude Code. Machine-wide writes only add; a project that joins
+// later only adds its own engine choice.
+import fs from 'node:fs';
+import path from 'node:path';
+import { readBoundedFile } from '../../../shared/io/bounded.js';
+import { chooseEngine, ddcVars, engineExtraDirs, engineToolDirs, engineVars, fileAssociationPlan, findEngines, findUproject, hasMcpPlugin, incompleteDirs, itemSizes, launcherManifestsDir, launcherEntriesFor, registryPlan, UNREAL_MCP_URL, unrealSummaryLine, uprojectAssociation, versionSelectorIn, versionText, } from '../../../shared/unreal/index.js';
+import { errMsg } from '../../../core/util/errors.js';
+import { exists, mkdirp } from '../../runtime/fs.js';
+import { log, warn } from '../../runtime/log.js';
+import { dryRun } from '../../runtime/paths.js';
+import { runScriptWithJsonAsync } from '../../runtime/process.js';
+import { projectWorkspace } from '../../runtime/project-context.js';
+import { session } from '../../runtime/session.js';
+import { setUnrealMcp, writeAddonMcpServers } from '../../setup/addon-mcp.js';
+import { saveLauncherState, savedEntries, writeLauncherEntries } from './epic-launcher.js';
+import { DDC_DIR, ENGINES_DIR, SAVED_DIR, updateUnrealStatus } from './unreal-status.js';
+const SAVED_MANIFESTS = path.join(SAVED_DIR, 'Manifests');
+/** The real disk, read bounded. */
+export const DISK = {
+    exists: (file) => exists(file),
+    read: (file, max) => readBoundedFile(file, max),
+    list: (dir) => {
+        try {
+            return fs.readdirSync(dir).slice(0, 500);
+        }
+        catch {
+            return []; // Not a folder: nothing in it.
+        }
+    },
+};
+/** This PC's engines the host mapped (session.json's pcInstalls). */
+export function mappedEngines(ctx) {
+    return ctx.pcInstalls.items
+        .filter((i) => i.kind === 'unreal')
+        .map((i) => ({
+        guest: i.guest,
+        id: i.id,
+        ...(i.writable ? { writable: true } : {}),
+        ...(i.buildId ? { buildId: i.buildId } : {}),
+    }));
+}
+/** The project roots of this sandbox (their folders may hold source builds). */
+function projectRoots() {
+    const roots = (session.mappedProjects ?? []).filter((m) => m.root).map((m) => m.guest);
+    return [...new Set([...roots, ...(session.roots ?? [])])].filter((r) => exists(r));
+}
+/** The engines the launcher installed in tools\unreal\engines (its saved manifests and entries name them). */
+function launcherDirs() {
+    return [...savedEntries().map((e) => e.InstallLocation), ...itemSizes(SAVED_MANIFESTS).keys()];
+}
+/** Every engine this sandbox has (an install the launcher has not finished is not one yet). */
+export function sandboxEngines(ctx, disk = DISK) {
+    const incomplete = incompleteDirs(launcherManifestsDir(process.env.ProgramData ?? 'C:\\ProgramData'), SAVED_MANIFESTS);
+    return findEngines({
+        mapped: mappedEngines(ctx),
+        enginesRoot: ENGINES_DIR,
+        launcherDirs: launcherDirs(),
+        projectRoots: projectRoots(),
+    }, disk).filter((e) => !incomplete.has(path.win32.normalize(e.dir).toLowerCase()));
+}
+/** The LauncherInstalled.dat entries for the installed builds: the launcher's own saved ones, else made from them. */
+export function launcherEntries(engines, ctx) {
+    return launcherEntriesFor(engines, savedEntries(), ctx.pcInstalls.items);
+}
+/** Registers the engines machine-wide: the registry, LauncherInstalled.dat, the .uproject file association. */
+export async function registerEngines(engines, selectorFrom, ctx, aliases = []) {
+    const selector = selectorFrom ? versionSelectorIn(selectorFrom.dir) : null;
+    const values = [
+        ...registryPlan(engines, aliases),
+        ...(selector && exists(selector) ? fileAssociationPlan(selector) : []),
+    ];
+    if (values.length)
+        await runScriptWithJsonAsync('set-registry-values.ps1', 'PlanFile', { values });
+    try {
+        writeLauncherEntries(launcherEntries(engines, ctx));
+    }
+    catch (e) {
+        warn("Unreal: the Epic Games Launcher's LauncherInstalled.dat was left as it is (" + errMsg(e) + ')');
+    }
+}
+/**
+ * While the sandbox runs (the daemon, every few minutes): saves what the launcher learned about engines it installed
+ * on the data disk and, when something is new, registers them and lists them for the Unreal page.
+ */
+export async function captureLauncherEngines() {
+    const unreal = session.toolchains.unreal;
+    if (dryRun || unreal.enabled !== true || !unreal.persistEngines || !saveLauncherState())
+        return;
+    const ctx = { pcInstalls: session.pcInstalls ?? { items: [] } };
+    const engines = sandboxEngines(ctx);
+    await registerEngines(engines, engines[0] ?? null, ctx);
+    const sizes = itemSizes(SAVED_MANIFESTS);
+    updateUnrealStatus((s) => ({ ...s, engines: engines.map((e) => statusEngine(e, sizes)) }));
+}
+const statusEngine = (e, sizes) => ({
+    id: e.id,
+    dir: e.dir,
+    version: versionText(e.version),
+    build: e.build,
+    origin: e.origin,
+    writable: e.writable,
+    sizeBytes: sizes.get(e.dir.toLowerCase()) ?? null,
+});
+/** The project's engine on PATH, its variables, the guide's facts; the engines registered. */
+export async function setupUnrealEngines(env, config, ctx) {
+    const workspace = projectWorkspace();
+    const engines = sandboxEngines(ctx);
+    const uproject = findUproject(workspace, DISK);
+    const text = uproject ? readBoundedFile(uproject, 1024 * 1024) : null;
+    const association = (text ? uprojectAssociation(text.toString('utf8')) : null) ?? { kind: 'none' };
+    const choice = chooseEngine(engines, association);
+    const engine = choice.engine;
+    if (dryRun) {
+        log('(dry run) would register ' + engines.length + ' Unreal engines and use ' + (engine?.dir ?? 'none'));
+        return;
+    }
+    try {
+        await registerEngines(engines, engine ?? engines[0] ?? null, ctx, engine && choice.alias ? [{ id: choice.alias, dir: engine.dir }] : []);
+    }
+    catch (e) {
+        warn('Unreal: registering the engines failed (' + errMsg(e) + '); Build.bat and RunUAT.bat still work from PATH');
+    }
+    const ddc = config.derivedDataCache === 'persisted' ? mkdirp(DDC_DIR) : null;
+    Object.assign(env.vars, ddcVars(config.derivedDataCache, DDC_DIR));
+    if (engine) {
+        env.prepend.push(...engineToolDirs(engine.dir, DISK));
+        env.append.push(...engineExtraDirs(engine.dir, DISK));
+        Object.assign(env.vars, engineVars(engine));
+    }
+    const mcp = engine && hasMcpPlugin(engine, DISK) ? UNREAL_MCP_URL : null;
+    if (mcp || !ctx.duringSession) {
+        setUnrealMcp(mcp);
+        try {
+            writeAddonMcpServers();
+        }
+        catch (e) {
+            warn("Unreal: the editor's MCP server was not added to Claude Code (" + errMsg(e) + ')');
+        }
+    }
+    const sizes = itemSizes(SAVED_MANIFESTS);
+    const status = updateUnrealStatus((s) => ({
+        ...s,
+        engines: engines.map((e) => statusEngine(e, sizes)),
+        projects: [
+            ...s.projects.filter((p) => p.workspace.toLowerCase() !== workspace.toLowerCase()),
+            { workspace, engine: engine?.dir ?? null, reason: choice.reason },
+        ].slice(-64),
+        ddc: { mode: config.derivedDataCache, dir: ddc },
+        vaults: ctx.pcInstalls.items.filter((i) => i.kind === 'unreal-vault').map((i) => i.guest),
+        mcpUrl: mcp ?? (ctx.duringSession ? s.mcpUrl : null),
+    }));
+    env.summary.push(unrealSummaryLine(status, workspace));
+    log('Unreal: ' +
+        engines.length +
+        ' engine(s); ' +
+        (engine ? 'this project uses ' + engine.id + ' at ' + engine.dir : 'none for this project') +
+        ' (' +
+        choice.reason +
+        ')');
 }

package/dist/guest/toolchains/engines/unreal-status.d.ts

@@ -0,0 +1,13 @@
+import { type UnrealStatus } from '../../../shared/unreal/index.js';
+export declare const UNREAL_DIR: string;
+/** Where the Epic Games Launcher installs engines (persistEngines). */
+export declare const ENGINES_DIR: string;
+/** The engines' local derived data cache (derivedDataCache "persisted"). */
+export declare const DDC_DIR: string;
+/** The launcher's manifests and entries of the engines in ENGINES_DIR, kept for later boots. */
+export declare const SAVED_DIR: string;
+export declare function readUnrealStatus(): UnrealStatus;
+/** Changes the status with `change` and writes it (whole, atomically). */
+export declare function updateUnrealStatus(change: (s: UnrealStatus) => UnrealStatus): UnrealStatus;
+/** A fresh status at boot: the machine parts start over, the engines and projects are found again. */
+export declare function resetUnrealStatus(): void;