windows-development-sandbox 1.25.1 → 1.27.1

package/dist/guest/toolchains/engines/unity.js

@@ -1,4 +1,251 @@
-import { notAvailableYet } from '../not-yet.js';
-export async function setupUnity(env, _config, _ctx) {
-    notAvailableYet(env, 'Unity');
+// Unity (toolchains.unity), for each project: the Unity CLI on PATH (pinned, checked), every editor the sandbox has
+// (this PC's, read-only, and the data disk's) registered with it, the editor the project's ProjectVersion.txt names
+// (installed on the data disk when nothing has that exact version), UNITY_EDITOR, the Asset Store cache, the licence,
+// Unity Hub when asked and the agent's MCP server and skills. Machine-wide writes only add; a project that joins
+// later only adds its own editor choice. A project is never opened or changed here.
+import fs from 'node:fs';
+import path from 'node:path';
+import { readBoundedFile } from '../../../shared/io/bounded.js';
+import { chooseEditor, editorsAddArgs, findEditors, installArgs, installModulesArgs, installNeedBytes, installPathArgs, unitySummaryLine, wantedVersion, } from '../../../shared/unity/index.js';
+import { errMsg } from '../../../core/util/errors.js';
+import { activateUnityLicence } from '../../accounts/kinds/unity.js';
+import { exists, mkdirp } from '../../runtime/fs.js';
+import { log, warn } from '../../runtime/log.js';
+import { dryRun } from '../../runtime/paths.js';
+import { heavy } from '../../runtime/pools.js';
+import { runScriptWithJsonAsync } from '../../runtime/process.js';
+import { projectWorkspace } from '../../runtime/project-context.js';
+import { session } from '../../runtime/session.js';
+import { setupUnityAgentTools } from '../../setup/unity-agent.js';
+import { ensurePersisted, installRecords } from '../persisted.js';
+import { ensureUnityCli, runUnityCli, runUnityCliChecked } from './unity-cli.js';
+import { ensureUnityHub } from './unity-hub.js';
+import { findUnityRelease } from './unity-release.js';
+import { ASSET_DIR, EDITORS_DIR, readUnityStatus, updateUnityStatus } from './unity-status.js';
+const MAX_PROJECT_VERSION_BYTES = 64 * 1024;
+const MARKER = 'Editor\\Unity.exe';
+const TERMS = 'https://unity.com/legal/terms-of-service';
+const FALLBACK_NEED_BYTES = 15 * 1024 ** 3;
+/** The real disk, for the editor search. */
+const DISK = {
+    exists: (file) => exists(file),
+    list: (dir) => {
+        try {
+            return fs.readdirSync(dir).slice(0, 500);
+        }
+        catch {
+            return []; // Not a folder: nothing in it.
+        }
+    },
+};
+/** This PC's editors the host mapped (session.json's pcInstalls; the id is the version). */
+function mappedEditors(ctx) {
+    return ctx.pcInstalls.items.filter((i) => i.kind === 'unity').map((i) => ({ guest: i.guest, id: i.id }));
+}
+/** Every editor this sandbox has. */
+export function sandboxEditors(ctx) {
+    return findEditors({ mapped: mappedEditors(ctx), dataRoot: EDITORS_DIR }, DISK);
+}
+/**
+ * The editor a project asks for: its ProjectVersion.txt (read bounded) always wins, since opening a project in another
+ * version upgrades its files; the version the setting names is only for folders without one.
+ */
+export function wantedEditor(config, workspace) {
+    const file = path.join(workspace, 'ProjectSettings', 'ProjectVersion.txt');
+    const bytes = readBoundedFile(file, MAX_PROJECT_VERSION_BYTES);
+    return wantedVersion(bytes ? bytes.toString('utf8') : null, config.version);
+}
+/** Whether the project's editor is already here (a first install goes to the background). */
+export function unityEditorSaved(config, ctx) {
+    const wanted = wantedEditor(config, projectWorkspace());
+    if (!wanted)
+        return true;
+    return sandboxEditors(ctx).some((e) => e.version === wanted.version);
+}
+function sizeOf(e) {
+    if (e.origin !== 'data')
+        return null;
+    return installRecords().find((r) => r.name === 'unity/editors' && r.version === e.version)?.sizeBytes ?? null;
+}
+const statusEditor = (e) => ({
+    version: e.version,
+    root: e.root,
+    origin: e.origin,
+    writable: e.writable,
+    modules: [...e.modules],
+    sizeBytes: sizeOf(e),
+});
+/**
+ * Installs one editor version on the data disk with the CLI (into a staging folder with TEMP inside it) and returns its
+ * folder. One heavy slot while the CLI runs.
+ */
+export async function ensureUnityEditor(cli, version, changeset, modules, keepVersions) {
+    const release = await findUnityRelease(version);
+    const cs = changeset ?? release?.changeset ?? null;
+    const need = release ? installNeedBytes(release, modules) : FALLBACK_NEED_BYTES;
+    const installed = await ensurePersisted({ name: 'unity/editors', version, needBytes: need, marker: MARKER, what: 'Unity ' + version, keepVersions }, async (staging, temp) => {
+        log('Installing Unity ' + version + ' on the data disk (several GB; this takes a while) ...');
+        await heavy.run(() => runUnityCliChecked(cli.exe, installArgs(version, cs, modules, staging), { temp }));
+    });
+    return installed.dir;
+}
+/** Adds modules to an editor on the data disk. */
+async function addModules(cli, editor, modules) {
+    const temp = path.join(editor.root, '.temp');
+    mkdirp(temp);
+    try {
+        log('Adding to Unity ' + editor.version + ': ' + modules.join(', ') + ' ...');
+        const args = installModulesArgs(editor.version, modules, editor.root);
+        await heavy.run(() => runUnityCliChecked(cli.exe, args, { temp }));
+    }
+    finally {
+        fs.rmSync(temp, { recursive: true, force: true });
+    }
+}
+/** While the sandbox runs: lists the editors again (the user may have installed one with Hub) for the status. */
+export function captureUnityEditors() {
+    const unity = session.toolchains.unity;
+    if (dryRun || unity.enabled !== true || !exists(EDITORS_DIR))
+        return Promise.resolve();
+    const editors = sandboxEditors({ pcInstalls: session.pcInstalls ?? { items: [] } });
+    const describe = (list) => list.map((e) => e.root + '|' + e.modules.join(',')).join(';');
+    if (describe(editors) !== describe(readUnityStatus().editors))
+        updateUnityStatus((s) => ({ ...s, editors: editors.slice(0, 32).map(statusEditor) }));
+    return Promise.resolve();
+}
+/** The editors, the project's choice, the CLI, the licence, the asset cache: set up and written to the status. */
+export async function setupUnity(env, config, ctx) {
+    if (!config.acceptLicense)
+        throw new Error('Unity is set up only with toolchains.unity.acceptLicense = true: you accept the Unity terms of service (' +
+            TERMS +
+            ') and the editor needs a Unity licence (Personal is free).');
+    const workspace = projectWorkspace();
+    if (dryRun) {
+        log('(dry run) would set up Unity ' + config.version + ' for ' + workspace);
+        return;
+    }
+    const cli = await ensureUnityCli(config.cliVersion);
+    env.prepend.push(path.dirname(cli.exe));
+    let problem = null;
+    const quiet = (what) => (e) => warn('Unity CLI: ' + what + ' (' + errMsg(e) + ')');
+    // Settings that only keep the CLI quiet: a failure is not worth stopping for.
+    await runUnityCli(cli.exe, ['config', 'update-check', 'off'], { timeoutMs: 60_000 }).catch(quiet('update-check'));
+    await runUnityCli(cli.exe, ['analytics', 'opt-out'], { timeoutMs: 60_000 }).catch(quiet('analytics'));
+    mkdirp(EDITORS_DIR);
+    await runUnityCli(cli.exe, installPathArgs(EDITORS_DIR), { timeoutMs: 60_000 }).catch(quiet('install-path'));
+    let editors = sandboxEditors(ctx);
+    if (editors.length)
+        await runUnityCli(cli.exe, editorsAddArgs(editors.map((e) => e.root)), { timeoutMs: 120_000 }).catch(quiet('editors add'));
+    const wanted = wantedEditor(config, workspace);
+    let choice = chooseEditor(editors, wanted, config.modules, true);
+    const install = choice.install;
+    if (install) {
+        try {
+            const { version, changeset } = install;
+            await ensureUnityEditor(cli, version, changeset, config.modules, config.keepVersions);
+            editors = sandboxEditors(ctx);
+            choice = chooseEditor(editors, wanted, config.modules, true);
+        }
+        catch (e) {
+            problem = 'Unity ' + install.version + ' was not installed: ' + errMsg(e);
+            warn(problem);
+        }
+    }
+    let editor = choice.editor;
+    if (editor) {
+        const have = editor.modules;
+        const lack = config.modules.filter((m) => !have.includes(m));
+        if (lack.length && editor.writable) {
+            try {
+                await addModules(cli, editor, lack);
+                editors = sandboxEditors(ctx);
+                const root = editor.root;
+                editor = editors.find((e) => e.root === root) ?? editor;
+            }
+            catch (e) {
+                problem = 'Unity modules were not added: ' + errMsg(e);
+                warn(problem);
+            }
+        }
+        else if (lack.length) {
+            problem =
+                'Unity ' +
+                    editor.version +
+                    ' from this PC has no ' +
+                    lack[0] +
+                    " module: add it with Unity Hub on your PC, or remove that editor from This PC's editors to install one here.";
+            warn(problem);
+        }
+        env.vars.UNITY_EDITOR = editor.exe;
+    }
+    // The Asset Store cache: where downloads made here go (HKCU too, so an editor started from Explorer agrees).
+    // For "pc" the mapped Asset Store folder (guest of the unity-assets item) sits inside the cache root.
+    const pcAssets = ctx.pcInstalls.items.filter((i) => i.kind === 'unity-assets').map((i) => i.guest);
+    let cacheDir = null;
+    if (config.assetCache === 'persisted')
+        cacheDir = mkdirp(ASSET_DIR);
+    else if (config.assetCache === 'pc' && pcAssets[0])
+        cacheDir = path.win32.dirname(pcAssets[0]);
+    if (cacheDir) {
+        env.vars.ASSETSTORE_CACHE_PATH = cacheDir;
+        if (!ctx.duringSession)
+            await runScriptWithJsonAsync('set-registry-values.ps1', 'PlanFile', {
+                values: [{ hive: 'HKCU', key: 'Environment', name: 'ASSETSTORE_CACHE_PATH', value: cacheDir }],
+            }).catch((e) => warn('Unity: the Asset Store cache was not set for Explorer (' + errMsg(e) + ')'));
+    }
+    const licence = await activateUnityLicence({ editorExe: editor?.exe ?? null, unityExe: cli.exe }).catch((e) => {
+        warn('Unity licence: ' + errMsg(e));
+        return readUnityStatus().licence;
+    });
+    let hub = readUnityStatus().hub;
+    if (config.hub)
+        try {
+            hub = { installed: true, path: await ensureUnityHub() };
+        }
+        catch (e) {
+            warn('Unity Hub was not installed: ' + errMsg(e));
+        }
+    const agent = await setupUnityAgentTools({
+        unityExe: cli.exe,
+        projectPath: workspace,
+        mcp: config.mcp,
+        skills: config.agentSkills,
+    }).catch((e) => {
+        warn('Unity agent tools: ' + errMsg(e));
+        return { mcp: null, skills: false };
+    });
+    const chosen = editor;
+    const status = updateUnityStatus((s) => {
+        const mine = s.projects.find((p) => p.workspace.toLowerCase() === workspace.toLowerCase());
+        return {
+            ...s,
+            cli: { version: cli.version, path: cli.exe },
+            editors: editors.slice(0, 32).map(statusEditor),
+            projects: [
+                ...s.projects.filter((p) => p !== mine),
+                {
+                    workspace,
+                    version: wanted?.version ?? null,
+                    editor: chosen?.root ?? null,
+                    reason: choice.reason,
+                    bridge: mine?.bridge ?? null,
+                },
+            ].slice(-64),
+            licence,
+            assetCache: { mode: config.assetCache, dir: cacheDir },
+            pcAssets: pcAssets.slice(0, 4),
+            hub,
+            mcp: agent.mcp ?? (ctx.duringSession ? s.mcp : null),
+            skills: agent.skills || (ctx.duringSession && s.skills),
+            problem,
+        };
+    });
+    env.summary.push(unitySummaryLine(status, workspace));
+    log('Unity: ' +
+        editors.length +
+        ' editor(s); ' +
+        (editor ? editor.version + ' at ' + editor.root : 'none for this project') +
+        ' (' +
+        choice.reason +
+        ')');
 }

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

@@ -18,7 +18,7 @@ const EMPTY = {
     updatedAt: '',
     engines: [],
     projects: [],
-    launcher: { installed: false, installLocation: null, problem: null, freeBytes: null, needBytes: 0 },
+    launcher: { installed: false, exe: null, installLocation: null, problem: null, freeBytes: null, needBytes: 0 },
     visualStudio: { version: '', path: '', how: '', check: '', ok: false },
     debugger: null,
     ddc: { mode: 'local', dir: null },

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

@@ -1,11 +1,11 @@
 // Mesa for running OpenGL and Vulkan programs without a GPU (llvmpipe, lavapipe).
 import path from 'node:path';
-import { downloader } from '../../../shared/download/index.js';
+import { downloader, fetchJson } from '../../../shared/download/index.js';
 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, warn } from '../../runtime/log.js';
+import { log } from '../../runtime/log.js';
 import { errMsg } from '../../../core/util/errors.js';
 import { arch, tool } from '../tool-env.js';
 import { installFromGithub } from '../install.js';
@@ -33,9 +33,28 @@ export async function setupMesa(env, config) {
     if (config.vulkan)
         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';
+/** LunarG's newest SDK version per platform ({"windows": "1.4.363.1", ...}). */
+const VULKAN_LATEST = 'https://vulkan.lunarg.com/sdk/latest.json';
+const runtimeUrl = (version) => 'https://sdk.lunarg.com/sdk/download/' + version + '/windows/vulkan-runtime-components.zip';
+/** Known to have the runtime zip: used when LunarG cannot be asked, or none of its versions has one. */
+const VULKAN_PINNED = '1.4.363.0';
+/**
+ * The versions to try for the runtime zip, newest first: LunarG's latest, its x.y.z.0 (a point release such as
+ * 1.4.363.1 reissues the SDK without the runtime zip), then the pinned one.
+ */
+async function runtimeVersions() {
+    let latest = null;
+    try {
+        const value = (await fetchJson(VULKAN_LATEST)).windows;
+        if (typeof value === 'string' && /^\d{1,2}\.\d{1,2}\.\d{1,4}\.\d{1,3}$/.test(value))
+            latest = value;
+    }
+    catch {
+        // LunarG not reachable: the pinned version.
+    }
+    const found = latest ? [latest, latest.replace(/\.\d+$/, '.0')] : [];
+    return [...new Set([...found, VULKAN_PINNED])];
+}
 /**
  * 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
@@ -52,12 +71,17 @@ const setupLavapipe = async (env, mesaDir) => {
         // 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.
         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 versions = await runtimeVersions();
+        for (const [n, version] of versions.entries()) {
+            try {
+                await fetchRuntime(runtimeUrl(version));
+                log('Vulkan loader ' + version + ' installed');
+                break;
+            }
+            catch (e) {
+                if (n === versions.length - 1)
+                    throw new Error('the Vulkan loader could not be downloaded (' + errMsg(e) + ')');
+            }
         }
     }
     const register = (file) => execAsync(SYSTEM.reg(), ['add', 'HKLM\\SOFTWARE\\Khronos\\Vulkan\\Drivers', '/v', file, '/t', 'REG_DWORD', '/d', '0', '/f'], { stdio: 'ignore' });

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

@@ -110,6 +110,7 @@ export async function setupUnreal(env, config, _ctx) {
         ...s,
         launcher: {
             installed: launcher !== null,
+            exe: launcher,
             installLocation: place.installLocation,
             problem: place.problem,
             freeBytes: place.freeBytes,

package/dist/guest/toolchains/plan.js

@@ -26,7 +26,8 @@ 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';
@@ -146,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/host/accounts/deliver.d.ts

@@ -2,6 +2,7 @@ import type { BootWant } from '../../core/local-config/index.js';
 import type { Config } from '../../core/types.js';
 import { type Payloads, type ServiceKind, type UsedBy } from '../../shared/accounts/index.js';
 import { AccountLeases } from './leases.js';
+import type { PcEnv } from './source.js';
 import { ServiceAccountStore } from './store.js';
 export interface AccountDelivery {
     readonly payloads: Payloads;
@@ -22,5 +23,7 @@ export interface DeliveryInput {
     readonly isRunning: (dataSet: string) => boolean;
     readonly store?: ServiceAccountStore;
     readonly leases?: AccountLeases;
+    /** This PC's folders: a shared kind with nothing saved takes this PC's own sign-in (left out: never). */
+    readonly pc?: PcEnv;
 }
 export declare function prepareServiceAccounts(i: DeliveryInput): AccountDelivery;

package/dist/host/accounts/deliver.js

@@ -2,6 +2,7 @@ import { fingerprint, SERVICE_KINDS, SERVICE_SPECS, serviceWanted, } from '../..
 import { setNameOf } from '../storage/index.js';
 import { takeHandoffs } from './handoff.js';
 import { AccountLeases } from './leases.js';
+import { HOST_SOURCES } from './sources.js';
 import { ServiceAccountStore } from './store.js';
 /** How to get a first sign-in of a kind, for the note when none is saved. */
 function howToSave(spec) {
@@ -9,14 +10,34 @@ 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')
         ? 'save one: sandbox account login ' + spec.kind
         : 'save one: sandbox account import ' + spec.kind + ' --from <file>';
 }
+/** The first time a shared kind has nothing saved: this PC's own sign-in, saved like `sandbox account import`. */
+function takeFromPc(kind, pc, store) {
+    const source = HOST_SOURCES[kind];
+    if (!pc || !source.fromPc)
+        return null;
+    let payload = null;
+    try {
+        payload = source.fromPc(pc);
+    }
+    catch {
+        return null; // This PC's program has no usable sign-in: the note says how to save one.
+    }
+    if (payload)
+        store.save(kind, payload, 'pc', source.summary(payload));
+    return payload;
+}
 export function prepareServiceAccounts(i) {
     const store = i.store ?? new ServiceAccountStore(i.storageRoot);
     const leases = i.leases ?? new AccountLeases(i.storageRoot);
@@ -49,6 +70,8 @@ export function prepareServiceAccounts(i) {
             catch {
                 unreadable = true;
             }
+            if (!payload && !unreadable)
+                payload = takeFromPc(kind, i.pc, store);
             if (spec.singleHolder) {
                 const claim = leases.claim(kind, dataSet, i.launchId, payload ? fingerprint(payload) : null, i.isRunning);
                 if (!claim.ok) {

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

@@ -10,6 +10,8 @@ export interface PcEnv {
     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. */
     readonly userVariable?: (name: string) => string | null;
+    /** This PC's local drives ("D:\\"), asked only by the searches that look on every drive. */
+    readonly drives?: () => readonly string[];
 }
 /** The value of `name` in `reg query <key> /v <name>` output, or null. */
 export declare function parseRegValue(text: string, name: string): string | null;

package/dist/host/accounts/source.js

@@ -2,6 +2,7 @@
 // (fromFile, `sandbox account import <kind> --from <file>`), or typed (fromAnswers, `sandbox account login <kind>`).
 // One module per kind under kinds/; sources.ts lists them.
 import { spawnSync } from 'node:child_process';
+import { diskUsage } from '../../core/disk.js';
 import { fail } from '../../core/util/index.js';
 import { SYSTEM } from '../../shared/system.js';
 import { refuseInSelfTest } from '../test-guard.js';
@@ -35,6 +36,7 @@ export function pcEnv() {
         programFiles: env.ProgramFiles ?? 'C:\\Program Files',
         env,
         userVariable: savedUserVariable,
+        drives: () => diskUsage(env.ProgramData ?? 'C:\\').map((d) => d.drive),
     };
 }
 /** What a kind whose host side is not written yet says. */

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';