windows-development-sandbox 1.25.1 → 1.27.1

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)');
+    },
+};

package/dist/selftest/unity.test.js

@@ -1,7 +1,242 @@
+// Unity: project versions, the editor choice, the release API, the Unity CLI, the editor bridge, the Asset Store cache,
+// the status, the guide lines and the licence file helpers (pure; nothing is downloaded or run).
+import fs from 'node:fs';
+import { parseLicenceStatus, ulfSummary, UnityPayloadSchema, unityEntitlementFile, unitySummary, unityUlfFile, } from '../shared/accounts/index.js';
+import { isKindReady, isToolchainReady } from '../shared/readiness.js';
+import { assetPackages, bridgeOf, chooseEditor, cliManifestUrl, CliManifestSchema, COPLAY_PACKAGE, COPLAY_PACKAGE_URL, compareUnityVersions, editorModules, editorsAddArgs, installArgs, installModulesArgs, installNeedBytes, installPathArgs, licenceStatusArgs, ORIGIN_LABELS, parseProjectVersion, pcAssetCacheDirs, pickCliBinary, pickRelease, PIPELINE_PACKAGE, releaseUrl, supportsPipeline, UNITY_CLI_ENV, unityCliMcpServer, unityGuideLines, UnityStatusSchema, wantedVersion, withBridge, } from '../shared/unity/index.js';
+const editor = (version, origin, modules = []) => {
+    const root = origin === 'pc' ? 'C:\\PcInstalls\\unity\\' + version : 'C:\\AgentData\\tools\\unity\\editors\\' + version;
+    return { version, root, exe: root + '\\Editor\\Unity.exe', origin, writable: origin === 'data', modules };
+};
+const RELEASE = {
+    results: [
+        {
+            version: '6000.0.58f2',
+            shortRevision: '92dee566b325',
+            downloads: [
+                {
+                    url: 'https://download.unity3d.com/download_unity/92dee566b325/Windows64EditorInstaller/UnitySetup64-6000.0.58f2.exe',
+                    type: 'EXE',
+                    integrity: 'md5-AAAAAAAAAAAAAAAAAAAAAA==',
+                    downloadSize: { value: 4_000_000_000 },
+                    installedSize: { value: 8_000_000_000 },
+                    modules: [
+                        {
+                            id: 'android',
+                            downloadSize: { value: 100 },
+                            installedSize: { value: 200 },
+                            integrity: 'md5-BBBBBBBBBBBBBBBBBBBBBB==',
+                            subModules: [
+                                { id: 'android-sdk-ndk-tools', downloadSize: { value: 10 }, installedSize: { value: 20 } },
+                                { id: 'android-open-jdk', downloadSize: { value: 1 }, installedSize: { value: 2 } },
+                            ],
+                        },
+                        { id: 'webgl', downloadSize: { value: 50 }, installedSize: { value: 60 } },
+                    ],
+                },
+            ],
+        },
+    ],
+};
+const SHA = 'a'.repeat(64);
+function status(over = {}) {
+    return {
+        updatedAt: 'now',
+        cli: { version: '1.0.0-beta.16', path: 'C:\\AgentData\\tools\\unity\\cli\\1.0.0-beta.16\\unity.exe' },
+        editors: [
+            { ...editor('6000.0.58f2', 'pc'), modules: [], sizeBytes: null },
+            { ...editor('2022.3.40f1', 'data'), modules: [], sizeBytes: null },
+        ],
+        projects: [
+            {
+                workspace: 'C:\\Workspace\\G',
+                version: '6000.0.58f2',
+                editor: 'C:\\PcInstalls\\unity\\6000.0.58f2',
+                reason: 'the project asks for 6000.0.58f2',
+                bridge: null,
+            },
+        ],
+        licence: { state: 'active', kind: 'personal', detail: 'Personal', user: null },
+        assetCache: { mode: 'persisted', dir: 'C:\\AgentData\\tools\\unity\\asset-store' },
+        pcAssets: [],
+        hub: { installed: false, path: null },
+        mcp: null,
+        skills: false,
+        problem: null,
+        ...over,
+    };
+}
 export const unitySuite = {
     name: 'unity',
-    title: 'Unity: editors, modules, the release API and the licence (not available yet)',
-    run: (t) => {
-        t.check(true, 'unity: not available yet');
+    title: 'Unity: editors, the release API, the CLI, the editor bridge, the guide and the licence file',
+    run: async (t) => {
+        t.section('ProjectVersion.txt');
+        t.equal(parseProjectVersion('m_EditorVersion: 6000.0.58f2\nm_EditorVersionWithRevision: 6000.0.58f2 (92dee566b325)\n'), { version: '6000.0.58f2', changeset: '92dee566b325' }, 'version and changeset');
+        t.equal(parseProjectVersion('m_EditorVersion: 2022.3.40f1\n'), { version: '2022.3.40f1', changeset: null }, 'without a revision');
+        t.equal(wantedVersion('m_EditorVersion: 2022.3.40f1\n', '6000.0.58f2'), { version: '2022.3.40f1', changeset: null }, "a project's own version wins over the setting");
+        t.equal(wantedVersion(null, '6000.0.58f2'), { version: '6000.0.58f2', changeset: null }, 'the setting is for folders without one');
+        t.equal(wantedVersion(null, 'project'), null, '"project" and no file: nothing');
+        t.equal(parseProjectVersion('m_EditorVersion: 2022.3.40f1\r\nm_EditorVersionWithRevision: 2022.3.40f1 (0123456789ab)\r\n'), { version: '2022.3.40f1', changeset: '0123456789ab' }, 'CRLF');
+        t.equal(parseProjectVersion('hello\nm_EditorVersion: banana\n'), null, 'garbage');
+        t.equal(parseProjectVersion('x'.repeat(70 * 1024) + '\nm_EditorVersion: 6000.0.58f2\n'), null, 'past 64 KB');
+        t.equal(parseProjectVersion('\n'.repeat(60) + 'm_EditorVersion: 6000.0.58f2\n'), null, 'past 50 lines');
+        t.section('versions');
+        t.check(compareUnityVersions('2022.3.9f1', '2022.3.10f1') < 0, 'patch numbers compare as numbers');
+        t.check(compareUnityVersions('6000.0.1f1', '2022.3.40f1') > 0, 'newer major is newer');
+        t.check(compareUnityVersions('6000.0.1b1', '6000.0.1f1') < 0, 'beta before final');
+        t.check(compareUnityVersions('6000.0.1f1', '6000.0.1f1') === 0, 'equal');
+        t.check(supportsPipeline('6000.0.58f2') && !supportsPipeline('2022.3.40f1'), 'the pipeline needs Unity 6');
+        t.section('chooseEditor');
+        const pc = editor('6000.0.58f2', 'pc', ['android']);
+        const data = editor('6000.0.58f2', 'data', ['android', 'webgl']);
+        const other = editor('2022.3.40f1', 'data');
+        const want = { version: '6000.0.58f2', changeset: '92dee566b325' };
+        t.equal(chooseEditor([pc, data], null, [], true).reason, 'no ProjectSettings/ProjectVersion.txt', 'no version file');
+        const a = chooseEditor([pc, data], want, ['android'], true);
+        t.equal([a.editor?.origin, a.reason], ['pc', 'the project asks for 6000.0.58f2'], 'the PC copy first');
+        const b = chooseEditor([pc, data], want, ['android', 'webgl'], true);
+        t.equal([b.editor?.origin, b.reason], ['data', '6000.0.58f2 from this PC lacks webgl; using the data disk copy'], 'the PC copy lacks a module');
+        const c = chooseEditor([other], want, [], true);
+        t.equal([c.editor, c.install, c.reason], [null, want, '6000.0.58f2 is not here yet; installing it on the data disk'], 'install it, never another version');
+        const d = chooseEditor([other], want, [], false);
+        t.equal([d.editor, d.install, d.reason], [
+            null,
+            null,
+            '6000.0.58f2 is not on this PC or the data disk; accept the Unity licence (Unity set-up settings) to install it',
+        ], 'no licence accepted');
+        t.equal(chooseEditor([pc], want, ['webgl'], false).editor?.origin, 'pc', 'a PC copy missing modules beats none');
+        t.section('editorModules');
+        const root = t.dir('editor');
+        const engines = ['Editor', 'Data', 'PlaybackEngines'];
+        t.dir('editor', ...engines, 'AndroidPlayer');
+        t.dir('editor', ...engines, 'windowsstandalonesupport', 'Variations', 'win64_development_il2cpp');
+        t.equal(editorModules(root, { exists: (f) => fs.existsSync(f), list: (d) => fs.readdirSync(d) }), ['android', 'windows-il2cpp'], 'modules found by their folders');
+        t.section('release API');
+        t.includes(releaseUrl('6000.0.58f2'), 'version=6000.0.58f2&platform=WINDOWS', 'release url');
+        t.includes(releaseUrl('a&b'), 'version=a%26b', 'release url encodes');
+        const rel = pickRelease(RELEASE);
+        t.equal(rel?.changeset, '92dee566b325', 'changeset');
+        t.equal(rel?.editor.integrity, 'md5-AAAAAAAAAAAAAAAAAAAAAA==', 'md5 integrity kept');
+        t.equal(rel?.modules[0]?.children, ['android-sdk-ndk-tools', 'android-open-jdk'], 'android children');
+        t.equal(pickRelease({ results: [] }), null, 'no result');
+        t.equal(pickRelease('nope'), null, 'not an object');
+        if (rel) {
+            t.equal(installNeedBytes(rel, []), Math.ceil(12_000_000_000 * 1.1), 'editor only');
+            t.equal(installNeedBytes(rel, ['android']), Math.ceil((12_000_000_000 + 100 + 200 + 11 + 22) * 1.1), 'module and children');
+        }
+        t.section('Unity CLI');
+        t.equal(cliManifestUrl('latest'), 'https://public-cdn.cloud.unity3d.com/hub/prod/cli/latest-beta.json', 'latest');
+        t.equal(cliManifestUrl('1.0.0-beta.16'), 'https://public-cdn.cloud.unity3d.com/hub/prod/cli/1.0.0-beta.16/latest.json', 'pinned');
+        await t.throws(() => cliManifestUrl('../x'), 'not a Unity CLI version', 'a bad version');
+        const manifest = (filename, sha256) => CliManifestSchema.parse({ version: '1.0.0-beta.16', binaries: { 'win32-x64': { filename, sha256, size: 44 } } });
+        t.equal(pickCliBinary(manifest('unity-windows-x64.exe', SHA), 'x64'), {
+            version: '1.0.0-beta.16',
+            url: 'https://public-cdn.cloud.unity3d.com/hub/prod/cli/1.0.0-beta.16/unity-windows-x64.exe',
+            sha256: SHA,
+            size: 44,
+        }, 'the x64 build');
+        t.equal(pickCliBinary(manifest('..\\evil.exe', SHA), 'x64'), null, 'a bad file name');
+        t.equal(pickCliBinary(manifest('unity-windows-x64.exe', 'abc'), 'x64'), null, 'a bad sha');
+        t.equal(pickCliBinary(manifest('unity-windows-x64.exe', SHA), 'arm64'), null, 'no build for this CPU');
+        t.equal(installArgs('6000.0.58f2', '92dee566b325', ['android'], 'C:\\S'), ['install', '6000.0.58f2', '-c', '92dee566b325', '-m', 'android', '--cm', '--download-directory', 'C:\\S'], 'install args');
+        t.equal(installArgs('6000.0.58f2', null, [], 'C:\\S'), ['install', '6000.0.58f2', '--download-directory', 'C:\\S'], 'install args, bare');
+        t.equal(installModulesArgs('6000.0.58f2', ['webgl', 'ios'], 'C:\\S'), ['install-modules', '-e', '6000.0.58f2', '-m', 'webgl', 'ios', '--cm', '--download-directory', 'C:\\S'], 'install-modules args');
+        t.equal(installPathArgs('C:\\E'), ['install-path', '--set', 'C:\\E'], 'install-path args');
+        t.equal(editorsAddArgs(['C:\\A', 'C:\\B']), ['editors', 'add', 'C:\\A', 'C:\\B'], 'editors add args');
+        t.equal(licenceStatusArgs(), ['license', 'status', '--format', 'json'], 'licence status args');
+        t.section('MCP');
+        t.equal(unityCliMcpServer('C:\\u\\unity.exe', 'C:\\Workspace\\G'), {
+            type: 'stdio',
+            command: 'C:\\u\\unity.exe',
+            args: ['mcp', '--cli-tools'],
+            env: { ...UNITY_CLI_ENV, UNITY_PROJECT_PATH: 'C:\\Workspace\\G' },
+        }, 'with a project');
+        t.equal(unityCliMcpServer('u', null).env, { ...UNITY_CLI_ENV }, 'without a project');
+        t.section('Packages/manifest.json');
+        const manifestText = JSON.stringify({ dependencies: { 'com.a': '1.0.0', 'com.b': '2.0.0' }, scopedRegistries: [] }, null, 2) + '\n';
+        for (const bridge of ['pipeline', 'coplay']) {
+            const on = withBridge(manifestText, bridge, true);
+            t.equal(bridgeOf(on), bridge, bridge + ' added');
+            t.equal(Object.keys(JSON.parse(on).dependencies).slice(0, 2), ['com.a', 'com.b'], bridge + ': order kept');
+            t.equal(withBridge(on, bridge, false), manifestText, bridge + ': removed again, byte for byte');
+        }
+        t.equal(JSON.parse(withBridge(manifestText, 'pipeline', true, '0.11.0')).dependencies[PIPELINE_PACKAGE], '0.11.0', 'pipeline version');
+        t.equal(JSON.parse(withBridge(manifestText, 'coplay', true)).dependencies[COPLAY_PACKAGE], COPLAY_PACKAGE_URL, 'coplay url');
+        const crlf = withBridge(manifestText.replace(/\n/g, '\r\n'), 'pipeline', true);
+        t.check(crlf.includes('\r\n') && !/[^\r]\n/.test(crlf), 'CRLF kept');
+        t.equal(bridgeOf('not json'), null, 'garbage has no bridge');
+        t.equal(bridgeOf(manifestText), null, 'no bridge');
+        await t.throws(() => withBridge('[]', 'pipeline', true), 'not an object', 'refuses an array');
+        await t.throws(() => withBridge('{"a":"' + 'x'.repeat(1024 * 1024) + '"}', 'pipeline', true), 'over 1 MB', 'refuses a big file');
+        await t.throws(() => withBridge(manifestText, 'pipeline', true, '1.0; rm'), 'not a package version', 'bad version');
+        t.section('Asset Store cache');
+        const dirs = new Set(['C:\\Env\\Asset Store-5.x', 'C:\\Users\\u\\AppData\\Roaming\\Unity\\Asset Store-5.x']);
+        const isDir = (d) => dirs.has(d);
+        t.equal(pcAssetCacheDirs({ appData: 'C:\\Users\\u\\AppData\\Roaming', envValue: 'C:\\Env' }, isDir), ['C:\\Env', 'C:\\Users\\u\\AppData\\Roaming\\Unity'], 'the environment first');
+        t.equal(pcAssetCacheDirs({ appData: 'C:\\Users\\u\\AppData\\Roaming' }, isDir), ['C:\\Users\\u\\AppData\\Roaming\\Unity'], 'the default');
+        t.equal(pcAssetCacheDirs({ appData: 'C:\\X' }, isDir), [], 'none');
+        const tree = {
+            R: ['Pub', 'file.txt'],
+            'R\\Pub': ['Cat'],
+            'R\\Pub\\Cat': ['a.unitypackage', 'b.txt'],
+        };
+        const assetFs = {
+            list: (d) => tree[d] ?? [],
+            isDir: (d) => d in tree,
+            size: (f) => (f.endsWith('.unitypackage') ? 7 : null),
+        };
+        t.equal(assetPackages('R', assetFs), [{ publisher: 'Pub', category: 'Cat', name: 'a', sizeBytes: 7 }], 'packages');
+        const many = {
+            R: ['P'],
+            'R\\P': ['C'],
+            'R\\P\\C': Array.from({ length: 2500 }, (_, i) => 'p' + i + '.unitypackage'),
+        };
+        t.equal(assetPackages('R', { ...assetFs, list: (d) => many[d] ?? [], isDir: (d) => d in many }).length, 2000, 'at most 2000');
+        t.section('status');
+        const good = status();
+        t.check(UnityStatusSchema.safeParse(good).success, 'a status parses');
+        t.check(!UnityStatusSchema.safeParse({ ...good, editors: Array.from({ length: 33 }, () => good.editors[0]) }).success, '33 editors are refused');
+        t.section('guide');
+        const lines = (s) => unityGuideLines(s, [{ workspace: 'C:\\Workspace\\G' }]).join('\n');
+        const exe = '"C:\\PcInstalls\\unity\\6000.0.58f2\\Editor\\Unity.exe"';
+        t.equal(unityGuideLines(good, [{ workspace: 'C:\\Workspace\\G' }])[0], '- Unity: editor 6000.0.58f2 at `C:\\PcInstalls\\unity\\6000.0.58f2\\Editor\\Unity.exe` (' +
+            ORIGIN_LABELS.pc +
+            '; the project asks for 6000.0.58f2). Build or run code without opening it: `' +
+            exe +
+            ' -batchmode -nographics -quit -projectPath "C:\\Workspace\\G" -executeMethod <Class.Method> -logFile -`; tests: `-runTests -testPlatform EditMode -testResults <file>` (without -quit). Opening the project in another Unity version upgrades its files: never do that without asking the user. It is the user\'s PC copy, read-only: never add modules to it.', 'PC read-only line');
+        const onData = lines(status({
+            projects: [{ ...good.projects[0], editor: 'C:\\AgentData\\tools\\unity\\editors\\2022.3.40f1' }],
+        }));
+        t.includes(onData, '(' + ORIGIN_LABELS.data + ';', 'data origin label');
+        t.excludes(onData, 'read-only: never add modules', 'a data editor has no read-only note');
+        t.includes(lines(good), '- `unity` (Unity CLI 1.0.0-beta.16) is on PATH: `unity editors -i`, `unity build`, `unity test`, `unity open <project>` (opens it signed in).', 'CLI line');
+        t.includes(lines(good), "- To drive a running editor (scenes, GameObjects, play mode) the project needs an editor bridge package: ask the user to add it on the sandbox tool's Unity page. Never change Packages/manifest.json yourself unless asked.", 'no bridge');
+        const bridged = (bridge) => lines(status({ projects: [{ ...good.projects[0], bridge }] }));
+        t.includes(bridged('pipeline'), '- The open editor can be driven with `unity command` and `unity eval` (Unity Pipeline package); MCP clients use sbx-unity.', 'pipeline');
+        t.includes(bridged('coplay'), '- The open editor can be driven with MCP for Unity (sbx-unity-mcp in Apps).', 'coplay');
+        t.excludes(bridged('pipeline'), 'needs an editor bridge', 'no bridge line when there is one');
+        t.includes(lines(status({ pcAssets: ['C:\\PcInstalls\\unity\\AssetStore'] })), "- The user's Unity Asset Store downloads (read-only): `C:\\PcInstalls\\unity\\AssetStore`; import one with the editor closed:", 'assets');
+        t.includes(lines(status({ licence: { state: 'none', kind: '', detail: 'no licence', user: null } })), "- Unity licence: no licence. Batch mode fails without one: ask the user to sign in to Unity on the sandbox tool's Unity page.", 'no licence');
+        t.equal(unityGuideLines(good, [{ workspace: 'C:\\Elsewhere' }]), [], 'nothing for a project Unity has no word on');
+        t.section('licence files');
+        t.equal(unityUlfFile('C:\\ProgramData'), 'C:\\ProgramData\\Unity\\Unity_lic.ulf', 'ulf path');
+        t.equal(unityEntitlementFile('C:\\Users\\u\\AppData\\Local'), 'C:\\Users\\u\\AppData\\Local\\Unity\\licenses\\UnityEntitlementLicense.xml', 'entitlement path');
+        const ulf = '<?xml version="1.0" encoding="UTF-8"?>\r\n<root>\r\n  <License id="Terms">\r\n    <SerialMasked Value="U3-XXXX-XXXX-XXXX-XXXX-XXXX" />\r\n    <UpdateDate Value="2026-10-01T10:00:00" />\r\n  </License>\r\n</root>';
+        t.equal(ulfSummary(ulf), { serialMasked: 'U3-XXXX-XXXX-XXXX-XXXX-XXXX', updated: '2026-10-01T10:00:00', kind: 'personal' }, 'personal ulf');
+        t.equal(ulfSummary(ulf.replace('U3-', 'F4-'))?.kind, 'paid', 'paid ulf');
+        t.equal(ulfSummary('hello'), null, 'not a ulf');
+        t.equal(unitySummary({ email: 'me@x.com', password: 'hunter2hunter2' }), 'me@x.com', 'the email');
+        t.excludes(unitySummary({ email: 'me@x.com', password: 'hunter2hunter2', serial: 'SECRET' }), 'hunter2', 'no password in the summary');
+        t.equal(unitySummary({ ulf }), 'licence file (Personal)', 'a personal file');
+        t.equal(unitySummary({ ulf: ulf.replace('U3-', 'F4-') }), 'licence file (Plus or Pro)', 'a paid file');
+        t.check(!UnityPayloadSchema.safeParse({}).success, 'an empty sign-in is refused');
+        t.check(UnityPayloadSchema.safeParse({ entitlement: '<x/>' }).success, 'an entitlement alone is a sign-in');
+        t.equal(parseLicenceStatus({ weird: true }).state, 'unknown', 'an unknown shape is unknown');
+        t.equal(parseLicenceStatus('text').state, 'unknown', 'text is unknown');
+        t.equal(parseLicenceStatus(null).state, 'unknown', 'null is unknown');
+        t.equal(parseLicenceStatus({ licenses: [] }).state, 'none', 'no licences');
+        t.equal(parseLicenceStatus({ status: 'active', type: 'Personal' }).state, 'active', 'active');
+        t.section('readiness');
+        t.check(isToolchainReady('unity') && isKindReady('unity'), 'Unity is offered');
     },
 };

package/dist/shared/accounts/index.d.ts

@@ -3,6 +3,7 @@ export * from './payloads.js';
 export { fingerprint } from './fingerprint.js';
 export { epicSettingsFile, epicSettingsFiles, MAX_EPIC_INI_BYTES, readEpicLogin, withEpicLogin, type EpicPayload, } from './kinds/epic.js';
 export * from './kinds/steam.js';
+export * from './kinds/unity.js';
 export { PERPLEXITY_ENV, perplexityKeyFromText, perplexitySummary, type PerplexityPayload, } from './kinds/perplexity.js';
 export { cometPayloadFromCookies, cometSummary, cookiesToRestore, type CometPayload } from './kinds/comet.js';
 export * from './anthropic.js';

package/dist/shared/accounts/index.js

@@ -5,6 +5,7 @@ export * from './payloads.js';
 export { fingerprint } from './fingerprint.js';
 export { epicSettingsFile, epicSettingsFiles, MAX_EPIC_INI_BYTES, readEpicLogin, withEpicLogin, } from './kinds/epic.js';
 export * from './kinds/steam.js';
+export * from './kinds/unity.js';
 export { PERPLEXITY_ENV, perplexityKeyFromText, perplexitySummary, } from './kinds/perplexity.js';
 export { cometPayloadFromCookies, cometSummary, cookiesToRestore } from './kinds/comet.js';
 export * from './anthropic.js';

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

@@ -0,0 +1,28 @@
+import type { Payload } from '../payloads.js';
+export type UnityPayload = Payload<'unity'>;
+/** The licence files' size limit (the payload's). */
+export declare const MAX_ULF_BYTES: number;
+/** %PROGRAMDATA%\Unity\Unity_lic.ulf */
+export declare function unityUlfFile(programData: string): string;
+/** %LOCALAPPDATA%\Unity\licenses\UnityEntitlementLicense.xml */
+export declare function unityEntitlementFile(localAppData: string): string;
+export interface UlfSummary {
+    /** The serial as Unity masks it in the file (XXXX-...), never a full one. */
+    readonly serialMasked: string | null;
+    readonly updated: string | null;
+    readonly kind: 'personal' | 'paid' | 'unknown';
+}
+/** What a Unity_lic.ulf says (its SerialMasked and UpdateDate), or null when it holds neither. */
+export declare function ulfSummary(text: string): UlfSummary | null;
+/** One line for the status: the Unity ID, else what kind of licence file it is. Never a secret. */
+export declare function unitySummary(p: UnityPayload): string;
+export interface LicenceStatus {
+    readonly state: 'active' | 'none' | 'unknown';
+    readonly kind: string;
+    readonly detail: string;
+}
+/**
+ * What `unity license status --format json` printed. The shape is not documented (checked against the docs, not a live
+ * run), so anything unrecognised is 'unknown', never a guess.
+ */
+export declare function parseLicenceStatus(json: unknown): LicenceStatus;

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

@@ -0,0 +1,88 @@
+// Unity's licence files and what they say, without secrets: the serial licence (Unity_lic.ulf), the named-user licence
+// (UnityEntitlementLicense.xml) and the answer of `unity license status`. Pure text handling, every scan bounded.
+import path from 'node:path';
+/** The licence files' size limit (the payload's). */
+export const MAX_ULF_BYTES = 128 * 1024;
+const MAX_LINES = 4000;
+const MAX_FIELD = 200;
+/** %PROGRAMDATA%\Unity\Unity_lic.ulf */
+export function unityUlfFile(programData) {
+    return path.win32.join(programData, 'Unity', 'Unity_lic.ulf');
+}
+/** %LOCALAPPDATA%\Unity\licenses\UnityEntitlementLicense.xml */
+export function unityEntitlementFile(localAppData) {
+    return path.win32.join(localAppData, 'Unity', 'licenses', 'UnityEntitlementLicense.xml');
+}
+/** The value of `<Name Value="..."/>` on one line, by index scan (no backtracking). */
+function valueOf(line, name) {
+    const at = line.indexOf('<' + name);
+    if (at < 0)
+        return null;
+    const key = line.indexOf('Value="', at);
+    if (key < 0)
+        return null;
+    const from = key + 7;
+    const end = line.indexOf('"', from);
+    if (end < 0 || end - from > MAX_FIELD)
+        return null;
+    return line.slice(from, end);
+}
+/** What a Unity_lic.ulf says (its SerialMasked and UpdateDate), or null when it holds neither. */
+export function ulfSummary(text) {
+    let serialMasked = null;
+    let updated = null;
+    const lines = text.slice(0, MAX_ULF_BYTES).split('\n', MAX_LINES);
+    for (const line of lines) {
+        serialMasked ??= valueOf(line, 'SerialMasked');
+        updated ??= valueOf(line, 'UpdateDate');
+        if (serialMasked !== null && updated !== null)
+            break;
+    }
+    if (serialMasked === null && updated === null)
+        return null;
+    const kind = serialMasked === null ? 'unknown' : serialMasked.startsWith('U3-') ? 'personal' : 'paid';
+    return { serialMasked, updated, kind };
+}
+/** One line for the status: the Unity ID, else what kind of licence file it is. Never a secret. */
+export function unitySummary(p) {
+    if (p.email)
+        return p.email;
+    if (p.ulf) {
+        const kind = ulfSummary(p.ulf)?.kind;
+        return kind === 'personal' ? 'licence file (Personal)' : 'licence file (Plus or Pro)';
+    }
+    if (p.entitlement)
+        return 'licence file (Personal)';
+    return 'serial';
+}
+function text(v) {
+    return typeof v === 'string' ? v.slice(0, MAX_FIELD) : '';
+}
+/**
+ * What `unity license status --format json` printed. The shape is not documented (checked against the docs, not a live
+ * run), so anything unrecognised is 'unknown', never a guess.
+ */
+export function parseLicenceStatus(json) {
+    const unknown = { state: 'unknown', kind: '', detail: 'not recognised' };
+    if (typeof json !== 'object' || json === null || Array.isArray(json))
+        return unknown;
+    const o = json;
+    const licences = Array.isArray(o.licenses)
+        ? o.licenses
+        : Array.isArray(o.licences)
+            ? o.licences
+            : null;
+    if (licences !== null) {
+        if (!licences.length)
+            return { state: 'none', kind: '', detail: 'no licence' };
+        const first = licences[0];
+        const f = typeof first === 'object' && first !== null ? first : {};
+        return { state: 'active', kind: text(f.type ?? f.kind), detail: text(f.detail ?? f.name ?? f.status) };
+    }
+    const status = text(o.status ?? o.state).toLowerCase();
+    if (status === 'active' || status === 'activated' || status === 'valid')
+        return { state: 'active', kind: text(o.type ?? o.kind), detail: text(o.detail ?? o.message) || status };
+    if (status === 'none' || status === 'inactive' || status === 'not activated' || status === 'unlicensed')
+        return { state: 'none', kind: '', detail: text(o.detail ?? o.message) || status };
+    return unknown;
+}