windows-development-sandbox 1.25.1 → 1.27.0

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

@@ -0,0 +1,39 @@
+// tools\unity\status.json: what the sandbox found for Unity, for the guide and the Unity page on the PC. The boot's
+// project step writes its editor choice, the licence step the licence, the daemon the editors; every write keeps what
+// the other parts wrote.
+import path from 'node:path';
+import { readValid, writeJsonAtomic } from '../../../shared/io/json.js';
+import { UNITY_STATUS_FILE, UnityStatusSchema } from '../../../shared/unity/index.js';
+import { mkdirp } from '../../runtime/fs.js';
+import { tool } from '../tool-env.js';
+export const UNITY_DIR = tool('unity');
+/** The Unity CLI, one folder per version (unity.exe). */
+export const CLI_DIR = path.join(UNITY_DIR, 'cli');
+/** The editors on the data disk: one folder per version (Editor\Unity.exe). */
+export const EDITORS_DIR = path.join(UNITY_DIR, 'editors');
+/** Asset Store downloads made in the sandbox (assetCache "persisted"). */
+export const ASSET_DIR = path.join(UNITY_DIR, 'asset-store');
+const FILE = path.join(UNITY_DIR, UNITY_STATUS_FILE);
+const EMPTY = {
+    updatedAt: '',
+    cli: null,
+    editors: [],
+    projects: [],
+    licence: { state: 'unknown', kind: '', detail: 'not checked', user: null },
+    assetCache: { mode: 'local', dir: null },
+    pcAssets: [],
+    hub: { installed: false, path: null },
+    mcp: null,
+    skills: false,
+    problem: null,
+};
+export function readUnityStatus() {
+    return readValid(UnityStatusSchema, FILE) ?? EMPTY;
+}
+/** Changes the status with `change` and writes it (whole, atomically). */
+export function updateUnityStatus(change) {
+    const next = { ...change(readUnityStatus()), updatedAt: new Date().toISOString() };
+    mkdirp(UNITY_DIR);
+    writeJsonAtomic(FILE, next);
+    return next;
+}

package/dist/guest/toolchains/engines/unity.d.ts

@@ -1,4 +1,23 @@
+import { type UnityEditor, type WantedEditor } from '../../../shared/unity/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 setupUnity(env: ToolEnv, _config: Toolchains['unity'], _ctx: ToolCtx): Promise<void>;
+import { type UnityCli } from './unity-cli.js';
+/** Every editor this sandbox has. */
+export declare function sandboxEditors(ctx: Pick<ToolCtx, 'pcInstalls'>): UnityEditor[];
+/**
+ * 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 declare function wantedEditor(config: Pick<Toolchains['unity'], 'version'>, workspace: string): WantedEditor | null;
+/** Whether the project's editor is already here (a first install goes to the background). */
+export declare function unityEditorSaved(config: Toolchains['unity'], ctx: Pick<ToolCtx, 'pcInstalls'>): boolean;
+/**
+ * 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 declare function ensureUnityEditor(cli: UnityCli, version: string, changeset: string | null, modules: readonly string[], keepVersions: number): Promise<string>;
+/** While the sandbox runs: lists the editors again (the user may have installed one with Hub) for the status. */
+export declare function captureUnityEditors(): Promise<void>;
+/** The editors, the project's choice, the CLI, the licence, the asset cache: set up and written to the status. */
+export declare function setupUnity(env: ToolEnv, config: Toolchains['unity'], ctx: ToolCtx): Promise<void>;

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/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.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/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/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[];
+}>;