windows-development-sandbox 1.25.1 → 1.27.0

package/dist/selftest/support/fixtures.d.ts

@@ -106,6 +106,7 @@ export declare function createFixtures(t: Harness): {
         };
         github: {
             shareToken: boolean;
+            usePcLogin: boolean;
         };
         accounts: {
             epic: {
@@ -138,6 +139,9 @@ export declare function createFixtures(t: Harness): {
             comet: {
                 share: boolean;
             };
+            perplexityapp: {
+                share: boolean;
+            };
         };
         pcInstalls: {
             steamGames: boolean | number[];
@@ -145,7 +149,8 @@ export declare function createFixtures(t: Harness): {
             unrealEngines: boolean | string[] | "auto";
             unrealEngineFolders: string[];
             unrealAssets: boolean | "auto";
-            unityEditors: boolean | string[];
+            unityEditors: boolean | string[] | "auto";
+            unityAssets: boolean | "auto";
         };
         provisioning: {
             copyFromHost: boolean;
@@ -212,6 +217,10 @@ export declare function createFixtures(t: Harness): {
                 modules: string[];
                 hub: boolean;
                 keepVersions: number;
+                mcp: boolean;
+                agentSkills: boolean;
+                cliVersion: string;
+                assetCache: "pc" | "persisted" | "local";
             };
             godot: {
                 enabled: boolean | "auto";

package/dist/selftest/support/unity-sample.d.ts

@@ -0,0 +1,2 @@
+import type { UnityOverview } from '../../app/features/unity/index.js';
+export declare const UNITY_SAMPLE: UnityOverview;

package/dist/selftest/support/unity-sample.js

@@ -0,0 +1,80 @@
+export const UNITY_SAMPLE = {
+    setUp: true,
+    checkedAt: '2026-11-05T12:00:00.000Z',
+    cli: { version: '1.0.0-beta.16', path: 'C:\\AgentData\\tools\\unity\\cli\\1.0.0-beta.16\\unity.exe' },
+    editors: [
+        {
+            version: '6000.0.58f2',
+            dir: 'C:\\PcInstalls\\unity\\6000.0.58f2',
+            where: 'this PC, read-only',
+            writable: false,
+            modules: ['android'],
+            sizeBytes: null,
+            projects: ['Platformer'],
+        },
+        {
+            version: '2022.3.20f1',
+            dir: 'C:\\AgentData\\tools\\unity\\editors\\2022.3.20f1',
+            where: 'the data disk, kept between sandboxes',
+            writable: true,
+            modules: [],
+            sizeBytes: 9 * 1024 ** 3,
+            projects: ['OldGame'],
+        },
+    ],
+    projects: [
+        {
+            project: 'Platformer',
+            folder: 'F:\\Code\\Platformer',
+            version: '6000.0.58f2',
+            editor: 'Unity 6000.0.58f2',
+            reason: 'the project asks for 6000.0.58f2',
+            bridge: 'pipeline',
+            pipeline: true,
+        },
+        {
+            project: 'OldGame',
+            folder: 'F:\\Code\\OldGame',
+            version: '2022.3.20f1',
+            editor: 'Unity 2022.3.20f1',
+            reason: 'the project asks for 2022.3.20f1',
+            bridge: null,
+            pipeline: false,
+        },
+    ],
+    licence: { state: 'active', kind: 'Personal', detail: 'Unity Personal', user: 'dev@example.com' },
+    hub: { installed: false, setting: false },
+    assetCache: { mode: 'persisted', dir: 'C:\\AgentData\\tools\\unity\\asset-store' },
+    agentTools: { cliVersion: '1.0.0-beta.16', mcp: 'sbx-unity', mcpSetting: true, skills: true, skillsSetting: true },
+    pc: {
+        setting: 'auto',
+        editors: [{ version: '6000.0.58f2', folder: 'C:\\Program Files\\Unity\\Hub\\Editor\\6000.0.58f2' }],
+        problem: null,
+    },
+    assets: {
+        setting: 'auto',
+        folders: [
+            {
+                folder: 'C:\\Users\\dev\\AppData\\Roaming\\Unity\\Asset Store-5.x',
+                packages: [
+                    { publisher: 'Kenney', category: '2D', name: 'Platformer Pack', size: '120 MB' },
+                    { publisher: 'Synty Studios', category: '3D Models', name: 'POLYGON Fantasy', size: '1.4 GB' },
+                ],
+                more: 0,
+            },
+        ],
+    },
+    problem: null,
+    settings: {
+        enabled: 'auto',
+        acceptLicense: true,
+        version: 'project',
+        modules: 'none',
+        hub: false,
+        keepVersions: 2,
+        mcp: true,
+        agentSkills: true,
+        cliVersion: '1.0.0-beta.16',
+        assetCache: 'persisted',
+    },
+};

package/dist/selftest/unity-accounts.test.d.ts

@@ -0,0 +1,2 @@
+import type { Suite } from './support/suite.js';
+export declare const unityAccountsSuite: Suite;

package/dist/selftest/unity-accounts.test.js

@@ -0,0 +1,106 @@
+// Unity licence and sign-in: the host source (a fake ProgramData and LocalAppData in temp folders), the guest adapter
+// (apply and read back, release with an injected runner) and the Accounts page. Nothing real is read or run.
+import path from 'node:path';
+import { serviceRow, servicePage } from '../app/features/accounts/index.js';
+import { pageLines } from '../cli/output/index.js';
+import { AccountLeases, HOST_SOURCES, ServiceAccountStore } from '../host/accounts/index.js';
+import { unitySource } from '../host/accounts/kinds/unity.js';
+import { SecretStore } from '../host/secrets/index.js';
+import { serviceWanted, unityEntitlementFile, unityUlfFile, } from '../shared/accounts/index.js';
+import { activateUnityLicence, unityAdapterFor } from '../guest/accounts/kinds/unity.js';
+const ULF = '<?xml version="1.0"?><root><License id="Terms"><SerialMasked Value="U3-XXXX-XXXX"/></License></root>';
+const ENTITLEMENT = '<?xml version="1.0"?><Entitlement><Id>abc</Id></Entitlement>';
+const PASSWORD = 'hunter2-unity-pw';
+const SERIAL = 'E3-AAAA-BBBB-CCCC-DDDD-EEEE';
+function message(fn) {
+    try {
+        fn();
+    }
+    catch (e) {
+        return String(e.message);
+    }
+    return '';
+}
+export const unityAccountsSuite = {
+    name: 'unity-accounts',
+    title: 'Unity licence and sign-in',
+    run: async (t, f) => {
+        t.section('the host source');
+        const pcDir = t.dir('unity-pc');
+        const pc = {
+            programData: path.join(pcDir, 'ProgramData'),
+            localAppData: path.join(pcDir, 'Local'),
+            appData: path.join(pcDir, 'Roaming'),
+        };
+        t.check(unitySource.fromPc(pc) === null, 'a PC with no Unity licence gives nothing');
+        t.write(unityUlfFile(pc.programData), ULF);
+        t.write(unityEntitlementFile(pc.localAppData), ENTITLEMENT);
+        const fromPc = unitySource.fromPc(pc);
+        t.check(fromPc?.ulf === ULF && fromPc.entitlement === ENTITLEMENT, 'the PC licence and entitlement are read');
+        const other = t.dir('unity-other');
+        t.write(unityUlfFile(other), ULF);
+        t.check(unitySource.fromPc({ ...pc, localAppData: '' }, other)?.ulf === ULF, '--from names another ProgramData folder');
+        const virtual = t.dir('unity-virtual');
+        t.write(path.join(virtual, 'VirtualStore', 'ProgramData', 'Unity', 'Unity_lic.ulf'), ULF);
+        t.check(unitySource.fromPc({ programData: path.join(virtual, 'none'), localAppData: virtual, appData: '' })?.ulf === ULF, 'the VirtualStore copy is the fallback');
+        const refusal = message(() => unitySource.fromFile(Buffer.from('hello'), {}));
+        t.check(refusal.includes('That is not a Unity licence file (Unity_lic.ulf) or entitlement file.'), 'a file that is not a licence is refused with the plain text', refusal);
+        const ulfPayload = unitySource.fromFile(Buffer.from(ULF), { email: 'me@example.com' });
+        const entPayload = unitySource.fromFile(Buffer.from(ENTITLEMENT), {});
+        t.check(ulfPayload.ulf === ULF && ulfPayload.email === 'me@example.com' && entPayload.entitlement === ENTITLEMENT, 'a ULF becomes ulf, an Entitlement file becomes entitlement, answers are added');
+        t.check(message(() => unitySource.fromAnswers({ serial: SERIAL, email: 'me@example.com' })).includes('A serial needs your Unity ID email and password.'), 'a serial without email and password is refused');
+        const typed = unitySource.fromAnswers({ email: 'me@example.com', password: PASSWORD, serial: SERIAL });
+        t.check(typed.email === 'me@example.com' && typed.password === PASSWORD && typed.serial === SERIAL, 'typed answers');
+        const summary = unitySource.summary(typed) ?? '';
+        t.check(!summary.includes(PASSWORD) && !summary.includes(SERIAL), 'the summary never holds a secret');
+        t.section('the guest adapter');
+        const runs = [];
+        const run = (file, args) => {
+            runs.push(file + ' ' + args.join(' '));
+            return Promise.resolve({ code: 0, stdout: '{"status":"active","type":"Personal"}' });
+        };
+        const dirs = {
+            programData: t.dir('unity-guest-pd'),
+            localAppData: t.dir('unity-guest-local'),
+            secrets: t.dir('unity-guest-secrets'),
+        };
+        const adapter = unityAdapterFor(dirs, run);
+        t.check(adapter.current() === null, 'nothing is held at first');
+        const payload = { ulf: ULF, entitlement: ENTITLEMENT, email: 'me@example.com', password: PASSWORD };
+        const applied = await adapter.apply(payload);
+        const back = adapter.current();
+        t.check(back?.ulf === ULF &&
+            back.entitlement === ENTITLEMENT &&
+            back.email === 'me@example.com' &&
+            back.password === PASSWORD, 'apply then current keeps the licence files and the password');
+        t.check(!applied.summary.includes(PASSWORD) && !applied.summary.includes('me@example.com'), 'the summary is safe');
+        await adapter.release();
+        t.check(runs.length === 0, 'release without activated.json runs nothing');
+        const serialDirs = { ...dirs, secrets: t.dir('unity-guest-secrets2') };
+        const serialRuns = [];
+        const record = (file, args, o) => {
+            serialRuns.push(file + ' ' + args.join(' '));
+            return run(file, args, o);
+        };
+        const serialAdapter = unityAdapterFor(serialDirs, record);
+        await serialAdapter.apply({ email: 'me@example.com', password: PASSWORD, serial: SERIAL });
+        const licence = await activateUnityLicence({ editorExe: 'C:\\Editor\\Unity.exe', unityExe: 'C:\\Cli\\unity.exe' }, serialDirs, record);
+        t.check(serialRuns[0].includes('-serial') && serialRuns[0].includes('activate.log') && licence.state === 'active', 'a serial is activated with the editor, then the licence status is read');
+        t.check(!JSON.stringify(licence).includes(PASSWORD) && !JSON.stringify(licence).includes(SERIAL), 'the licence status holds no secret');
+        await serialAdapter.release();
+        t.check(serialRuns.some((r) => r.includes('-returnlicense') && r.includes('return.log')), 'release returns the seat once activated.json exists');
+        const noLicence = () => Promise.resolve({ code: 0, stdout: '{"licenses":[]}' });
+        const none = await activateUnityLicence({ editorExe: null, unityExe: 'C:\\Cli\\unity.exe' }, { programData: t.dir('unity-empty-pd'), localAppData: t.dir('unity-empty-la'), secrets: t.dir('unity-empty-s') }, noLicence);
+        t.check(none.state === 'none' && none.detail === 'none: sign in to Unity once in this sandbox', 'no licence: sign in once');
+        const refused = await activateUnityLicence({ editorExe: null, unityExe: 'C:\\Cli\\unity.exe', source: 'this PC' }, dirs, noLicence);
+        t.check(refused.state === 'invalid' && refused.detail.includes('is not accepted here: sign in again'), 'a licence file that is not accepted says to sign in again');
+        t.section('who wants it, and the page');
+        t.check(serviceWanted('unity', new Set(['unity'])) && !serviceWanted('unity', new Set(['steam'])), 'only the Unity toolchain wants the Unity sign-in');
+        t.check(HOST_SOURCES.unity === unitySource, 'the Unity source is registered');
+        const config = f.makeConfig();
+        const store = new ServiceAccountStore(config.storage.root, SecretStore.memory());
+        const row = serviceRow('unity', config, store, new AccountLeases(config.storage.root));
+        const text = pageLines(servicePage(row)).join('\n');
+        t.check(row.canImport && row.canLogin && row.warnings.length > 0 && !text.includes('sandbox account'), 'the Accounts section offers import and sign in, and shows no "sandbox account" command text', text);
+    },
+};

package/dist/selftest/unity-agent.test.d.ts

@@ -0,0 +1,2 @@
+import type { Suite } from './support/suite.js';
+export declare const unityAgentSuite: Suite;

package/dist/selftest/unity-agent.test.js

@@ -0,0 +1,47 @@
+// Unity agent tools: sbx-unity in Claude Code's and Codex's MCP settings, the Apps add-ons (MCP for Unity, openupm-cli)
+// and their lock files. Pure: nothing is installed or run.
+import fs from 'node:fs';
+import path from 'node:path';
+import { addonMcpServer, APPS, codexWithAddonMcpServers, withAddonMcpServers, } from '../shared/apps/index.js';
+import { UNITY_MCP_NAME, unityCliMcpServer } from '../shared/unity/index.js';
+export const unityAgentSuite = {
+    name: 'unity-agent',
+    title: 'Unity agent tools: MCP, guide, Apps add-ons',
+    run: (t) => {
+        t.section('sbx-unity in the agents');
+        const server = unityCliMcpServer('C:\\AgentData\\tools\\unity\\cli\\1.0.0\\unity.exe', 'C:\\Workspace\\game');
+        const mine = { mine: { type: 'stdio', command: 'mine.exe', args: [], env: {} } };
+        // The guest's ENGINE_MCP_NAMES (guest/setup/addon-mcp.ts) cannot be imported here: it loads the guest runtime.
+        const engineNames = ['sbx-unreal-editor', UNITY_MCP_NAME];
+        const names = [...APPS.flatMap((a) => (a.mcp ? [a.mcp.name] : [])), ...engineNames];
+        const on = withAddonMcpServers(mine, { [UNITY_MCP_NAME]: server }, names);
+        t.check('mine' in on && UNITY_MCP_NAME in on, 'your own servers are kept and sbx-unity is added');
+        const off = withAddonMcpServers(on, {}, names);
+        t.check('mine' in off && !(UNITY_MCP_NAME in off), 'sbx-unity is removed when it is off; your servers stay');
+        const codex = codexWithAddonMcpServers('', { [UNITY_MCP_NAME]: server }, engineNames);
+        t.check(codex.toml.includes('[mcp_servers.sbx-unity]') && codex.toml.includes('args = ["mcp", "--cli-tools"]'), 'Codex gets [mcp_servers.sbx-unity] with args = ["mcp", "--cli-tools"]');
+        t.section('Apps add-ons');
+        const unity = APPS.find((a) => a.id === 'unity-mcp');
+        const built = addonMcpServer('C:\\x', unity.mcp, { exe: 'C:\\x\\venv\\Scripts\\mcp-for-unity.exe' });
+        t.check(built?.type === 'stdio' &&
+            built.command === 'C:\\x\\venv\\Scripts\\mcp-for-unity.exe' &&
+            built.args.join(' ') === '--transport stdio' &&
+            built.env.DISABLE_TELEMETRY === '1' &&
+            built.env.UNITY_MCP_DISABLE_TELEMETRY === '1' &&
+            built.env.MCP_DISABLE_TELEMETRY === '1' &&
+            unity.mcp?.name === 'sbx-unity-mcp' &&
+            unity.mcp.codex === true, 'MCP for Unity runs mcp-for-unity.exe --transport stdio with telemetry off, for Claude Code and Codex');
+        const openupm = APPS.find((a) => a.id === 'openupm-cli');
+        t.check(openupm?.exe === 'openupm.cmd' && openupm.category === 'gamedev' && !openupm.mcp, 'openupm-cli is a game-development app');
+        const addons = path.join(process.cwd(), 'sandbox', 'addons');
+        const reqs = fs.readFileSync(path.join(addons, 'unity-mcp', 'requirements.txt'), 'utf8');
+        t.check(fs
+            .readFileSync(path.join(addons, 'unity-mcp', 'requirements.in'), 'utf8')
+            .includes('mcpforunityserver==10.3.0') &&
+            /^mcpforunityserver==10\.3\.0 \\\r?\n\s+--hash=sha256:[0-9a-f]{64}/m.test(reqs), 'the MCP for Unity lock file pins mcpforunityserver 10.3.0 with hashes');
+        const lock = fs.readFileSync(path.join(addons, 'openupm-cli', 'package-lock.json'), 'utf8');
+        t.check(fs.existsSync(path.join(addons, 'openupm-cli', 'package.json')) &&
+            lock.includes('"node_modules/openupm-cli"') &&
+            lock.includes('"version": "4.5.3"'), 'the openupm-cli lock file pins 4.5.3');
+    },
+};

package/dist/selftest/unity-page.test.d.ts

@@ -0,0 +1,2 @@
+import type { Suite } from './support/suite.js';
+export declare const unityPageSuite: Suite;

package/dist/selftest/unity-page.test.js

@@ -0,0 +1,177 @@
+// The Unity page and its host side: this PC's editors and Asset Store downloads (a temp PC tree), "auto" following the
+// launch, the status file never read through a link, the page itself (no command text, every operation on it) and the
+// editor bridge edited in a temp project. No network: the Pipeline version lookup is given a fake.
+import fs from 'node:fs';
+import path from 'node:path';
+import { DEFAULTS } from '../core/config/index.js';
+import { pageActions } from '../app/kernel/index.js';
+import { unityPage, unityView } from '../app/features/unity/index.js';
+import { addBridgeToProject, latestPipelineVersion, readStatus, removeBridgeFromProject, } from '../app/features/unity/unity.run.js';
+import { discoverPcInstalls } from '../host/pc-installs/index.js';
+import { findUnityEditorsOnPc, unityAssetCacheDirs, unityPcFiles } from '../host/pc-installs/unity.js';
+import { unityAssetInstalls } from '../host/pc-installs/unity-assets.js';
+import { pageLines } from '../cli/output/render-view.js';
+import { UNITY_STATUS_FILE, bridgeOf } from '../shared/unity/index.js';
+import { UNITY_SAMPLE } from './support/unity-sample.js';
+const STATUS = {
+    updatedAt: '2026-11-05T12:00:00.000Z',
+    cli: null,
+    editors: [],
+    projects: [],
+    licence: { state: 'unknown', kind: '', detail: '', user: null },
+    assetCache: { mode: 'persisted', dir: null },
+    pcAssets: [],
+    hub: { installed: false, path: null },
+    mcp: null,
+    skills: false,
+    problem: null,
+};
+const MANIFEST = JSON.stringify({ dependencies: { 'com.unity.ugui': '2.0.0', 'com.unity.modules.ai': '1.0.0' } }, null, 2) + '\n';
+export const unityPageSuite = {
+    name: 'unity-page',
+    title: "The Unity page: this PC's editors and downloads, auto, the status file, the bridge",
+    run: async (t) => {
+        t.section("this PC's editors");
+        const pcDir = t.dir('pc');
+        const appData = path.join(pcDir, 'AppData');
+        const programFiles = path.join(pcDir, 'Program Files');
+        const editor = (root) => t.write(path.join(root, 'Editor', 'Unity.exe'), 'x');
+        editor(path.join(programFiles, 'Unity', 'Hub', 'Editor', '6000.0.58f2'));
+        const second = path.join(pcDir, 'Editors');
+        editor(path.join(second, '2022.3.20f1'));
+        t.write(path.join(appData, 'UnityHub', 'secondaryInstallPath.json'), JSON.stringify(second));
+        const listedRoot = path.join(pcDir, 'Elsewhere', '2021.3.1f1');
+        editor(listedRoot);
+        editor(path.join(pcDir, 'Elsewhere', 'evil'));
+        t.write(path.join(appData, 'UnityHub', 'editors-v2.json'), JSON.stringify({
+            'schema-version': 'v2',
+            data: [
+                { version: '2021.3.1f1', location: [path.join(listedRoot, 'Editor', 'Unity.exe')], other: 1 },
+                { version: '../../evil', location: path.join(pcDir, 'Elsewhere', 'evil', 'Editor', 'Unity.exe') },
+                { version: '2020.3.1f1', location: path.join(pcDir, 'Elsewhere', 'x', 'Editor', 'notunity.exe') },
+                { version: 5, location: 3 },
+            ],
+        }));
+        const files = unityPcFiles({ appData, localAppData: '', programData: '', programFiles });
+        const found = findUnityEditorsOnPc(files, true);
+        t.equal(found.map((e) => e.id), ['6000.0.58f2', '2022.3.20f1', '2021.3.1f1'], 'the default folder, the secondary folder and editors-v2.json are read; a bad version or exe name is skipped');
+        t.check(found.every((e) => e.kind === 'unity' && e.name === 'Unity ' + e.id && e.version === e.id), 'each editor is named by its version');
+        t.equal(findUnityEditorsOnPc(files, ['2022.3.20f1']).map((e) => e.id), ['2022.3.20f1'], 'a list asks for exact versions only');
+        t.write(path.join(appData, 'UnityHub', 'secondaryInstallPath.json'), JSON.stringify('relative\\dir'));
+        t.equal(findUnityEditorsOnPc(files, true).map((e) => e.id), ['6000.0.58f2', '2021.3.1f1'], 'a relative secondary path is ignored');
+        t.section("this PC's Asset Store downloads");
+        const store = path.join(appData, 'Unity', 'Asset Store-5.x');
+        t.write(path.join(store, 'Kenney', '2D', 'Pack.unitypackage'), 'x');
+        const envRoot = t.dir('pc', 'Cache');
+        t.dir('pc', 'Cache', 'Asset Store-5.x');
+        t.equal(unityAssetCacheDirs(files, undefined), [store], 'the default folder under %APPDATA%\\Unity');
+        t.equal(unityAssetCacheDirs(files, envRoot), [path.join(envRoot, 'Asset Store-5.x'), store], 'the environment variable first, then the default');
+        t.equal(unityAssetInstalls([store, store + '2']).map((i) => i.id), ['AssetStore', 'AssetStore2'], 'mapped at AssetStore, AssetStore2');
+        t.section('auto follows the launch');
+        const host = t.dir('auto-host', '6000.0.58f2');
+        const unitySource = {
+            kind: 'unity',
+            setting: 'unityEditors',
+            find: () => [{ kind: 'unity', id: '6000.0.58f2', name: 'Unity 6000.0.58f2', host, guest: '' }],
+        };
+        const unrealSource = {
+            kind: 'unreal',
+            setting: 'unrealEngines',
+            find: () => [{ kind: 'unreal', id: 'UE_5.4', name: 'Unreal Engine 5.4', host, guest: '' }],
+        };
+        const run = (o) => discoverPcInstalls(DEFAULTS.pcInstalls, {
+            packageRoot: t.packageRoot,
+            storageRoot: t.dir('auto-storage'),
+            sources: [unitySource, unrealSource],
+            ...o,
+        }).manifest.items.map((i) => i.guest);
+        t.equal(run({ unityOn: true }), ['C:\\PcInstalls\\unity\\6000.0.58f2'], 'Unity on: the editors, not the engines');
+        t.equal(run({ unrealOn: true }), ['C:\\PcInstalls\\unreal\\UE_5.4'], 'Unreal on: the engines, not the editors');
+        t.equal(run({}), [], 'neither on: nothing');
+        t.section('the status file');
+        const data = t.dir('status-data');
+        const target = t.dir('status-elsewhere');
+        t.write(path.join(target, UNITY_STATUS_FILE), JSON.stringify(STATUS));
+        t.write(path.join(data, 'plain', 'tools', 'unity', UNITY_STATUS_FILE), JSON.stringify(STATUS));
+        t.check(readStatus(path.join(data, 'plain')) !== null, 'a status file in the data folder is read');
+        fs.mkdirSync(path.join(data, 'linked', 'tools'), { recursive: true });
+        fs.symlinkSync(target, path.join(data, 'linked', 'tools', 'unity'), 'junction');
+        t.check(readStatus(path.join(data, 'linked')) === null, 'a junction at tools\\unity is never followed');
+        t.write(path.join(data, 'bad', 'tools', 'unity', UNITY_STATUS_FILE), '{"editors": "x"}');
+        t.check(readStatus(path.join(data, 'bad')) === null, 'a status file that does not fit the schema is not used');
+        t.section('the page');
+        const page = unityPage(UNITY_SAMPLE);
+        t.equal(page.sections.map((s) => s.id), ['editors', 'pc', 'assets', 'licence', 'projects', 'tools', 'settings'], 'editors, this PC, assets, licence, projects, agent tools, settings');
+        const actions = pageActions(page);
+        const ops = actions.flatMap((a) => (a.kind === 'operation' ? [a.op] : []));
+        t.check(unityView.operations.every((op) => ops.includes(op.id) || op.id === 'unity.openHub'), 'every operation of the view is on the page (Open Unity Hub once the Hub is in the sandbox)');
+        const withHub = pageActions(unityPage({ ...UNITY_SAMPLE, hub: { installed: true, setting: true } }));
+        t.check(withHub.some((a) => a.kind === 'operation' && a.op === 'unity.openHub'), 'Open Unity Hub is offered when the Hub is installed');
+        t.check(actions.some((a) => a.kind === 'link' && a.target.kind === 'view' && a.target.view === 'accounts'), 'a link to Unity sign-in in Accounts');
+        const settingKeys = actions.flatMap((a) => a.kind === 'link' && a.target.kind === 'setting' ? [a.target.key] : []);
+        t.check(settingKeys.includes('pcInstalls.unityEditors'), 'the settings are links');
+        const text = pageLines(page).join('\n');
+        for (const needle of [
+            '6000.0.58f2',
+            'this PC, read-only',
+            'Platformer Pack',
+            'dev@example.com',
+            'toolchains.unity.assetCache',
+            'pcInstalls.unityAssets',
+        ])
+            t.includes(text, needle, 'the page shows ' + needle);
+        t.check(!/sandbox (unity|launch|config|account|projects)/.test(text), 'no page text tells you to run a command');
+        t.excludes(text, 'unity editors', 'no Unity CLI command on the page');
+        t.excludes(text, ' --', 'no flag on the page');
+        const empty = pageLines(unityPage({ ...UNITY_SAMPLE, setUp: false, editors: [], projects: [] })).join('\n');
+        t.includes(empty, 'No sandbox has set Unity up yet', 'nothing set up: the page says so');
+        t.section('the editor bridge');
+        const project = t.dir('bridge', 'Game');
+        t.write(path.join(project, 'ProjectSettings', 'ProjectVersion.txt'), 'm_EditorVersion: 6000.0.58f2\n');
+        const manifest = t.write(path.join(project, 'Packages', 'manifest.json'), MANIFEST);
+        const hooks = {
+            pipelineVersion: () => Promise.resolve('0.10.1'),
+            confirm: () => Promise.resolve(true),
+        };
+        const declined = await addBridgeToProject(project, undefined, { ...hooks, confirm: () => Promise.resolve(false) });
+        t.check(fs.readFileSync(manifest, 'utf8') === MANIFEST && declined.message === 'Nothing was changed.', 'no: nothing changes');
+        const added = await addBridgeToProject(project, undefined, hooks);
+        const after = JSON.parse(fs.readFileSync(manifest, 'utf8'));
+        t.equal(Object.keys(after.dependencies), ['com.unity.ugui', 'com.unity.modules.ai', 'com.unity.pipeline'], 'exactly one dependency is added, the others keep their order');
+        t.check(after.dependencies['com.unity.pipeline'] === '0.10.1', 'the Pipeline version is the one looked up');
+        t.check(bridgeOf(fs.readFileSync(manifest, 'utf8')) === 'pipeline' && added.file === manifest, 'it is the Pipeline bridge');
+        const again = await addBridgeToProject(project, undefined, hooks);
+        t.includes(again.message, 'already', 'adding twice changes nothing');
+        await removeBridgeFromProject(project, hooks);
+        t.check(fs.readFileSync(manifest, 'utf8') === MANIFEST, 'removing restores the bytes');
+        const crlf = MANIFEST.replace(/\n/g, '\r\n');
+        fs.writeFileSync(manifest, crlf);
+        await addBridgeToProject(project, undefined, hooks);
+        await removeBridgeFromProject(project, hooks);
+        t.check(fs.readFileSync(manifest, 'utf8') === crlf, 'a CRLF manifest comes back as it was');
+        const old = t.dir('bridge', 'Old');
+        t.write(path.join(old, 'ProjectSettings', 'ProjectVersion.txt'), 'm_EditorVersion: 2022.3.20f1\n');
+        const oldManifest = t.write(path.join(old, 'Packages', 'manifest.json'), MANIFEST);
+        await addBridgeToProject(old, undefined, hooks);
+        t.check(bridgeOf(fs.readFileSync(oldManifest, 'utf8')) === 'coplay', 'Unity before 6 gets the Coplay bridge');
+        await t.throws(() => addBridgeToProject(t.dir('bridge', 'Old2'), 'pipeline', hooks), /not a Unity project/, 'a folder without ProjectVersion.txt is refused');
+        const old2 = t.dir('bridge', 'Old3');
+        t.write(path.join(old2, 'ProjectSettings', 'ProjectVersion.txt'), 'm_EditorVersion: 2022.3.20f1\n');
+        t.write(path.join(old2, 'Packages', 'manifest.json'), MANIFEST);
+        await t.throws(() => addBridgeToProject(old2, 'pipeline', hooks), /Unity 6/, 'Pipeline is refused before Unity 6');
+        const offline = t.dir('bridge', 'Offline');
+        t.write(path.join(offline, 'ProjectSettings', 'ProjectVersion.txt'), 'm_EditorVersion: 6000.0.58f2\n');
+        const offlineManifest = t.write(path.join(offline, 'Packages', 'manifest.json'), MANIFEST);
+        const fallback = await addBridgeToProject(offline, undefined, {
+            ...hooks,
+            pipelineVersion: () => Promise.reject(new Error('offline')),
+        });
+        t.includes(fallback.message, 'offline', 'no answer from Unity: the bundled version is used and it says so');
+        t.check(bridgeOf(fs.readFileSync(offlineManifest, 'utf8')) === 'pipeline', 'the bridge is still added');
+        t.section('the Pipeline version lookup (a fake registry)');
+        const reply = (body) => () => Promise.resolve(new Response(body));
+        t.check((await latestPipelineVersion(reply(JSON.stringify({ 'dist-tags': { latest: '0.11.0' } })))) === '0.11.0', 'dist-tags.latest is used');
+        await t.throws(() => latestPipelineVersion(reply(JSON.stringify({ 'dist-tags': { latest: '1; rm -rf' } }))), /no usable version/, 'a version that is not semver is refused');
+        await t.throws(() => latestPipelineVersion(reply('x'.repeat(3 * 1024 * 1024))), /over 2 MB/, 'a huge answer is refused');
+    },
+};

package/dist/selftest/unity-setup.test.d.ts

@@ -0,0 +1,2 @@
+import type { Suite } from './support/suite.js';
+export declare const unitySetupSuite: Suite;

package/dist/selftest/unity-setup.test.js

@@ -0,0 +1,49 @@
+// Unity set-up on the data disk: an editor is installed into tools\unity\editors\<version> through ensurePersisted (a
+// fake installer in a temp folder stands in for the Unity CLI), kept, pruned; sbx-unity is gone. Nothing is downloaded.
+import fs from 'node:fs';
+import path from 'node:path';
+import { ensurePersisted } from '../guest/toolchains/persisted.js';
+const GB = 1024 ** 3;
+export const unitySetupSuite = {
+    name: 'unity-setup',
+    title: 'Unity set-up on the data disk: editors kept between sandboxes, no sbx-unity helper',
+    run: async (t) => {
+        t.section('an editor on the data disk');
+        const tools = t.dir('unity-tools');
+        const deps = { toolsDir: tools, statfs: () => ({ bavail: 100 * GB, bsize: 1 }) };
+        const spec = (version) => ({
+            name: 'unity/editors',
+            version,
+            needBytes: 10 * GB,
+            marker: 'Editor\\Unity.exe',
+            what: 'Unity ' + version,
+            keepVersions: 2,
+        });
+        const fake = (version) => async (staging, temp) => {
+            fs.writeFileSync(path.join(temp, 'download.part'), 'x');
+            fs.mkdirSync(path.join(staging, 'Editor'), { recursive: true });
+            fs.writeFileSync(path.join(staging, 'Editor', 'Unity.exe'), 'unity ' + version);
+        };
+        const first = await ensurePersisted(spec('6000.0.58f2'), fake('6000.0.58f2'), deps);
+        t.check(first.fresh && first.dir === path.join(tools, 'unity', 'editors', '6000.0.58f2'), 'the editor goes to tools\\unity\\editors\\<version>');
+        let ran = false;
+        const second = await ensurePersisted(spec('6000.0.58f2'), async () => {
+            ran = true;
+        }, deps);
+        t.check(!second.fresh && !ran, 'a second call finds it and installs nothing');
+        await t.throws(() => ensurePersisted(spec('6000.0.60f1'), async () => {
+            throw new Error('the CLI failed');
+        }, deps), 'the CLI failed', 'a failed install is reported');
+        const editors = path.join(tools, 'unity', 'editors');
+        t.equal(fs.readdirSync(editors).filter((n) => n.startsWith('.staging-')).length, 0, 'a failed install leaves no .staging-* folder');
+        await ensurePersisted(spec('6000.0.59f1'), fake('6000.0.59f1'), deps);
+        await ensurePersisted(spec('6000.1.0f1'), fake('6000.1.0f1'), deps);
+        const kept = fs.readdirSync(editors).sort();
+        t.check(kept.length === 2 && kept.includes('6000.1.0f1') && !kept.includes('6000.0.58f2'), 'keepVersions 2 removes the least recently used editor');
+        t.section('no sbx-unity helper');
+        t.check(!fs.existsSync(path.join(t.packageRoot, 'src', 'guest', 'devtools', 'unity.ts')), 'devtools/unity.ts is gone');
+        const toolJs = path.join(t.packageRoot, 'dist', 'runtime', 'tool.js');
+        t.check(!fs.existsSync(toolJs) ||
+            !fs.readFileSync(toolJs, 'utf8').includes('build with -executeMethod, the licence status'), 'runtime/tool.js has no sbx-unity helper (the setting texts may still name the MCP server)');
+    },
+};