windows-development-sandbox 1.25.1 → 1.27.0

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;
+}

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

@@ -1,9 +1,9 @@
-export declare const SERVICE_KINDS: readonly ["epic", "steam", "unity", "cfx", "keystore", "play", "expo", "appstore", "perplexity", "comet"];
+export declare const SERVICE_KINDS: readonly ["epic", "steam", "unity", "cfx", "keystore", "play", "expo", "appstore", "perplexity", "comet", "perplexityapp"];
 export type ServiceKind = (typeof SERVICE_KINDS)[number];
 /** The toolchains a sign-in can serve (each is a key of `toolchains`). */
 export type ToolchainUser = 'unreal' | 'steam' | 'unity' | 'fivem' | 'android' | 'flutter' | 'reactNative' | 'godot' | 'dotnet';
 /** The apps a sign-in can serve: on when one of APP_USERS' apps is in apps.install. */
-export type AppUser = 'perplexity' | 'comet';
+export type AppUser = 'perplexity' | 'comet' | 'perplexityapp';
 /** What a sign-in serves (it is handed over only when one of them is on for the boot). */
 export type UsedBy = ToolchainUser | AppUser;
 /** The toolchains a sign-in can serve. */

package/dist/shared/accounts/kinds.js

@@ -13,6 +13,7 @@ export const SERVICE_KINDS = [
     'appstore',
     'perplexity',
     'comet',
+    'perplexityapp',
 ];
 /** The toolchains a sign-in can serve. */
 export const USED_BY = [
@@ -30,6 +31,7 @@ export const USED_BY = [
 export const APP_USERS = {
     perplexity: ['perplexity-mcp'],
     comet: ['comet'],
+    perplexityapp: ['perplexity-desktop'],
 };
 export const ACCOUNT_SOURCES = ['pc', 'file', 'typed', 'sandbox'];
 const AGENT_CAN_USE = 'The agent in the sandbox can use this sign-in while it is there.';
@@ -77,7 +79,9 @@ export const SERVICE_SPECS = {
         warnings: [
             AGENT_CAN_USE,
             ONE_PLACE,
-            'A Pro seat is handed back when the sandbox stops cleanly; a sandbox closed abruptly may keep it until you return it.',
+            'Unity Personal is activated by signing in: sign in to Unity once in a sandbox and the licence it makes is kept for the next ones (if Unity refuses it there, sign in again).',
+            'A Plus or Pro serial is activated in each sandbox and handed back when the sandbox stops cleanly; a sandbox closed abruptly may keep the seat until you remove it at id.unity.com (My Seats).',
+            'A licence file taken from this PC may not work in a sandbox: Unity ties it to the computer.',
         ],
         fields: [
             { name: 'email', label: 'Unity ID email', secret: false, optional: true },
@@ -206,6 +210,23 @@ export const SERVICE_SPECS = {
         ],
         fields: [],
     },
+    perplexityapp: {
+        kind: 'perplexityapp',
+        label: 'Perplexity desktop app',
+        usedBy: ['perplexityapp'],
+        sources: ['sandbox'],
+        singleHolder: false,
+        returns: true,
+        maxBytes: 256 * 1024,
+        warnings: [
+            AGENT_CAN_USE +
+                ' It can act as you in the Perplexity app and spend your Perplexity Computer credits; the app acts on the pages it reads, which can try to steer it.',
+            "Your sign-in in the Perplexity app can't be copied from this PC: Windows locks it to your PC account. Sign in once inside a sandbox and it is kept for the next ones.",
+            'Only the perplexity.ai sign-in cookies are kept: never saved passwords, other sites, localStorage or history.',
+            'Several sandboxes can use it at once: the sign-in the last one hands back is kept.',
+        ],
+        fields: [],
+    },
 };
 /** Where a sandbox leaves a renewed sign-in, under the data folder: state\accounts\<kind>.json. */
 export const HANDOFF_PARTS = ['state', 'accounts'];
@@ -218,6 +239,7 @@ export function isServiceKind(value) {
 const APP_USER_TEXT = {
     perplexity: 'the Perplexity MCP app',
     comet: 'the Comet app',
+    perplexityapp: 'the Perplexity desktop app',
 };
 /** What a sign-in serves, for a sentence: "unreal", "reactNative or flutter", "the Comet app". */
 export function usedByText(usedBy) {

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

@@ -17,6 +17,7 @@ export declare const SteamPayloadSchema: z.ZodObject<{
 /** A Unity licence file (Unity_lic.ulf), and the Unity ID to sign in with when it has to be made again. */
 export declare const UnityPayloadSchema: z.ZodObject<{
     ulf: z.ZodOptional<z.ZodString>;
+    entitlement: z.ZodOptional<z.ZodString>;
     email: z.ZodOptional<z.ZodString>;
     password: z.ZodOptional<z.ZodString>;
     serial: z.ZodOptional<z.ZodString>;
@@ -91,6 +92,23 @@ export declare const CometPayloadSchema: z.ZodObject<{
         }>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
+/** The Perplexity desktop app's sign-in: the same perplexity.ai cookies as Comet's. */
+export declare const PerplexityAppPayloadSchema: z.ZodObject<{
+    cookies: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+        domain: z.ZodString;
+        path: z.ZodString;
+        expires: z.ZodOptional<z.ZodNumber>;
+        secure: z.ZodBoolean;
+        httpOnly: z.ZodBoolean;
+        sameSite: z.ZodOptional<z.ZodEnum<{
+            Strict: "Strict";
+            Lax: "Lax";
+            None: "None";
+        }>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
 export declare const PAYLOADS: {
     readonly epic: z.ZodObject<{
         data: z.ZodString;
@@ -106,6 +124,7 @@ export declare const PAYLOADS: {
     }, z.core.$strict>;
     readonly unity: z.ZodObject<{
         ulf: z.ZodOptional<z.ZodString>;
+        entitlement: z.ZodOptional<z.ZodString>;
         email: z.ZodOptional<z.ZodString>;
         password: z.ZodOptional<z.ZodString>;
         serial: z.ZodOptional<z.ZodString>;
@@ -151,6 +170,22 @@ export declare const PAYLOADS: {
             }>>;
         }, z.core.$strict>>;
     }, z.core.$strict>;
+    readonly perplexityapp: z.ZodObject<{
+        cookies: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodString;
+            domain: z.ZodString;
+            path: z.ZodString;
+            expires: z.ZodOptional<z.ZodNumber>;
+            secure: z.ZodBoolean;
+            httpOnly: z.ZodBoolean;
+            sameSite: z.ZodOptional<z.ZodEnum<{
+                Strict: "Strict";
+                Lax: "Lax";
+                None: "None";
+            }>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
 };
 export type Payload<K extends ServiceKind> = z.output<(typeof PAYLOADS)[K]>;
 export type AnyPayload = Payload<ServiceKind>;
@@ -173,6 +208,7 @@ export declare const ServiceAccountsSchema: z.ZodObject<{
     }, z.core.$strict>>;
     unity: z.ZodOptional<z.ZodObject<{
         ulf: z.ZodOptional<z.ZodString>;
+        entitlement: z.ZodOptional<z.ZodString>;
         email: z.ZodOptional<z.ZodString>;
         password: z.ZodOptional<z.ZodString>;
         serial: z.ZodOptional<z.ZodString>;
@@ -218,6 +254,22 @@ export declare const ServiceAccountsSchema: z.ZodObject<{
             }>>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
+    perplexityapp: z.ZodOptional<z.ZodObject<{
+        cookies: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodString;
+            domain: z.ZodString;
+            path: z.ZodString;
+            expires: z.ZodOptional<z.ZodNumber>;
+            secure: z.ZodBoolean;
+            httpOnly: z.ZodBoolean;
+            sameSite: z.ZodOptional<z.ZodEnum<{
+                Strict: "Strict";
+                Lax: "Lax";
+                None: "None";
+            }>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export type ServiceAccounts = z.output<typeof ServiceAccountsSchema>;
 /** A launch's id (generate.ts: "<ms>-<6 hex>"). */

package/dist/shared/accounts/payloads.js

@@ -33,16 +33,24 @@ export const SteamPayloadSchema = z.strictObject({
     client: base64(256 * KB).optional(),
 });
 /** A Unity licence file (Unity_lic.ulf), and the Unity ID to sign in with when it has to be made again. */
-export const UnityPayloadSchema = z.strictObject({
+export const UnityPayloadSchema = z
+    .strictObject({
     ulf: z
         .string()
         .min(1)
         .max(128 * KB)
         .optional(),
+    /** The named-user licence (UnityEntitlementLicense.xml) a Unity sign-in makes. */
+    entitlement: z
+        .string()
+        .min(1)
+        .max(128 * KB)
+        .optional(),
     email: z.string().email().max(256).optional(),
     password: secretText(1024).optional(),
     serial: secretText(64).optional(),
-});
+})
+    .refine((p) => Object.keys(p).length > 0, 'empty Unity sign-in');
 /** A FiveM / RedM server licence key from the Cfx.re keymaster, and an optional Steam Web API key. */
 export const CfxPayloadSchema = z.strictObject({
     licenseKey: z
@@ -125,6 +133,8 @@ export const CometCookieSchema = z.strictObject({
 export const CometPayloadSchema = z.strictObject({
     cookies: z.array(CometCookieSchema).min(1).max(MAX_COMET_COOKIES),
 });
+/** The Perplexity desktop app's sign-in: the same perplexity.ai cookies as Comet's. */
+export const PerplexityAppPayloadSchema = CometPayloadSchema;
 export const PAYLOADS = {
     epic: EpicPayloadSchema,
     steam: SteamPayloadSchema,
@@ -136,6 +146,7 @@ export const PAYLOADS = {
     appstore: AppstorePayloadSchema,
     perplexity: PerplexityPayloadSchema,
     comet: CometPayloadSchema,
+    perplexityapp: PerplexityAppPayloadSchema,
 };
 /** The secrets-file field: the sign-ins this launch hands over, each optional. */
 export const ServiceAccountsSchema = z.strictObject({
@@ -149,6 +160,7 @@ export const ServiceAccountsSchema = z.strictObject({
     appstore: AppstorePayloadSchema.optional(),
     perplexity: PerplexityPayloadSchema.optional(),
     comet: CometPayloadSchema.optional(),
+    perplexityapp: PerplexityAppPayloadSchema.optional(),
 });
 /** A launch's id (generate.ts: "<ms>-<6 hex>"). */
 export const LaunchIdSchema = z.string().regex(/^[A-Za-z0-9-]{1,64}$/);

package/dist/shared/apps/catalogue-agents-web.d.ts

@@ -14,4 +14,11 @@ export declare const COMET_DOWNLOAD_URL = "https://www.perplexity.ai/rest/browse
  * subject with E=<contact address> first (E=..., CN="PERPLEXITY AI, INC.", O=...), so CN is not at the start.
  */
 export declare const COMET_SIGNER: AppSigner;
+/**
+ * The Perplexity desktop app is Store-only (its old installer is gone): product 9P9XG917PWCJ, an MSIX of about 300 MB.
+ * The package is fetched on this PC with your own Store tooling and installed in the sandbox with Add-AppxPackage.
+ */
+export declare const PERPLEXITY_DESKTOP_PRODUCT_ID = "9P9XG917PWCJ";
+export declare const PERPLEXITY_DESKTOP_PACKAGE = "PerplexityAI.PerplexityApp";
+export declare const PERPLEXITY_DESKTOP_FAMILY = "PerplexityAI.PerplexityApp_3jh4kjrg4dzr2";
 export declare const AGENTS_WEB_APPS: readonly AppEntry[];