windows-development-sandbox 1.25.0 → 1.25.1

package/dist/shared/unreal/status.js

@@ -0,0 +1,57 @@
+// What the sandbox last found for Unreal (tools\unreal\status.json): its engines, which engine each project builds
+// with, the Epic Games Launcher's install folder, Visual Studio, the debuggers and the derived data cache. The sandbox
+// writes it every boot and when a project joins; the Unreal page on this PC reads it. It is written by the guest, so
+// the host reads it with this schema (bounded strings and lists) and prints its text through safeText.
+import { z } from 'zod';
+/** The file in tools\unreal. */
+export const UNREAL_STATUS_FILE = 'status.json';
+const Text = (max = 400) => z.string().max(max);
+export const UnrealStatusSchema = z.object({
+    updatedAt: Text(40),
+    engines: z
+        .array(z.object({
+        id: Text(100),
+        dir: Text(),
+        version: Text(40),
+        build: z.enum(['installed', 'source']),
+        origin: z.enum(['pc', 'pc-folder', 'launcher', 'data', 'project']),
+        writable: z.boolean(),
+        /** Its size on disk, when it was counted (the launcher's manifest says it). */
+        sizeBytes: z.number().int().min(0).nullable(),
+    }))
+        .max(32),
+    projects: z
+        .array(z.object({
+        workspace: Text(),
+        /** The engine's folder, null when there is none for it. */
+        engine: Text().nullable(),
+        reason: Text(),
+    }))
+        .max(64),
+    launcher: z.object({
+        installed: z.boolean(),
+        /** Where the launcher installs engines; null when it could not be set. */
+        installLocation: Text().nullable(),
+        /** Why engines would not go to the data disk (shown loudly), null when they do. */
+        problem: Text(600).nullable(),
+        freeBytes: z.number().min(0).nullable(),
+        needBytes: z.number().min(0),
+    }),
+    visualStudio: z.object({
+        version: Text(60),
+        path: Text(),
+        /** "kept on the data disk", "installed" ... ('' when there is none). */
+        how: Text(100),
+        /** What UnrealBuildTool's way of looking finds (the Setup API, MSVC, the Windows SDK), in plain words. */
+        check: Text(600),
+        /** Whether that check found everything a build needs. */
+        ok: z.boolean(),
+    }),
+    /** cdb.exe of the Windows SDK's debuggers, null when they are missing. */
+    debugger: Text().nullable(),
+    ddc: z.object({ mode: z.enum(['persisted', 'local']), dir: Text().nullable() }),
+    /** This PC's vault cache folders (Fab and Marketplace packs), read-only in the sandbox. */
+    vaults: z.array(Text()).max(4).default([]),
+    /** The editor's MCP server address when the project's engine has the plugin. */
+    mcpUrl: Text(200).nullable(),
+});

package/dist/shared/unreal/vault.d.ts

@@ -0,0 +1,21 @@
+/** The default vault cache under a ProgramData folder. */
+export declare function defaultVaultDir(programData: string): string;
+/** The vault cache folders a launcher settings text names (VaultCacheDirectories / VaultCacheLocation lines). */
+export declare function vaultDirsFromIni(ini: string): string[];
+export interface VaultFs {
+    exists(file: string): boolean;
+    list(dir: string): string[];
+    /** A file's size, or null when it is a folder or missing. */
+    size(file: string): number | null;
+    isDir(dir: string): boolean;
+}
+export interface VaultPack {
+    readonly name: string;
+    /** Bytes counted (at least this much when `partial`). */
+    readonly sizeBytes: number;
+    readonly partial: boolean;
+    /** "content" (data\Content: copy it into a project's Content) or "plugin" (a code plugin: into Plugins). */
+    readonly kind: 'content' | 'plugin' | 'other';
+}
+/** The packs in a vault cache folder, by name, with their size (bounded: very big packs read "at least"). */
+export declare function vaultPacks(vault: string, fs: VaultFs): VaultPack[];

package/dist/shared/unreal/vault.js

@@ -0,0 +1,67 @@
+// The Epic Games Launcher's vault cache: the Fab and Marketplace packs it downloaded but has not added to a project
+// yet, one folder per pack (<VaultCache>\<Pack>\data\Content\..., or data\<Plugin>.uplugin for a code plugin). Where
+// it is comes from the launcher's GameUserSettings.ini (VaultCacheDirectories in launcher 20.3; older files may say
+// VaultCacheLocation), else its default %ProgramData%\Epic\EpicGamesLauncher\VaultCache. Pure apart from the
+// EngineFs-style reads it is given; every walk is bounded.
+import path from 'node:path';
+const win = path.win32;
+const MAX_PACKS = 500;
+const MAX_FILES_PER_PACK = 5_000;
+const MAX_FILES = 50_000;
+/** The default vault cache under a ProgramData folder. */
+export function defaultVaultDir(programData) {
+    return win.join(programData, 'Epic', 'EpicGamesLauncher', 'VaultCache');
+}
+/** The vault cache folders a launcher settings text names (VaultCacheDirectories / VaultCacheLocation lines). */
+export function vaultDirsFromIni(ini) {
+    const found = [];
+    for (const raw of ini.split(/\r?\n/).slice(0, 5000)) {
+        const m = /^\s*[+.-]?\s*(VaultCacheDirectories|VaultCacheLocation)\s*=\s*(.{0,2000})$/i.exec(raw);
+        if (!m)
+            continue;
+        for (const hit of m[2].matchAll(/[A-Za-z]:[\\/][^"\r\n,()]{0,400}/g)) {
+            const dir = win.normalize(hit[0].trim().replace(/\//g, '\\')).replace(/\\+$/, '');
+            if (dir.length > 3 && !found.some((f) => f.toLowerCase() === dir.toLowerCase()))
+                found.push(dir);
+        }
+    }
+    return found;
+}
+function walk(dir, fs, budget) {
+    let bytes = 0;
+    let files = 0;
+    const stack = [dir];
+    while (stack.length) {
+        const at = stack.pop();
+        for (const name of fs.list(at)) {
+            if (++files > MAX_FILES_PER_PACK || --budget.left < 0)
+                return { bytes, partial: true };
+            const full = win.join(at, name);
+            const size = fs.size(full);
+            if (size === null) {
+                if (fs.isDir(full))
+                    stack.push(full);
+            }
+            else
+                bytes += size;
+        }
+    }
+    return { bytes, partial: false };
+}
+/** The packs in a vault cache folder, by name, with their size (bounded: very big packs read "at least"). */
+export function vaultPacks(vault, fs) {
+    const budget = { left: MAX_FILES };
+    return fs
+        .list(vault)
+        .filter((n) => !n.startsWith('.') && fs.isDir(win.join(vault, n)))
+        .sort((a, b) => a.localeCompare(b))
+        .slice(0, MAX_PACKS)
+        .map((name) => {
+        const dir = win.join(vault, name);
+        const data = win.join(dir, 'data');
+        const plugin = fs.list(data).some((n) => /\.uplugin$/i.test(n));
+        const kind = plugin ? 'plugin' : fs.isDir(win.join(data, 'Content')) ? 'content' : 'other';
+        const { bytes, partial } = walk(dir, fs, budget);
+        return { name, sizeBytes: bytes, partial, kind };
+    });
+}

package/dist/shared/unreal/vs-check.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+export declare const VsSetupReportSchema: z.ZodObject<{
+    setupError: z.ZodString;
+    instances: z.ZodArray<z.ZodObject<{
+        instanceId: z.ZodString;
+        installationPath: z.ZodString;
+        installationVersion: z.ZodString;
+        productId: z.ZodString;
+        state: z.ZodNumber;
+        isComplete: z.ZodBoolean;
+        isLaunchable: z.ZodBoolean;
+        packages: z.ZodArray<z.ZodString>;
+        toolchains: z.ZodArray<z.ZodObject<{
+            version: z.ZodString;
+            cl: z.ZodBoolean;
+            link: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    kitsRoots: z.ZodArray<z.ZodObject<{
+        where: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$strip>>;
+    sdks: z.ZodArray<z.ZodObject<{
+        version: z.ZodString;
+        root: z.ZodString;
+        windowsH: z.ZodBoolean;
+        kernel32: z.ZodBoolean;
+        ucrt: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type VsSetupReport = z.output<typeof VsSetupReportSchema>;
+/** The oldest MSVC Unreal 5.4+ builds with. */
+export declare const MIN_MSVC: readonly [14, 38];
+export interface VsVerdict {
+    readonly ok: boolean;
+    readonly text: string;
+}
+/** What UnrealBuildTool would find, in plain words. */
+export declare function vsVerdict(r: VsSetupReport): VsVerdict;

package/dist/shared/unreal/vs-check.js

@@ -0,0 +1,79 @@
+// Whether UnrealBuildTool would find a compiler: the verdict on what sandbox\scripts\get-vs-setup.ps1 reports. UBT
+// (MicrosoftPlatformSDK / VCToolChain) lists Visual Studio instances through the Setup Configuration API
+// (EnumAllInstances), takes those with the MSVC x64 tools (Microsoft.VisualStudio.Component.VC.Tools.x86.x64) and a
+// VC\Tools\MSVC\<version> with Hostx64\x64\cl.exe, and a Windows SDK under the KitsRoot10 the registry names with its
+// headers and libraries. Unreal 5.4 and later want MSVC 14.38 or newer. Pure.
+import { z } from 'zod';
+export const VsSetupReportSchema = z.object({
+    setupError: z.string().max(2000),
+    instances: z
+        .array(z.object({
+        instanceId: z.string().max(100),
+        installationPath: z.string().max(400),
+        installationVersion: z.string().max(60),
+        productId: z.string().max(200),
+        state: z.number().int().min(0),
+        isComplete: z.boolean(),
+        isLaunchable: z.boolean(),
+        packages: z.array(z.string().max(200)).max(50),
+        toolchains: z.array(z.object({ version: z.string().max(40), cl: z.boolean(), link: z.boolean() })).max(50),
+    }))
+        .max(20),
+    kitsRoots: z.array(z.object({ where: z.string().max(40), path: z.string().max(400) })).max(10),
+    sdks: z
+        .array(z.object({
+        version: z.string().max(40),
+        root: z.string().max(400),
+        windowsH: z.boolean(),
+        kernel32: z.boolean(),
+        ucrt: z.boolean(),
+    }))
+        .max(50),
+});
+/** The oldest MSVC Unreal 5.4+ builds with. */
+export const MIN_MSVC = [14, 38];
+const parts = (v) => v.split('.').map((p) => parseInt(p, 10) || 0);
+const newer = (a, b) => {
+    const x = parts(a);
+    const y = parts(b);
+    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;
+};
+/** What UnrealBuildTool would find, in plain words. */
+export function vsVerdict(r) {
+    if (r.setupError)
+        return { ok: false, text: 'the Setup Configuration API failed: ' + r.setupError.slice(0, 300) };
+    const usable = r.instances.filter((i) => (i.state & 1) === 1 && i.isComplete && i.packages.includes('Microsoft.VisualStudio.Component.VC.Tools.x86.x64'));
+    if (!usable.length)
+        return {
+            ok: false,
+            text: r.instances.length
+                ? 'Visual Studio is listed, but no complete instance has the C++ x64 tools'
+                : 'the Setup Configuration API lists no Visual Studio',
+        };
+    const tools = usable
+        .flatMap((i) => i.toolchains.filter((t) => t.cl && t.link).map((t) => ({ i, t })))
+        .sort((a, b) => newer(b.t.version, a.t.version));
+    const best = tools[0];
+    if (!best)
+        return { ok: false, text: 'Visual Studio has no MSVC with the x64 compiler (VC\\Tools\\MSVC)' };
+    const [major, minor] = parts(best.t.version);
+    const oldMsvc = major < MIN_MSVC[0] || (major === MIN_MSVC[0] && minor < MIN_MSVC[1]);
+    const sdk = r.sdks.filter((s) => s.windowsH && s.kernel32 && s.ucrt).sort((a, b) => newer(b.version, a.version))[0];
+    const where = 'Visual Studio ' + best.i.installationVersion + ' at ' + best.i.installationPath;
+    if (!sdk)
+        return { ok: false, text: where + ', MSVC ' + best.t.version + ', but no complete Windows SDK' };
+    return {
+        ok: !oldMsvc,
+        text: where +
+            ', MSVC ' +
+            best.t.version +
+            (oldMsvc ? ' (too old: Unreal 5.4 and later need 14.38 or newer)' : '') +
+            ', Windows SDK ' +
+            sdk.version +
+            ' at ' +
+            sdk.root,
+    };
+}

package/dist/web/index.html

@@ -6,7 +6,7 @@
     <title>Sandbox</title>
     <link rel="icon" href="data:," />
     <link rel="stylesheet" href="/main-XT7T6ODM.css" />
-    <script type="module" src="/main-CCILLX2M.js"></script>
+    <script type="module" src="/main-FNE6XEHA.js"></script>
   </head>
   <body>
     <div id="root"></div>