windows-development-sandbox 1.25.0 → 1.27.0

package/dist/guest/toolchains/native/mesa.js

@@ -5,7 +5,8 @@ import { SYSTEM } from '../../../shared/system.js';
 import { dryRun } from '../../runtime/paths.js';
 import { execAsync, scriptOutput } from '../../runtime/process.js';
 import { exists } from '../../runtime/fs.js';
-import { log } from '../../runtime/log.js';
+import { log, warn } from '../../runtime/log.js';
+import { errMsg } from '../../../core/util/errors.js';
 import { arch, tool } from '../tool-env.js';
 import { installFromGithub } from '../install.js';
 /**
@@ -33,6 +34,8 @@ export async function setupMesa(env, config) {
         await setupLavapipe(env, dir);
 }
 const VULKAN_RUNTIME = 'https://sdk.lunarg.com/sdk/download/latest/windows/vulkan-runtime-components.zip';
+/** Used when "latest" is not published yet (LunarG announces a version before its runtime zip is up: a 404). */
+const VULKAN_RUNTIME_PINNED = 'https://sdk.lunarg.com/sdk/download/1.4.350.0/windows/vulkan-runtime-components.zip';
 /**
  * Software Vulkan: Mesa's lavapipe plus the Khronos loader (vulkan-1.dll, from LunarG's runtime components; Windows
  * Sandbox has no Vulkan loader). The loader ignores VK_DRIVER_FILES in elevated processes, and everything in the
@@ -43,15 +46,19 @@ const setupLavapipe = async (env, mesaDir) => {
     if (!exists(icd))
         throw new Error('this Mesa build has no lavapipe (' + path.basename(icd) + ')');
     const dir = tool('vulkan');
-    if (!exists(path.join(dir, 'vulkan-1.dll'))) {
-        log('Downloading the Vulkan loader (~10 MB once) ...');
+    // vulkaninfo.exe too: a copy kept from an older runtime zip may lack it.
+    if (!exists(path.join(dir, 'vulkan-1.dll')) || !exists(path.join(dir, 'vulkaninfo.exe'))) {
+        log('Downloading the Vulkan loader (~20 MB once) ...');
         // LunarG publishes no checksum for this zip; it comes over HTTPS from LunarG, the Khronos SDK's maintainer.
         // The zip has x86 and x64 folders: only the 64-bit loader (and vulkaninfo) is extracted.
-        await downloader.archive(VULKAN_RUNTIME, dir, {
-            locate: 'vulkan-1.dll',
-            fileName: 'vulkan-runtime.zip',
-            members: ['*/x64/*'],
-        });
+        const fetchRuntime = (url) => downloader.archive(url, dir, { locate: 'vulkan-1.dll', fileName: 'vulkan-runtime.zip', members: ['*/x64/*'] });
+        try {
+            await fetchRuntime(VULKAN_RUNTIME);
+        }
+        catch (e) {
+            warn('The latest Vulkan runtime could not be downloaded (' + errMsg(e) + '); using version 1.4.350.0.');
+            await fetchRuntime(VULKAN_RUNTIME_PINNED);
+        }
     }
     const register = (file) => execAsync(SYSTEM.reg(), ['add', 'HKLM\\SOFTWARE\\Khronos\\Vulkan\\Drivers', '/v', file, '/t', 'REG_DWORD', '/d', '0', '/f'], { stdio: 'ignore' });
     await register(icd);

package/dist/guest/toolchains/native/rust-extras.d.ts

@@ -14,6 +14,13 @@ export declare function cargoShim(env: ToolEnv, rust: Toolchains['rust']): void;
  * run at once in the whole sandbox and, with linker "lld", has MinGW's gcc use Rust's own lld instead of GNU ld.
  */
 export declare function linkGate(env: ToolEnv, rust: Toolchains['rust'], host: string): void;
+/**
+ * MSVC host: link.exe writes an executable into a mapped folder (the workspace, C:\AgentData) as all zeros, so a
+ * fresh build script or test program fails with "The file or directory is corrupted and unreadable" (os error 1392).
+ * Rust's own lld (a copy of rust-lld.exe named lld-link.exe, which is how lld picks its mode) writes them whole.
+ * `rust.linker` "gnu" keeps link.exe; a linker the user set for the target wins.
+ */
+export declare function lldLink(env: ToolEnv, rust: Toolchains['rust'], host: string): void;
 /**
  * Cargo defaults that fit Windows, written only when there is no $CARGO_HOME\config.toml yet: fewer parallel jobs
  * (parallel rustc ran out of paging file) and, for the GNU host, only line tables as debug info (full debug info made

package/dist/guest/toolchains/native/rust-extras.js

@@ -7,7 +7,7 @@ import { execOutput } from '../../runtime/process.js';
 import { ensureCompiled } from '../../runtime/csc.js';
 import { arch, tool } from '../tool-env.js';
 import { wanted } from '../detect.js';
-import { cargoJobs, chooseTargetDir } from '../../../shared/memory/index.js';
+import { cargoJobs, cargoLinkerVar, chooseTargetDir } from '../../../shared/memory/index.js';
 import { linkerSlots } from '../../governor/decide.js';
 import { warn } from '../../runtime/log.js';
 import { freeBytes } from '../persisted.js';
@@ -81,6 +81,28 @@ export function linkGate(env, rust, host) {
         env.vars.AGENT_LINK_SLOTS +
         ' at once');
 }
+/**
+ * MSVC host: link.exe writes an executable into a mapped folder (the workspace, C:\AgentData) as all zeros, so a
+ * fresh build script or test program fails with "The file or directory is corrupted and unreadable" (os error 1392).
+ * Rust's own lld (a copy of rust-lld.exe named lld-link.exe, which is how lld picks its mode) writes them whole.
+ * `rust.linker` "gnu" keeps link.exe; a linker the user set for the target wins.
+ */
+export function lldLink(env, rust, host) {
+    if (!host.endsWith('-pc-windows-msvc') || rust.linker !== 'lld')
+        return;
+    const variable = cargoLinkerVar(host);
+    if (process.env[variable])
+        return;
+    const rustEnv = { ...process.env, RUSTUP_HOME: tool('rust', 'rustup'), CARGO_HOME: tool('rust', 'cargo') };
+    const sysroot = execOutput(tool('rust', 'cargo', 'bin', 'rustc.exe'), ['--print', 'sysroot'], { env: rustEnv });
+    const lld = sysroot ? path.join(sysroot, 'lib', 'rustlib', host, 'bin', 'rust-lld.exe') : '';
+    if (!lld || !exists(lld))
+        return;
+    const shim = path.join(mkdirp(tool('shims')), 'lld-link.exe');
+    fs.copyFileSync(lld, shim);
+    env.vars[variable] = shim;
+    env.summary.push('rust linking: lld (link.exe writes empty files into mapped folders)');
+}
 /**
  * Cargo defaults that fit Windows, written only when there is no $CARGO_HOME\config.toml yet: fewer parallel jobs
  * (parallel rustc ran out of paging file) and, for the GNU host, only line tables as debug info (full debug info made

package/dist/guest/toolchains/native/unreal.d.ts

@@ -2,6 +2,6 @@ import type { Toolchains } from '../../../core/types.js';
 import type { ToolCtx } from '../step.js';
 import { type ToolEnv } from '../tool-env.js';
 export { UNREAL_COMPONENTS } from './vs-request.js';
-/** Downloads the DirectX redistributable ahead of the install (only once the licence is accepted). */
+/** Downloads the DirectX redistributable and the launcher ahead of the install (only once the licence is accepted). */
 export declare function fetchDirectX(config: Toolchains['unreal']): Promise<void>;
-export declare function setupUnreal(env: ToolEnv, config: Toolchains['unreal'], ctx: ToolCtx): Promise<void>;
+export declare function setupUnreal(env: ToolEnv, config: Toolchains['unreal'], _ctx: ToolCtx): Promise<void>;

package/dist/guest/toolchains/native/unreal.js

@@ -1,18 +1,25 @@
-// Unreal Engine development (toolchains.unreal): the DirectX End-User Runtime the engine lists (a real installer: it
-// runs every boot), then the engines (engines/unreal-engines.ts: the launcher's install folder on the data disk, PC
-// engines from pcInstalls, the derived data cache). Visual Studio (Community with the C++ game workload, or the Build
-// Tools) is its own step (visual-studio.ts), which the plan runs first. The engine itself comes from the Epic Games
-// Launcher or its source.
+// Unreal Engine development, machine-wide (toolchains.unreal, once per boot): the DirectX End-User Runtime the engine
+// lists and the Epic Games Launcher (real installers: they run every boot), the launcher pointed at the data disk for
+// engines and given back the engines it installed there, the Windows SDK debuggers for crash dumps, and a check that
+// UnrealBuildTool finds Visual Studio the way it looks (the Setup Configuration API). Visual Studio itself is its own
+// step (visual-studio.ts), which the plan runs first; each project's engine is set up by engines/unreal-engines.ts.
+import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { runInstaller } from '../../runtime/pools.js';
+import { errMsg } from '../../../core/util/errors.js';
+import { readValid } from '../../../shared/io/json.js';
 import { safeRemove } from '../../../shared/io/safe-remove.js';
+import { VsSetupReportSchema, vsVerdict } from '../../../shared/unreal/index.js';
+import { runInstaller } from '../../runtime/pools.js';
 import { dryRun } from '../../runtime/paths.js';
 import { exists, mkdirp } from '../../runtime/fs.js';
-import { log } from '../../runtime/log.js';
-import { setupUnrealEngines } from '../engines/unreal-engines.js';
+import { log, warn } from '../../runtime/log.js';
+import { runScriptAsync } from '../../runtime/process.js';
+import { ensureLauncher, fetchLauncher, placeEngines, restoreLauncherItems } from '../engines/epic-launcher.js';
+import { resetUnrealStatus, updateUnrealStatus } from '../engines/unreal-status.js';
 import { SIGNERS, signedInstaller } from '../installers.js';
 import { tool } from '../tool-env.js';
+import { ensureDebuggers } from './debuggers.js';
 import { installedVs } from './visual-studio.js';
 export { UNREAL_COMPONENTS } from './vs-request.js';
 const DIRECTX_URL = 'https://download.microsoft.com/download/8/4/A/84A35BF1-DAFE-4AE8-82AF-AD2AE20B6B14/directx_Jun2010_redist.exe';
@@ -23,10 +30,13 @@ const directXInstalled = () => {
 };
 /** The redistributable (downloaded once, signature checked). */
 const directXRedist = () => signedInstaller(DIRECTX_URL, path.join(tool('visualstudio'), 'directx_Jun2010_redist.exe'), 'the DirectX End-User Runtime (~95 MB once)', SIGNERS.microsoft);
-/** Downloads the DirectX redistributable ahead of the install (only once the licence is accepted). */
+/** Downloads the DirectX redistributable and the launcher ahead of the install (only once the licence is accepted). */
 export async function fetchDirectX(config) {
-    if (config.acceptLicense && !directXInstalled())
+    if (!config.acceptLicense)
+        return;
+    if (!directXInstalled())
         await directXRedist();
+    await fetchLauncher();
 }
 async function installDirectX() {
     if (directXInstalled())
@@ -42,17 +52,85 @@ async function installDirectX() {
     if (code !== 0)
         throw new Error('the DirectX End-User Runtime installer failed (exit ' + code + ')');
 }
-export async function setupUnreal(env, config, ctx) {
+/** What UnrealBuildTool's way of finding Visual Studio finds (scripts\get-vs-setup.ps1 calls the Setup API). */
+async function checkVisualStudio() {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sbx-vs-check-'));
+    const file = path.join(dir, 'result.json');
+    try {
+        await runScriptAsync('get-vs-setup.ps1', ['-ResultFile', file]);
+        const report = readValid(VsSetupReportSchema, file);
+        return report ? vsVerdict(report) : { ok: false, text: 'the check left no result' };
+    }
+    catch (e) {
+        return { ok: false, text: 'the check failed: ' + errMsg(e) };
+    }
+    finally {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+}
+/** Runs one part, warning (not failing the step) when it does not work. */
+async function part(what, work, fallback) {
+    try {
+        return await work();
+    }
+    catch (e) {
+        warn('Unreal: ' + what + ' failed (' + errMsg(e) + ')');
+        return fallback;
+    }
+}
+export async function setupUnreal(env, config, _ctx) {
     if (!config.acceptLicense)
-        throw new Error('Unreal tools are installed only with toolchains.unreal.acceptLicense = true: Visual Studio Community and the DirectX End-User Runtime come under Microsoft licence terms (https://visualstudio.microsoft.com/license-terms/)');
+        throw new Error("Unreal tools are installed only with toolchains.unreal.acceptLicense = true: Visual Studio Community and the DirectX End-User Runtime come under Microsoft licence terms (https://visualstudio.microsoft.com/license-terms/), the Epic Games Launcher under Epic's (https://www.epicgames.com/site/eula)");
     if (dryRun) {
-        log('(dry run) would install the DirectX End-User Runtime and set up the Unreal engines');
+        log('(dry run) would install the DirectX End-User Runtime and the Epic Games Launcher');
         return;
     }
-    await installDirectX();
-    await setupUnrealEngines(env, config, ctx);
+    resetUnrealStatus();
+    await part('the DirectX End-User Runtime', installDirectX, undefined);
+    const launcher = await part('the Epic Games Launcher', ensureLauncher, null);
+    // Before anyone opens the launcher: engines go to the data disk, and it knows the ones it installed there before.
+    const place = placeEngines(config.persistEngines);
+    if (config.persistEngines)
+        await part("restoring the launcher's engines", async () => restoreLauncherItems(), []);
+    if (place.problem) {
+        warn('Unreal: ' + place.problem);
+        env.summary.push('UNREAL: ' + place.problem);
+    }
+    const debuggers = await part('the Windows SDK debuggers', ensureDebuggers, null);
+    if (debuggers)
+        env.append.push(debuggers);
     const vs = installedVs();
-    env.summary.push('unreal: ' +
-        (vs ? 'Visual Studio ' + vs.version + ' at ' + vs.path + '; ' : '') +
-        'DirectX End-User Runtime; get the engine from the Epic Games Launcher (Start menu)');
+    const check = vs ? await checkVisualStudio() : { ok: false, text: 'no Visual Studio with the C++ tools' };
+    if (!check.ok)
+        warn('Unreal: UnrealBuildTool would not find a compiler: ' + check.text);
+    else
+        log('Unreal: UnrealBuildTool finds ' + check.text);
+    const kept = Boolean(vs && /\\visualstudio\\persist\\/i.test(vs.path + '\\'));
+    updateUnrealStatus((s) => ({
+        ...s,
+        launcher: {
+            installed: launcher !== null,
+            installLocation: place.installLocation,
+            problem: place.problem,
+            freeBytes: place.freeBytes,
+            needBytes: place.needBytes,
+        },
+        visualStudio: {
+            version: vs?.version ?? '',
+            path: vs?.path ?? '',
+            how: vs ? (kept ? 'kept on the data disk' : 'installed in this sandbox') : '',
+            check: check.text,
+            ok: check.ok,
+        },
+        debugger: debuggers ? path.join(debuggers, 'cdb.exe') : null,
+    }));
+    env.summary.push('unreal tools: ' +
+        (vs
+            ? 'Visual Studio ' +
+                vs.version +
+                (check.ok ? ' (UnrealBuildTool finds it)' : ' (UnrealBuildTool would NOT find it)')
+            : 'no Visual Studio') +
+        ', DirectX End-User Runtime' +
+        (launcher ? ', Epic Games Launcher' : '') +
+        (debuggers ? ', cdb/windbg' : ''));
 }

package/dist/guest/toolchains/plan.js

@@ -12,6 +12,7 @@ import { setupDotnet } from './native/dotnet.js';
 import { setupMesa } from './native/mesa.js';
 import { setupMsvc } from './native/msvc/index.js';
 import { fetchDirectX, setupUnreal } from './native/unreal.js';
+import { setupUnrealEngines } from './engines/unreal-engines.js';
 import { fetchRustupInit, setupRust } from './native/rust.js';
 import { setupNode } from './languages/node.js';
 import { setupPwsh } from './tools/pwsh.js';
@@ -25,14 +26,15 @@ import { ensureVisualStudio, prefetchVisualStudio, visualStudioSaved, visualStud
 import { duringSession } from '../runtime/project-context.js';
 import { setupSteam } from './steam/steam.js';
 import { setupGodot } from './engines/godot.js';
-import { setupUnity } from './engines/unity.js';
+import { setupUnity, unityEditorSaved } from './engines/unity.js';
+import { prefetchUnityCli } from './engines/unity-cli.js';
 import { setupFivem } from './fivem/fivem.js';
 import { setupAndroid } from './mobile/android.js';
 import { setupFlutter } from './mobile/flutter.js';
 import { setupDart } from './mobile/dart.js';
 import { setupReactNative } from './mobile/react-native.js';
 import { setupKotlin } from './languages/kotlin.js';
-import { rustHost, rustCaches, cargoDefaults, cargoShim, linkGate, resolveTargetDir, targetSummary, } from './native/rust-extras.js';
+import { rustHost, rustCaches, cargoDefaults, cargoShim, linkGate, lldLink, resolveTargetDir, targetSummary, } from './native/rust-extras.js';
 import { setupPythonTools } from './languages/python-tools.js';
 export function plan(config, versions, o) {
     const apps = Boolean(o.apps && (o.apps.install.length || Object.keys(o.apps.custom).length));
@@ -87,6 +89,14 @@ export function plan(config, versions, o) {
             ...ahead(() => fetchDirectX(config.unreal)),
             install: (env) => setupUnreal(env, config.unreal, ctx),
         },
+        // Each project's engine (its .uproject's EngineAssociation) on its PATH: not shared, a project that joins later
+        // gets its own. It registers every engine too, so this PC's engines work without the licence step above.
+        {
+            name: 'Unreal engines',
+            enabled: unreal,
+            after: ['Unreal'],
+            install: (env) => setupUnrealEngines(env, config.unreal, ctx),
+        },
         {
             name: 'MSVC',
             enabled: wanted(config.msvc.enabled, 'msvc') && vs === null,
@@ -108,6 +118,8 @@ export function plan(config, versions, o) {
                     cargoDefaults(rustHost(config));
                     cargoShim(env, rust);
                     linkGate(env, rust, rustHost(config));
+                    lldLink(env, rust, rustHost(config));
+                    lldLink(env, rust, rustHost(config));
                 }
             },
         },
@@ -135,6 +147,9 @@ export function plan(config, versions, o) {
             name: 'Unity',
             enabled: wanted(config.unity.enabled, 'unity'),
             after: ['Visual Studio', 'Android SDK'],
+            ...ahead(() => prefetchUnityCli(config.unity.cliVersion)),
+            // Only the first install of an editor (several GB) goes to the background; a saved one is back in seconds.
+            background: deferred && !unityEditorSaved(config.unity, ctx),
             install: (env) => setupUnity(env, config.unity, ctx),
         },
         {

package/dist/guest/toolchains/tools/cli.js

@@ -34,13 +34,13 @@ export function ghExePath() {
  * gh keeps its token in Windows Credential Manager unless told otherwise, and that is wiped with the sandbox: only a
  * login made with --insecure-storage (the token in GH_CONFIG_DIR, which persists) is still there next time.
  */
-const GH_NOTE = ' (log in once with: gh auth login --web --insecure-storage; it is kept between sandboxes)';
+const GH_NOTE = ' (signed in on your PC? turn on github.usePcLogin and the login comes from there; otherwise log in once with: gh auth login --web --insecure-storage, which is kept between sandboxes)';
 /** A saved gh account whose token was in Credential Manager (gone now): say how to log in so that it lasts. */
 function warnKeyringLogin() {
     try {
         const hosts = fs.readFileSync(path.join(ghConfigDir(), 'hosts.yml'), 'utf8');
         if (/^\s*user:/m.test(hosts) && !/oauth_token:/.test(hosts))
-            warn('gh: the GitHub login from an earlier sandbox was kept in Windows Credential Manager, which is wiped with each sandbox. Log in again with: gh auth login --web --insecure-storage (then it lasts).');
+            warn('gh: the GitHub login from an earlier sandbox was kept in Windows Credential Manager, which is wiped with each sandbox. Log in again with: gh auth login --web --insecure-storage (then it lasts), or sign gh in on your PC and turn on github.usePcLogin.');
     }
     catch {
         // No saved login: nothing to say.

package/dist/guest/toolchains/tools/vscode-profile.js

@@ -54,6 +54,8 @@ const BY_TOOLCHAIN = {
     rust: ['rust-lang.rust-analyzer', 'vadimcn.vscode-lldb'],
     cpp: ['ms-vscode.cpptools', 'ms-vscode.cmake-tools'],
     msvc: ['ms-vscode.cpptools', 'ms-vscode.cmake-tools'],
+    // Unreal C++ (IntelliSense from the generated .code-workspace) and the C# of the *.Build.cs / *.Target.cs rules.
+    unreal: ['ms-vscode.cpptools', 'ms-dotnettools.csharp'],
     dotnet: ['ms-dotnettools.csharp'],
     ruby: ['shopify.ruby-lsp'],
     php: ['bmewburn.vscode-intelephense-client', 'xdebug.php-debug'],

package/dist/host/accounts/deliver.js

@@ -9,8 +9,12 @@ function howToSave(spec) {
         return "sign in to the Epic Games Launcher in this sandbox once, or take this PC's: sandbox account import epic";
     if (spec.kind === 'steam')
         return 'sign in once in this sandbox with sbx-steam login';
+    if (spec.kind === 'unity')
+        return 'sign in to Unity once in this sandbox (Unity page: Sign in to Unity), or: sandbox account login unity';
     if (spec.kind === 'comet')
         return 'sign in to Comet once in this sandbox, and it is kept for the next ones';
+    if (spec.kind === 'perplexityapp')
+        return 'sign in to the Perplexity app once in this sandbox, and it is kept for the next ones';
     if (spec.returns)
         return 'sign in once in this sandbox, or: sandbox account import ' + spec.kind;
     return spec.sources.includes('typed')

package/dist/host/accounts/kinds/epic.js

@@ -1,15 +1,21 @@
-// Epic Games: this PC's launcher sign-in ("Remember me" in its GameUserSettings.ini, often UTF-16). Taking it signs
-// the launcher on this PC out the first time a sandbox uses it (a sign-in works in one place at a time).
+// Epic Games: this PC's launcher sign-in ("Remember me" in its GameUserSettings.ini, often UTF-16; launcher 17+ keeps
+// it in Config\WindowsEditor, older ones in Config\Windows). Taking it signs the launcher on this PC out the first time
+// a sandbox uses it (a sign-in works in one place at a time).
 import path from 'node:path';
-import { epicSettingsFile, MAX_EPIC_INI_BYTES, readEpicLogin, } from '../../../shared/accounts/index.js';
+import { epicSettingsFiles, MAX_EPIC_INI_BYTES, readEpicLogin, } from '../../../shared/accounts/index.js';
 import { decodeText, readBoundedFile } from '../../../shared/io/index.js';
 export const epicSource = {
     fromPc(pc, from) {
         const localAppData = from ? path.resolve(from) : pc.localAppData;
         if (!localAppData)
             return null;
-        const bytes = readBoundedFile(epicSettingsFile(localAppData), MAX_EPIC_INI_BYTES);
-        return bytes ? readEpicLogin(decodeText(bytes).text) : null;
+        for (const file of epicSettingsFiles(localAppData)) {
+            const bytes = readBoundedFile(file, MAX_EPIC_INI_BYTES);
+            const login = bytes ? readEpicLogin(decodeText(bytes).text) : null;
+            if (login)
+                return login;
+        }
+        return null;
     },
     summary: () => null,
 };

package/dist/host/accounts/kinds/perplexityapp.d.ts

@@ -0,0 +1,2 @@
+import type { HostSource } from '../source.js';
+export declare const perplexityAppSource: HostSource<'perplexityapp'>;

package/dist/host/accounts/kinds/perplexityapp.js

@@ -0,0 +1,8 @@
+// Perplexity desktop app: nothing to take from this PC. The app is an Electron program in a Microsoft Store package;
+// its cookies are sealed to your Windows account (Chromium's cookie key is protected by DPAPI), so they cannot open in
+// a sandbox, and reading them would be what password stealers do. The sign-in only ever comes from a sandbox you
+// signed in in (the same way as Comet's).
+import { cometSummary } from '../../../shared/accounts/index.js';
+export const perplexityAppSource = {
+    summary: (p) => cometSummary(p),
+};

package/dist/host/accounts/kinds/unity.d.ts

@@ -1,2 +1,2 @@
-import { type HostSource } from '../source.js';
+import type { HostSource } from '../source.js';
 export declare const unitySource: HostSource<'unity'>;

package/dist/host/accounts/kinds/unity.js

@@ -1,13 +1,65 @@
-import { notAvailableYet } from '../source.js';
+// Unity: this PC's licence file (Unity_lic.ulf, or the named-user UnityEntitlementLicense.xml), a licence file you
+// name, or the Unity ID (and serial) typed for a sandbox to sign in with. Unity ties a licence file to the computer, so
+// a sandbox may refuse one taken from this PC; the typed Unity ID is the way that always works.
+import path from 'node:path';
+import { MAX_ULF_BYTES, unityEntitlementFile, unitySummary, unityUlfFile, UnityPayloadSchema, } from '../../../shared/accounts/index.js';
+import { fail } from '../../../core/util/index.js';
+import { decodeText, readBoundedFile } from '../../../shared/io/index.js';
+const NOT_A_LICENCE = 'That is not a Unity licence file (Unity_lic.ulf) or entitlement file.';
+const WHERE = 'Pick the file from C:\\ProgramData\\Unity or %LOCALAPPDATA%\\Unity\\licenses.';
+function readText(file) {
+    const bytes = readBoundedFile(file, MAX_ULF_BYTES);
+    return bytes ? decodeText(bytes).text : null;
+}
+/** The email, password and serial answers that were typed (trimmed, empty ones left out). */
+function typed(answers) {
+    const out = {};
+    const email = (answers.email ?? '').trim();
+    const password = answers.password ?? '';
+    const serial = (answers.serial ?? '').trim();
+    if (email)
+        out.email = email;
+    if (password)
+        out.password = password;
+    if (serial)
+        out.serial = serial;
+    return out;
+}
+function checked(candidate) {
+    const parsed = UnityPayloadSchema.safeParse(candidate);
+    if (!parsed.success)
+        fail('That Unity sign-in is not valid (check the email, and that the licence file is not too big).', WHERE);
+    return parsed.data;
+}
 export const unitySource = {
-    fromPc(_pc, _from) {
-        return notAvailableYet('unity');
+    fromPc(pc, from) {
+        const ulf = (pc.programData || from ? readText(unityUlfFile(from ? path.resolve(from) : pc.programData)) : null) ??
+            (pc.localAppData
+                ? readText(path.win32.join(pc.localAppData, 'VirtualStore', 'ProgramData', 'Unity', 'Unity_lic.ulf'))
+                : null);
+        const entitlement = pc.localAppData ? readText(unityEntitlementFile(pc.localAppData)) : null;
+        if (ulf === null && entitlement === null)
+            return null;
+        return { ...(ulf !== null ? { ulf } : {}), ...(entitlement !== null ? { entitlement } : {}) };
     },
-    fromFile(_bytes, _answers) {
-        return notAvailableYet('unity');
+    fromFile(bytes, answers) {
+        const text = decodeText(bytes).text;
+        const candidate = { ...typed(answers) };
+        if (text.includes('Entitlement'))
+            candidate.entitlement = text;
+        else if (text.includes('<License'))
+            candidate.ulf = text;
+        else
+            fail(NOT_A_LICENCE, WHERE);
+        return checked(candidate);
     },
-    fromAnswers(_answers) {
-        return notAvailableYet('unity');
+    fromAnswers(answers) {
+        const t = typed(answers);
+        if (t.serial && !(t.email && t.password))
+            fail('A serial needs your Unity ID email and password.', 'Type them too, or leave the serial empty.');
+        if (!t.email || !t.password)
+            fail('A Unity sign-in needs your Unity ID email and password.', 'Type both: sandbox account login unity');
+        return checked(t);
     },
-    summary: () => null,
+    summary: unitySummary,
 };

package/dist/host/accounts/leases.d.ts

@@ -2,16 +2,17 @@ import { z } from 'zod';
 import { type ServiceKind } from '../../shared/accounts/index.js';
 declare const LeaseSchema: z.ZodObject<{
     kind: z.ZodEnum<{
-        unity: "unity";
         keystore: "keystore";
         play: "play";
         expo: "expo";
         appstore: "appstore";
+        unity: "unity";
         steam: "steam";
         epic: "epic";
         cfx: "cfx";
         perplexity: "perplexity";
         comet: "comet";
+        perplexityapp: "perplexityapp";
     }>;
     dataSet: z.ZodString;
     launchId: z.ZodString;

package/dist/host/accounts/source.d.ts

@@ -4,6 +4,8 @@ export interface PcEnv {
     readonly localAppData: string;
     readonly appData: string;
     readonly programData: string;
+    /** C:\Program Files (where the Epic Games Launcher installs engines by default). */
+    readonly programFiles?: string;
     /** The environment the command runs with (a variable set in this terminal). */
     readonly env?: Readonly<Record<string, string | undefined>>;
     /** A variable of this Windows user's saved environment (HKCU\Environment), or null when it is not set. */

package/dist/host/accounts/source.js

@@ -32,6 +32,7 @@ export function pcEnv() {
         localAppData: env.LOCALAPPDATA ?? '',
         appData: env.APPDATA ?? '',
         programData: env.ProgramData ?? env.PROGRAMDATA ?? 'C:\\ProgramData',
+        programFiles: env.ProgramFiles ?? 'C:\\Program Files',
         env,
         userVariable: savedUserVariable,
     };

package/dist/host/accounts/sources.js

@@ -4,6 +4,7 @@ import { cometSource } from './kinds/comet.js';
 import { epicSource } from './kinds/epic.js';
 import { expoSource } from './kinds/expo.js';
 import { keystoreSource } from './kinds/keystore.js';
+import { perplexityAppSource } from './kinds/perplexityapp.js';
 import { perplexitySource } from './kinds/perplexity.js';
 import { playSource } from './kinds/play.js';
 import { steamSource } from './kinds/steam.js';
@@ -19,4 +20,5 @@ export const HOST_SOURCES = {
     appstore: appstoreSource,
     perplexity: perplexitySource,
     comet: cometSource,
+    perplexityapp: perplexityAppSource,
 };

package/dist/host/apps/index.d.ts

@@ -0,0 +1 @@
+export { prepareStorePackages, spawnStoreRunner, stagedPackageDir, StorePackages, STORE_PACKAGE_MAX_AGE_MS, type ScriptRun, type StoreApp, type StoreRunner, type StoreStaging, } from './store-package.js';

package/dist/host/apps/index.js

@@ -0,0 +1,2 @@
+// Store apps for the sandbox (host side): the package fetched on this PC and staged in the data folder.
+export { prepareStorePackages, spawnStoreRunner, stagedPackageDir, StorePackages, STORE_PACKAGE_MAX_AGE_MS, } from './store-package.js';

package/dist/host/apps/store-package.d.ts

@@ -0,0 +1,51 @@
+import { type StorePackageManifest } from '../../shared/apps/index.js';
+/** How long a fetched package is used before a launch looks for a newer one (a failed look keeps the old one). */
+export declare const STORE_PACKAGE_MAX_AGE_MS: number;
+export interface ScriptRun {
+    readonly status: number | null;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+/** Runs a program and collects its output; the self-test passes a fake. */
+export type StoreRunner = (exe: string, args: readonly string[], timeoutMs: number) => Promise<ScriptRun>;
+export declare const spawnStoreRunner: StoreRunner;
+/** What an app needs fetched (catalogue source.store). */
+export interface StoreApp {
+    readonly id: string;
+    readonly productId: string;
+    readonly packageName: string;
+}
+export interface StoreStaging {
+    readonly storageRoot: string;
+    readonly dataPath: string;
+    readonly run?: StoreRunner;
+    readonly now?: () => number;
+}
+/** Where the data folder keeps an app's package for the sandbox. */
+export declare function stagedPackageDir(dataPath: string, appId: string): string;
+export declare class StorePackages {
+    private readonly o;
+    constructor(o: StoreStaging);
+    cacheDir(productId: string): string;
+    /** The cached package when its files are all there at the size hashed; null otherwise. */
+    cached(productId: string): StorePackageManifest | null;
+    private fresh;
+    /** Fetches the package into the cache with this PC's Store tooling and returns what was kept. */
+    fetch(app: StoreApp): Promise<StorePackageManifest>;
+    /** Checks what the script fetched into `work`, hashes it and moves it into the cache. */
+    private keep;
+    /** The package to use: the cache when fresh, else a new fetch (the old one stands when that fails). */
+    ensure(app: StoreApp): Promise<{
+        manifest: StorePackageManifest;
+        note: string;
+    }>;
+    /** Copies the cached package into the data folder for the sandbox (files already there at the same size stay). */
+    stage(app: StoreApp, manifest: StorePackageManifest): string;
+}
+/**
+ * For a launch: every Store app chosen gets its package fetched (or kept) and staged. A failure never stops the launch:
+ * it is a note, and the sandbox skips that app.
+ */
+export declare function prepareStorePackages(apps: readonly StoreApp[], o: StoreStaging): Promise<{
+    readonly notes: readonly string[];
+}>;