windows-development-sandbox 1.25.1 → 1.27.1

package/dist/core/schema/toolchains.d.ts

@@ -55,6 +55,14 @@ export declare const ToolchainsSchema: z.ZodObject<{
         modules: z.ZodArray<z.ZodString>;
         hub: z.ZodBoolean;
         keepVersions: z.ZodNumber;
+        mcp: z.ZodBoolean;
+        agentSkills: z.ZodBoolean;
+        cliVersion: z.ZodString;
+        assetCache: z.ZodEnum<{
+            pc: "pc";
+            persisted: "persisted";
+            local: "local";
+        }>;
     }, z.core.$strict>;
     godot: z.ZodObject<{
         enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;

package/dist/core/schema/toolchains.js

@@ -70,24 +70,39 @@ export const ToolchainsSchema = z.strictObject({
             .describe('"persisted": the engine\'s local derived data cache (compiled shaders, 10-50 GB) in tools\\unreal\\ddc, kept between sandboxes. "local": Unreal\'s own place on the sandbox disk (rebuilt every boot).'),
     }),
     unity: z.strictObject({
-        enabled: enabled("Unity: the editor version a project asks for, from Unity's release API (checked against its published hash), installed into tools\\unity\\<version> (6-7 GB each), with the modules you list.", 'ProjectSettings/ProjectVersion.txt'),
+        enabled: enabled("Unity: the editor version a project asks for, from Unity's release API (checked against its published hash), installed on the data disk (tools\\unity\\editors\\<version>, 8-13 GB each, kept between sandboxes), with the modules you list. This PC's editors (pcInstalls.unityEditors) are used first.", 'ProjectSettings/ProjectVersion.txt'),
         acceptLicense: z
             .boolean()
             .describe('Required to install: you accept the Unity terms of service (https://unity.com/legal/terms-of-service), and the editor needs a Unity licence (Personal is free). A project file cannot accept it for you.'),
         version: z
             .string()
             .min(1)
-            .describe('"project" = the version in ProjectSettings/ProjectVersion.txt, or an editor version such as "6000.0.32f1".'),
+            .describe('"project" = the version in ProjectSettings/ProjectVersion.txt, or an editor version such as "6000.0.32f1" for folders without one (a project\'s own version always wins).'),
         modules: z
             .array(z.string().regex(/^[a-z0-9-]+$/))
             .describe('Editor modules to add: "android" (4-5 GB, also the Android SDK), "webgl" (1.5 GB), "windows-il2cpp" (adds Visual Studio\'s C++ parts), "ios" (Xcode project export only: iOS builds need a Mac).'),
-        hub: z.boolean().describe('Also Unity Hub, with the installed editors listed in it.'),
+        hub: z
+            .boolean()
+            .describe('Also Unity Hub (kept on the data disk), for signing in to Unity Personal and installing editors by hand.'),
         keepVersions: z
             .number()
             .int()
             .min(1)
             .max(20)
             .describe('How many editor versions to keep in tools\\unity; older ones are removed (the least recently used first).'),
+        mcp: z
+            .boolean()
+            .describe("The Unity CLI's MCP server (unity mcp) in Claude Code and Codex as sbx-unity: Unity's read-only tools always, the open editor's tools when the project has the Unity Pipeline package (Unity 6 and later). Nothing in your project changes."),
+        agentSkills: z
+            .boolean()
+            .describe("Unity's skills for Claude Code and Codex, from Unity-Technologies/skills at the commit the Unity CLI pins."),
+        cliVersion: z
+            .string()
+            .regex(/^(latest|\d+\.\d+\.\d+(-[A-Za-z0-9.]+)?)$/)
+            .describe('The Unity CLI version, checked against the SHA-256 Unity publishes: a version such as "1.0.0-beta.16", or "latest". It never updates itself.'),
+        assetCache: z
+            .enum(['persisted', 'pc', 'local'])
+            .describe('"persisted": Asset Store downloads made in the sandbox go to tools\\unity\\asset-store (kept). "pc": the sandbox uses this PC\'s Asset Store downloads (read-only; download new ones on your PC). "local": Unity\'s own place on the sandbox disk (lost when it closes).'),
     }),
     godot: z.strictObject({
         enabled: enabled('Godot from its official builds (checked against the published SHA-512 sums), self-contained in tools\\godot\\<version> with `godot` (the console build) on PATH.', 'project.godot'),
@@ -218,7 +233,7 @@ export const ToolchainsSchema = z.strictObject({
     }),
     cli: z
         .strictObject({
-        gh: EnabledSchema.describe('GitHub CLI (gh). Only with provisioning.git.access "full": gh can push and merge through the GitHub API, past a read-only git. Your PC\'s gh login is never copied; `gh auth login` inside persists (GH_CONFIG_DIR), unless a token you saved for sandboxes is handed over (github.shareToken). "auto" = when the project has a .github folder.'),
+        gh: EnabledSchema.describe('GitHub CLI (gh). Only with provisioning.git.access "full": gh can push and merge through the GitHub API, past a read-only git. Your PC\'s gh login is copied only with github.usePcLogin (or a token you saved for sandboxes with github.shareToken); otherwise `gh auth login` inside persists (GH_CONFIG_DIR). "auto" = when the project has a .github folder.'),
         zstd: EnabledSchema.describe('Zstandard (zstd). "auto" = off; set true to get it.'),
         openssl: EnabledSchema.describe('`openssl` on PATH, from the copy Git for Windows ships (its mingw64\\bin is not put on PATH, so it cannot shadow MinGW\'s gcc). "auto" = on.'),
     })

package/dist/guest/accounts/adapters.js

@@ -5,6 +5,7 @@ import { epicAdapter } from './kinds/epic.js';
 import { expoAdapter } from './kinds/expo.js';
 import { keystoreAdapter } from './kinds/keystore.js';
 import { perplexityAdapter } from './kinds/perplexity.js';
+import { perplexityAppAdapter } from './kinds/perplexityapp.js';
 import { playAdapter } from './kinds/play.js';
 import { steamAdapter } from './kinds/steam.js';
 import { unityAdapter } from './kinds/unity.js';
@@ -19,4 +20,5 @@ export const ADAPTERS = {
     appstore: appstoreAdapter,
     perplexity: perplexityAdapter,
     comet: cometAdapter,
+    perplexityapp: perplexityAppAdapter,
 };

package/dist/guest/accounts/apply.d.ts

@@ -4,28 +4,30 @@ import type { ServiceAccounts } from '../../shared/accounts/payloads.js';
 import { type GuestAdapter } from './adapter.js';
 export declare const DeliveredSchema: z.ZodObject<{
     fingerprints: z.ZodRecord<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";
     }> & z.core.$partial, z.ZodString>;
     leased: z.ZodArray<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";
     }>>;
 }, z.core.$strip>;
 export type Delivered = z.output<typeof DeliveredSchema>;

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

@@ -0,0 +1,7 @@
+import { type CometPayload } from '../../../shared/accounts/index.js';
+import { type GuestAdapter } from '../adapter.js';
+/** Where the sign-in waits for the app. */
+export declare function perplexityAppPendingFile(root?: string): string;
+/** The sign-in waiting for the app (left in place), or null (none, or not the expected shape). */
+export declare function peekPendingPerplexityApp(root?: string): CometPayload | null;
+export declare const perplexityAppAdapter: GuestAdapter<'perplexityapp'>;

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

@@ -0,0 +1,53 @@
+// Perplexity desktop app: the saved perplexity.ai sign-in cookies wait in secretDir('perplexityapp') (the sandbox's own
+// disk) until the app runs; the watch then writes them into it over its DevTools port and deletes the file. While the
+// sandbox runs, the watch asks the running app for its perplexity.ai cookies, so a sign-in made here (or renewed) is
+// kept for the next sandbox. When the app is not running, the last sign-in seen stands.
+import fs from 'node:fs';
+import path from 'node:path';
+import { cometSummary, PAYLOADS } from '../../../shared/accounts/index.js';
+import { readBoundedFile } from '../../../shared/io/bounded.js';
+import { readAppSignIn, restoreAppSignIn } from '../../browser/perplexity-app.js';
+import { secretDir } from '../adapter.js';
+/** Where the sign-in waits for the app. */
+export function perplexityAppPendingFile(root = secretDir('perplexityapp')) {
+    return path.join(root, 'restore.json');
+}
+/** The sign-in waiting for the app (left in place), or null (none, or not the expected shape). */
+export function peekPendingPerplexityApp(root) {
+    const bytes = readBoundedFile(perplexityAppPendingFile(root), 512 * 1024);
+    if (!bytes)
+        return null;
+    try {
+        const parsed = PAYLOADS.perplexityapp.safeParse(JSON.parse(bytes.toString('utf8')));
+        return parsed.success ? parsed.data : null;
+    }
+    catch {
+        return null; // Not JSON: nothing to restore.
+    }
+}
+/** The last sign-in seen in this process (the daemon's watch). */
+let held = null;
+export const perplexityAppAdapter = {
+    kind: 'perplexityapp',
+    apply(p) {
+        const file = perplexityAppPendingFile();
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(file, JSON.stringify(p), { encoding: 'utf8', mode: 0o600 });
+        held = p;
+        return {
+            summary: 'Perplexity app: your saved sign-in (' + cometSummary(p) + ') goes into it once it runs (reload its window)',
+        };
+    },
+    async refresh() {
+        const pending = peekPendingPerplexityApp();
+        if (pending && (await restoreAppSignIn(pending).catch(() => false)))
+            fs.rmSync(perplexityAppPendingFile(), { force: true });
+        const now = await readAppSignIn();
+        if (now)
+            held = now;
+    },
+    current() {
+        return held;
+    },
+    checkMs: 30_000,
+};

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

@@ -1,2 +1,29 @@
+import type { UnityStatus } from '../../../shared/unity/status.js';
 import { type GuestAdapter } from '../adapter.js';
+/** Runs a program to its end (or its time limit); the exit code and what it printed. Injected by the self-test. */
+export type UnityRunner = (file: string, args: readonly string[], o: {
+    readonly timeoutMs: number;
+    readonly env?: Readonly<Record<string, string>>;
+}) => Promise<{
+    readonly code: number;
+    readonly stdout: string;
+}>;
+export declare const runUnityProgram: UnityRunner;
+export interface UnityDirs {
+    readonly programData: string;
+    readonly localAppData: string;
+    /** secretDir('unity'). */
+    readonly secrets: string;
+}
+/** The adapter for these folders and this runner (the self-test passes its own). */
+export declare function unityAdapterFor(dirs: UnityDirs, run?: UnityRunner): GuestAdapter<'unity'>;
 export declare const unityAdapter: GuestAdapter<'unity'>;
+/**
+ * Activates the serial the sandbox holds once an editor exists, then asks `unity license status` where the licence
+ * stands. The detail never holds a secret.
+ */
+export declare function activateUnityLicence(o: {
+    readonly editorExe: string | null;
+    readonly unityExe: string | null;
+    readonly source?: string;
+}, dirs?: UnityDirs, run?: UnityRunner): Promise<UnityStatus['licence']>;

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

@@ -1,7 +1,164 @@
-import { notAvailableYet } from '../adapter.js';
-export const unityAdapter = {
-    kind: 'unity',
-    apply(_p) {
-        return notAvailableYet('unity');
-    },
-};
+// Unity: the licence file (Unity_lic.ulf) goes to %ProgramData%\Unity and the named-user licence to
+// %LOCALAPPDATA%\Unity\licenses, where the editor reads them. The Unity ID (and a Plus or Pro serial) are kept in
+// secretDir('unity')\activation.json, on the sandbox's own disk, for the editor to sign in with. A serial seat is
+// returned when the sandbox stops. Nothing here puts a password, serial or licence text in a log or a summary.
+import { execFile } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { z } from 'zod';
+import { MAX_ULF_BYTES, parseLicenceStatus, unityEntitlementFile, unityUlfFile, } from '../../../shared/accounts/index.js';
+import { decodeText, readBoundedFile } from '../../../shared/io/index.js';
+import { licenceStatusArgs, UNITY_CLI_ENV } from '../../../shared/unity/cli.js';
+import { localAppData, secretDir } from '../adapter.js';
+const MAX_JSON_BYTES = 16 * 1024;
+const RETURN_MS = 120_000;
+const ACTIVATE_MS = 180_000;
+const STATUS_MS = 60_000;
+const ActivationSchema = z.object({
+    email: z.string().max(256).optional(),
+    password: z.string().max(1024).optional(),
+    serial: z.string().max(64).optional(),
+});
+const ActivatedSchema = z.object({ editorExe: z.string().min(1).max(520), serial: z.literal(true) });
+export const runUnityProgram = (file, args, o) => new Promise((resolve) => {
+    execFile(file, [...args], { windowsHide: true, timeout: o.timeoutMs, maxBuffer: 1024 * 1024, env: { ...process.env, ...o.env } }, (error, stdout) => {
+        const code = error ? (typeof error.code === 'number' ? error.code : -1) : 0;
+        resolve({ code, stdout: String(stdout ?? '') });
+    });
+});
+function readText(file) {
+    const bytes = readBoundedFile(file, MAX_ULF_BYTES);
+    return bytes ? decodeText(bytes).text : null;
+}
+function readSecretJson(schema, file) {
+    const bytes = readBoundedFile(file, MAX_JSON_BYTES);
+    if (!bytes)
+        return null;
+    try {
+        const parsed = schema.safeParse(JSON.parse(decodeText(bytes).text));
+        return parsed.success ? parsed.data : null;
+    }
+    catch {
+        return null; // not JSON: treated as absent
+    }
+}
+function writeText(file, text) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, text, 'utf8');
+}
+/** The adapter for these folders and this runner (the self-test passes its own). */
+export function unityAdapterFor(dirs, run = runUnityProgram) {
+    const activation = path.join(dirs.secrets, 'activation.json');
+    const activated = path.join(dirs.secrets, 'activated.json');
+    return {
+        kind: 'unity',
+        apply(p) {
+            if (p.ulf)
+                writeText(unityUlfFile(dirs.programData), p.ulf);
+            if (p.entitlement)
+                writeText(unityEntitlementFile(dirs.localAppData), p.entitlement);
+            const sign = {};
+            if (p.email)
+                sign.email = p.email;
+            if (p.password)
+                sign.password = p.password;
+            if (p.serial)
+                sign.serial = p.serial;
+            if (Object.keys(sign).length)
+                writeText(activation, JSON.stringify(sign));
+            return {
+                summary: p.ulf || p.entitlement
+                    ? 'Unity: your licence file is in place'
+                    : 'Unity: your Unity ID is ready to activate the serial',
+            };
+        },
+        current() {
+            const ulf = readText(unityUlfFile(dirs.programData));
+            const entitlement = readText(unityEntitlementFile(dirs.localAppData));
+            const sign = readSecretJson(ActivationSchema, activation) ?? {};
+            const out = {
+                ...(ulf ? { ulf } : {}),
+                ...(entitlement ? { entitlement } : {}),
+                ...sign,
+            };
+            return Object.keys(out).length ? out : null;
+        },
+        async release() {
+            const marker = readSecretJson(ActivatedSchema, activated);
+            if (!marker)
+                return;
+            const sign = readSecretJson(ActivationSchema, activation);
+            if (!sign?.email || !sign.password)
+                return;
+            await run(marker.editorExe, [
+                '-batchmode',
+                '-nographics',
+                '-quit',
+                '-returnlicense',
+                '-username',
+                sign.email,
+                '-password',
+                sign.password,
+                '-logFile',
+                path.join(dirs.secrets, 'return.log'),
+            ], { timeoutMs: RETURN_MS });
+        },
+    };
+}
+function defaultDirs() {
+    return {
+        programData: process.env.ProgramData ?? process.env.PROGRAMDATA ?? 'C:\\ProgramData',
+        localAppData: localAppData(),
+        secrets: secretDir('unity'),
+    };
+}
+export const unityAdapter = unityAdapterFor(defaultDirs());
+/**
+ * Activates the serial the sandbox holds once an editor exists, then asks `unity license status` where the licence
+ * stands. The detail never holds a secret.
+ */
+export async function activateUnityLicence(o, dirs = defaultDirs(), run = runUnityProgram) {
+    const sign = readSecretJson(ActivationSchema, path.join(dirs.secrets, 'activation.json'));
+    if (sign?.serial && sign.email && sign.password && o.editorExe) {
+        await run(o.editorExe, [
+            '-batchmode',
+            '-nographics',
+            '-quit',
+            '-serial',
+            sign.serial,
+            '-username',
+            sign.email,
+            '-password',
+            sign.password,
+            '-logFile',
+            path.join(dirs.secrets, 'activate.log'),
+        ], { timeoutMs: ACTIVATE_MS });
+        writeText(path.join(dirs.secrets, 'activated.json'), JSON.stringify({ editorExe: o.editorExe, serial: true }));
+    }
+    const user = sign?.email ?? null;
+    if (!o.unityExe)
+        return { state: 'unknown', kind: '', detail: 'not checked', user };
+    let parsed = null;
+    try {
+        const r = await run(o.unityExe, licenceStatusArgs(), { timeoutMs: STATUS_MS, env: UNITY_CLI_ENV });
+        parsed = r.code === 0 ? JSON.parse(r.stdout) : null;
+    }
+    catch {
+        parsed = null; // not JSON: reported as not recognised
+    }
+    const s = parseLicenceStatus(parsed);
+    if (s.state === 'active')
+        return { state: 'active', kind: s.kind, detail: 'active (' + (s.kind || 'licensed') + ')', user };
+    if (s.state === 'none') {
+        const hasFile = readText(unityUlfFile(dirs.programData)) !== null || readText(unityEntitlementFile(dirs.localAppData)) !== null;
+        return hasFile
+            ? {
+                state: 'invalid',
+                kind: '',
+                detail: 'the licence file from ' + (o.source ?? 'your saved sign-in') + ' is not accepted here: sign in again',
+                user,
+            }
+            : { state: 'none', kind: '', detail: 'none: sign in to Unity once in this sandbox', user };
+    }
+    return { state: 'unknown', kind: '', detail: s.detail, user };
+}

package/dist/guest/apps/app-installer.js

@@ -13,10 +13,13 @@ import { errMsg } from '../../core/util/errors.js';
 import { emptyEnv, tool } from '../toolchains/tool-env.js';
 import { uvVars } from '../toolchains/runtimes.js';
 import { COMET_MCP_PORT, cometShortcutArgs } from '../browser/comet.js';
+import { perplexityAppShortcutArgs } from '../browser/perplexity-app.js';
 import { afterInstall } from './after-install.js';
 import { installFromKept } from './comet-unpack.js';
 import { findExe } from './find-exe.js';
+import { installStoreApp } from './store-app.js';
 import { shortcuts } from './shortcuts.js';
+import { SYSTEM } from '../../shared/system.js';
 import { signatureCheck } from '../toolchains/installers.js';
 import { resolve } from './sources.js';
 import { unpack } from './unpack.js';
@@ -46,6 +49,7 @@ export class AppInstaller {
     async prefetch(entries) {
         const todo = entries.filter((e) => !('remote' in e.source) &&
             !('locked' in e.source) &&
+            !('store' in e.source) &&
             !('npm' in e.source) &&
             e.id !== '7zip' &&
             (this.options.refresh || !exists(path.join(tool('apps', ...e.id.split('/')), MARKER))));
@@ -97,6 +101,20 @@ export class AppInstaller {
                 this.installed.push(entry.name);
                 return;
             }
+            if ('store' in entry.source) {
+                // A Store app: Windows in the sandbox is new on every boot, so it is installed again from the PC's package.
+                log('Installing ' + entry.name + ' (Microsoft Store package) ...');
+                await installStoreApp(entry.id, entry.source.store.packageName);
+                fs.writeFileSync(path.join(mkdirp(dest), MARKER), JSON.stringify({ id: entry.id, at: new Date().toISOString() }));
+                this.gui.push({
+                    name: entry.name,
+                    exe: SYSTEM.powershell(),
+                    args: perplexityAppShortcutArgs(path.join(launchDir, 'sandbox', 'scripts', 'start-store-app.ps1')),
+                });
+                this.installed.push(entry.name);
+                this.installedIds.push(entry.id);
+                return;
+            }
             if (!exists(path.join(dest, MARKER)) || this.options.refresh)
                 await this.download(entry, dest);
             // A Chromium installer that could not be unpacked is kept and installed into the sandbox each boot instead.

package/dist/guest/apps/store-app.d.ts

@@ -0,0 +1,4 @@
+/** Where the PC left an app's package. */
+export declare function storePackageDir(appId: string): string;
+/** Installs the app from its kept package; resolves when Windows has it. */
+export declare function installStoreApp(appId: string, packageName: string): Promise<void>;

package/dist/guest/apps/store-app.js

@@ -0,0 +1,19 @@
+// A Microsoft Store app in the sandbox: the PC put its package files in the data folder (toolsapps<id>.package,
+// with store-package.json). Windows in the sandbox is new on every boot, so the app is installed again each boot with
+// Add-AppxPackage (sandbox\scripts\install-store-package.ps1), from the package kept on the data disk. The files are
+// checked against the manifest's SHA-256 first (store-check.ts). Windows checks the publisher's signature itself.
+import { runScriptWithJsonAsync } from '../runtime/process.js';
+import { tool } from '../toolchains/tool-env.js';
+import { checkedPackage } from './store-check.js';
+/** Where the PC left an app's package. */
+export function storePackageDir(appId) {
+    return tool('apps', appId + '.package');
+}
+/** Installs the app from its kept package; resolves when Windows has it. */
+export async function installStoreApp(appId, packageName) {
+    const { main, dependencies } = await checkedPackage(storePackageDir(appId));
+    await runScriptWithJsonAsync('install-store-package.ps1', 'ListFile', { main, dependencies }, [
+        '-PackageName',
+        packageName,
+    ]);
+}

package/dist/guest/apps/store-check.d.ts

@@ -0,0 +1,8 @@
+/** The SHA-256 of a file, read in pieces (the package is hundreds of MB). */
+export declare function fileSha256(file: string): Promise<string>;
+export interface CheckedPackage {
+    readonly main: string;
+    readonly dependencies: string[];
+}
+/** The package in `dir` when its manifest is valid and every file is there as hashed; throws otherwise. */
+export declare function checkedPackage(dir: string): Promise<CheckedPackage>;

package/dist/guest/apps/store-check.js

@@ -0,0 +1,33 @@
+// The package files of a Store app the PC left in the data folder, checked against the SHA-256 in store-package.json.
+// No runtime imports: the self-test loads this file.
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { STORE_PACKAGE_MANIFEST, StorePackageManifestSchema } from '../../shared/apps/store-package.js';
+import { readValid } from '../../shared/io/json.js';
+const READ_CHUNK = 1024 * 1024;
+/** The SHA-256 of a file, read in pieces (the package is hundreds of MB). */
+export function fileSha256(file) {
+    return new Promise((resolve, reject) => {
+        const hash = crypto.createHash('sha256');
+        const stream = fs.createReadStream(file, { highWaterMark: READ_CHUNK });
+        stream.on('data', (chunk) => hash.update(chunk));
+        stream.on('error', reject);
+        stream.on('end', () => resolve(hash.digest('hex')));
+    });
+}
+/** The package in `dir` when its manifest is valid and every file is there as hashed; throws otherwise. */
+export async function checkedPackage(dir) {
+    const manifest = readValid(StorePackageManifestSchema, path.join(dir, STORE_PACKAGE_MANIFEST));
+    if (!manifest)
+        throw new Error('the package was not handed over (this PC could not fetch it: see the launch notes)');
+    for (const f of manifest.files) {
+        if ((await fileSha256(path.join(dir, f.name)).catch(() => '')) !== f.sha256)
+            throw new Error(f.name + ' is missing or changed');
+    }
+    const full = (name) => path.join(dir, name);
+    return {
+        main: full(manifest.files.find((f) => f.role === 'main').name),
+        dependencies: manifest.files.filter((f) => f.role === 'dependency').map((f) => full(f.name)),
+    };
+}

package/dist/guest/boot/boot.js

@@ -99,7 +99,7 @@ function writeDbCommand() {
     writeDevToolCommands(dir);
     return dir;
 }
-/** sbx-steam, sbx-fivem, sbx-unity, sbx-android for the toolchains that are on: runtime\tool.js with that helper. */
+/** sbx-steam, sbx-fivem, sbx-android for the toolchains that are on: runtime\tool.js with that helper. */
 function writeDevToolCommands(dir) {
     const script = path.join(path.dirname(process.argv[1]), 'tool.js');
     for (const tool of devToolsFor(session.toolchains))

package/dist/guest/boot/guide.js

@@ -10,6 +10,9 @@ import { projectFolderLines, toolLines } from './guide-lines.js';
 import { sandboxScriptsDir } from '../../shared/scripts.js';
 import { findUproject, unrealGuideLines } from '../../shared/unreal/index.js';
 import { DISK } from '../toolchains/engines/unreal-engines.js';
+import { readValid } from '../../shared/io/json.js';
+import { UNITY_STATUS_FILE, UnityStatusSchema, unityGuideLines } from '../../shared/unity/index.js';
+import { tool } from '../toolchains/tool-env.js';
 import { readUnrealStatus } from '../toolchains/engines/unreal-status.js';
 const BEGIN = '<!-- agent-sandbox:begin (generated every boot, do not edit) -->';
 const END = '<!-- agent-sandbox:end -->';
@@ -48,6 +51,20 @@ function unrealLines(projects) {
         .filter((f) => status.projects.some((p) => p.workspace.toLowerCase() === f.toLowerCase()))
         .map((f) => ({ workspace: f, uproject: findUproject(f, DISK) })), { mixamo: { downloads: path.join(dataDir, 'downloads'), script: mixamoScript() } });
 }
+/** The Unity lines (editor per project, build/test/import commands) when the sandbox is set up for Unity. */
+function unityLines(projects) {
+    const any = session.toolchains.unity.enabled === true || projects.some((p) => p.tools?.some((t) => /^unity/.test(t)));
+    if (!any)
+        return [];
+    const status = readValid(UnityStatusSchema, path.join(tool('unity'), UNITY_STATUS_FILE));
+    if (!status?.updatedAt)
+        return [];
+    const folders = [workspace, ...projects.map((p) => p.guest)];
+    return unityGuideLines(status, folders
+        .filter((f, i) => folders.findIndex((g) => g.toLowerCase() === f.toLowerCase()) === i)
+        .filter((f) => status.projects.some((p) => p.workspace.toLowerCase() === f.toLowerCase()))
+        .map((f) => ({ workspace: f })));
+}
 /** Deliberately tiny: it is loaded into every conversation. */
 export function sandboxGuide(toolSummary, lan = 'blocked', projects = [], addons = []) {
     return [
@@ -69,6 +86,7 @@ export function sandboxGuide(toolSummary, lan = 'blocked', projects = [], addons
         ...mirrorLine(),
         ...toolLines(session.project, toolSummary, projects),
         ...unrealLines(projects),
+        ...unityLines(projects),
         // Agent add-ons that change how the agent works (rtk, Headroom, MCP servers, ccusage).
         ...addons,
         '- Persistent installs: `npm i -g` (per nvm version), `pip`, `cargo install`, `dotnet tool -g`, `uv tool`, `bun add -g`. Real installers must re-run each boot via a hook (ask the user).',

package/dist/guest/browser/comet.d.ts

@@ -1,5 +1,5 @@
 import { type CometPayload } from '../../shared/accounts/kinds/comet.js';
-import { type DevToolsEndpoint } from './cdp.js';
+import { CdpConnection, type DevToolsEndpoint } from './cdp.js';
 /** The port comet-mcp looks for (it connects to a Comet already listening there). */
 export declare const COMET_MCP_PORT = 9222;
 /** The addresses whose cookies are read back (their cookies and the parent domain's). */
@@ -16,6 +16,8 @@ export declare function cometLaunchArgs(port: number, profile?: string): string[
 export declare function cometShortcutArgs(port: number, profile?: string): string;
 /** Where a Comet running with this profile listens, from its DevToolsActivePort file; null when there is none. */
 export declare function devToolsEndpoint(profile?: string): DevToolsEndpoint | null;
+/** A connection to the Comet running with this profile, or null when none answers. */
+export declare function connect(profile: string): Promise<CdpConnection | null>;
 /**
  * The sign-in the running Comet holds now (perplexity.ai's own cookies, asked of one of its pages), or null when
  * Comet is not running with this profile, has no page open, or holds no sign-in. Never asks for another site's cookies.

package/dist/guest/browser/comet.js

@@ -56,7 +56,7 @@ export function devToolsEndpoint(profile = cometProfileDir()) {
     return bytes ? parseDevToolsActivePort(bytes.toString('utf8')) : null;
 }
 /** A connection to the Comet running with this profile, or null when none answers. */
-async function connect(profile) {
+export async function connect(profile) {
     const endpoint = devToolsEndpoint(profile);
     if (!endpoint)
         return null;

package/dist/guest/browser/perplexity-app.d.ts

@@ -0,0 +1,12 @@
+import { type CometPayload } from '../../shared/accounts/kinds/comet.js';
+/** The app's profile: on the sandbox's own disk, wiped with it. */
+export declare function perplexityAppProfileDir(): string;
+/**
+ * The powershell.exe arguments of the app's shortcut: start-store-app.ps1 with the package, the profile and a free
+ * DevTools port (0). `script` is the full path of the script in the launch folder.
+ */
+export declare function perplexityAppShortcutArgs(script: string, profile?: string): string;
+/** The sign-in the running app holds now, or null (not running with this profile, no page, signed out). */
+export declare function readAppSignIn(profile?: string): Promise<CometPayload | null>;
+/** Writes the sign-in into the running app; false when the app is not running with this profile. */
+export declare function restoreAppSignIn(payload: CometPayload, profile?: string): Promise<boolean>;

package/dist/guest/browser/perplexity-app.js

@@ -0,0 +1,60 @@
+// The Perplexity desktop app (a Microsoft Store package, Electron inside) in this sandbox: the profile folder it runs
+// with, the command line of its shortcut, and its sign-in over the DevTools port, the way Comet's is kept
+// (browser/comet.ts): only the allow-listed perplexity.ai cookies are read (Network.getCookies) and written back
+// (Storage.setCookies). The profile is on the sandbox's own disk: its cookie key is sealed to this sandbox's Windows
+// user, which is why the sign-in is not copied from the PC. No runtime imports: the sign-in adapter and the self-test
+// load this file.
+import fs from 'node:fs';
+import path from 'node:path';
+import { cookiesToRestore } from '../../shared/accounts/kinds/comet.js';
+import { PERPLEXITY_DESKTOP_PACKAGE } from '../../shared/apps/catalogue-agents-web.js';
+import { localAppData } from '../accounts/adapter.js';
+import { connect, readCometSignIn } from './comet.js';
+/** The app's profile: on the sandbox's own disk, wiped with it. */
+export function perplexityAppProfileDir() {
+    return path.join(localAppData(), 'AgentSandbox', 'perplexity-app-profile');
+}
+/**
+ * The powershell.exe arguments of the app's shortcut: start-store-app.ps1 with the package, the profile and a free
+ * DevTools port (0). `script` is the full path of the script in the launch folder.
+ */
+export function perplexityAppShortcutArgs(script, profile = perplexityAppProfileDir()) {
+    return [
+        '-NoLogo',
+        '-NoProfile',
+        '-WindowStyle',
+        'Hidden',
+        '-ExecutionPolicy',
+        'Bypass',
+        '-File',
+        '"' + script + '"',
+        '-PackageName',
+        PERPLEXITY_DESKTOP_PACKAGE,
+        '-UserDataDir',
+        '"' + profile + '"',
+        '-Port',
+        '0',
+    ].join(' ');
+}
+/** The sign-in the running app holds now, or null (not running with this profile, no page, signed out). */
+export function readAppSignIn(profile = perplexityAppProfileDir()) {
+    return readCometSignIn(profile);
+}
+/** Writes the sign-in into the running app; false when the app is not running with this profile. */
+export async function restoreAppSignIn(payload, profile = perplexityAppProfileDir()) {
+    const cookies = cookiesToRestore(payload, Math.floor(Date.now() / 1000));
+    if (!cookies.length)
+        return true;
+    if (!fs.existsSync(path.join(profile, 'DevToolsActivePort')))
+        return false;
+    const cdp = await connect(profile);
+    if (!cdp)
+        return false;
+    try {
+        await cdp.call('Storage.setCookies', { cookies });
+        return true;
+    }
+    finally {
+        cdp.close();
+    }
+}