windows-development-sandbox 1.25.0 → 1.27.0

package/dist/shared/readiness.js

@@ -2,10 +2,9 @@
 // entries here (the end of round 2 leaves it empty). Pure.
 export const NOT_READY = {
     /** Toolchains whose step is a stub: their settings rows are hidden and "auto" never turns them on. */
-    toolchains: ['unity', 'godot', 'android', 'flutter', 'dart', 'reactNative'],
+    toolchains: ['godot', 'android', 'flutter', 'dart', 'reactNative'],
     /** Service sign-ins whose host or guest side is a stub: the menu and the web do not list them. */
-    kinds: ['unity', 'keystore', 'play', 'expo', 'appstore'],
-    unreal: ['engines'],
+    kinds: ['keystore', 'play', 'expo', 'appstore'],
 };
 export const isToolchainReady = (name) => !NOT_READY.toolchains.includes(name);
 export const isKindReady = (kind) => !NOT_READY.kinds.includes(kind);

package/dist/shared/signer.d.ts

@@ -21,4 +21,8 @@ export declare const SIGNERS: {
     readonly unity: {
         readonly subject: readonly ["^CN=\"?Unity Technologies"];
     };
+    /** The Epic Games Launcher's MSI (checked on EpicInstaller-20.3.3.msi). */
+    readonly epic: {
+        readonly subject: readonly ["^CN=Epic Games Inc\\., O=Epic Games Inc\\., L=Cary, S=North Carolina, C=US"];
+    };
 };

package/dist/shared/signer.js

@@ -12,4 +12,6 @@ export const SIGNERS = {
     microsoft: { subject: ['^CN=Microsoft Corporation, O=Microsoft Corporation, L=Redmond, S=Washington, C=US$'] },
     valve: { subject: ['^CN="?Valve(,| Corp)'] },
     unity: { subject: ['^CN="?Unity Technologies'] },
+    /** The Epic Games Launcher's MSI (checked on EpicInstaller-20.3.3.msi). */
+    epic: { subject: ['^CN=Epic Games Inc\\., O=Epic Games Inc\\., L=Cary, S=North Carolina, C=US'] },
 };

package/dist/shared/unity/asset-cache.d.ts

@@ -0,0 +1,20 @@
+export declare function assetStoreDir(root: string): string;
+/** The cache roots of this PC that hold an Asset Store-5.x folder: the environment's first, then %APPDATA%\Unity. */
+export declare function pcAssetCacheDirs(pc: {
+    readonly appData: string;
+    readonly envValue?: string | undefined;
+}, isDir: (dir: string) => boolean): string[];
+export interface AssetFs {
+    list(dir: string): string[];
+    isDir(dir: string): boolean;
+    /** A file's size, or null when it is a folder or missing. */
+    size(file: string): number | null;
+}
+export interface AssetPackage {
+    readonly publisher: string;
+    readonly category: string;
+    readonly name: string;
+    readonly sizeBytes: number;
+}
+/** The .unitypackage files in an Asset Store-5.x folder (three levels deep), sorted, at most 2000. */
+export declare function assetPackages(dir: string, fs: AssetFs): AssetPackage[];

package/dist/shared/unity/asset-cache.js

@@ -0,0 +1,44 @@
+// The Unity Asset Store's download cache: <root>\Asset Store-5.x\<publisher>\<category>\<name>.unitypackage. The root
+// is ASSETSTORE_CACHE_PATH, else %APPDATA%\Unity. Pure apart from the reads it is given; every walk is bounded.
+import path from 'node:path';
+const win = path.win32;
+const MAX_PACKAGES = 2000;
+const MAX_ROOTS = 2;
+export function assetStoreDir(root) {
+    return root + '\\Asset Store-5.x';
+}
+/** The cache roots of this PC that hold an Asset Store-5.x folder: the environment's first, then %APPDATA%\Unity. */
+export function pcAssetCacheDirs(pc, isDir) {
+    const all = [pc.envValue?.trim() ?? '', pc.appData ? win.join(pc.appData, 'Unity') : ''].filter(Boolean);
+    return all
+        .map((d) => win.normalize(d).replace(/\\+$/, ''))
+        .filter((d, i, a) => a.findIndex((o) => o.toLowerCase() === d.toLowerCase()) === i)
+        .filter((d) => isDir(assetStoreDir(d)))
+        .slice(0, MAX_ROOTS);
+}
+/** The .unitypackage files in an Asset Store-5.x folder (three levels deep), sorted, at most 2000. */
+export function assetPackages(dir, fs) {
+    const found = [];
+    const sorted = (d) => fs.list(d).sort((a, b) => a.localeCompare(b));
+    for (const publisher of sorted(dir)) {
+        const pdir = win.join(dir, publisher);
+        if (!fs.isDir(pdir))
+            continue;
+        for (const category of sorted(pdir)) {
+            const cdir = win.join(pdir, category);
+            if (!fs.isDir(cdir))
+                continue;
+            for (const file of sorted(cdir)) {
+                if (!/\.unitypackage$/i.test(file))
+                    continue;
+                const size = fs.size(win.join(cdir, file));
+                if (size === null)
+                    continue;
+                found.push({ publisher, category, name: file.replace(/\.unitypackage$/i, ''), sizeBytes: size });
+                if (found.length >= MAX_PACKAGES)
+                    return found;
+            }
+        }
+    }
+    return found;
+}

package/dist/shared/unity/cli.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+export declare const UNITY_CLI_CDN = "https://public-cdn.cloud.unity3d.com/hub/prod/cli";
+export declare const DEFAULT_UNITY_CLI = "1.0.0-beta.16";
+/** The manifest of a CLI version: "latest" is the newest beta, else that version's own latest.json. */
+export declare function cliManifestUrl(version: string): string;
+export declare const CliManifestSchema: z.ZodObject<{
+    version: z.ZodString;
+    binaries: z.ZodRecord<z.ZodString, z.ZodObject<{
+        filename: z.ZodString;
+        sha256: z.ZodString;
+        size: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CliManifest = z.infer<typeof CliManifestSchema>;
+export interface CliBinary {
+    readonly version: string;
+    readonly url: string;
+    readonly sha256: string;
+    readonly size: number;
+}
+/** The Windows build for this CPU, or null when the manifest has none or its file name or hash is unexpected. */
+export declare function pickCliBinary(m: CliManifest, arch: 'x64' | 'arm64'): CliBinary | null;
+/** No telemetry, hints, pager, elevation prompt or first-run set-up (the skills are synced by us when asked). */
+export declare const UNITY_CLI_ENV: {
+    readonly UNITY_NO_CLI_INVOKED_TELEMETRY: "1";
+    readonly UNITY_NO_AGENT_HINTS: "1";
+    readonly UNITY_CLI_SKIP_SETUP: "1";
+    readonly UNITY_NO_PAGER: "1";
+    readonly UNITY_NO_ELEVATE: "1";
+};
+/** `unity install <version> -c <changeset> -m <ids> --cm`. --download-directory is not in the docs: from the plan. */
+export declare function installArgs(version: string, changeset: string | null, modules: readonly string[], dir: string): string[];
+/** `unity install-modules -e <version> -m <ids> --cm`. --download-directory is not in the docs: from the plan. */
+export declare function installModulesArgs(version: string, modules: readonly string[], dir: string): string[];
+/** Where the CLI installs editors. `--set` is not in the docs (they say "run install-path --help"): from the plan. */
+export declare function installPathArgs(dir: string): string[];
+/** `unity editors add <path...>` registers editors installed outside the Hub (the docs pass their folders). */
+export declare function editorsAddArgs(exes: readonly string[]): string[];
+/** `unity license status` is not in the docs; --format json is the global output option. */
+export declare function licenceStatusArgs(): string[];

package/dist/shared/unity/cli.js

@@ -0,0 +1,77 @@
+// The Unity CLI (`unity`): where its pinned build is published, how a download is checked, the environment it runs in
+// and the argument lists we pass it. The flags below are checked against the docs
+// (docs.unity.com/en-us/unity-cli/reference), not a live run; the ones the docs do not settle are marked.
+import { z } from 'zod';
+export const UNITY_CLI_CDN = 'https://public-cdn.cloud.unity3d.com/hub/prod/cli';
+export const DEFAULT_UNITY_CLI = '1.0.0-beta.16';
+const CLI_VERSION = /^\d+\.\d+\.\d+(-[A-Za-z0-9.]+)?$/;
+const CLI_FILE = /^unity-windows-(x64|arm64)\.exe$/;
+const SHA256 = /^[0-9a-f]{64}$/i;
+/** The manifest of a CLI version: "latest" is the newest beta, else that version's own latest.json. */
+export function cliManifestUrl(version) {
+    if (version === 'latest')
+        return UNITY_CLI_CDN + '/latest-beta.json';
+    if (!CLI_VERSION.test(version))
+        throw new Error('not a Unity CLI version: ' + version);
+    return UNITY_CLI_CDN + '/' + version + '/latest.json';
+}
+export const CliManifestSchema = z.object({
+    version: z.string().regex(CLI_VERSION),
+    binaries: z
+        .record(z.string().max(40), z.object({
+        filename: z.string().max(80),
+        sha256: z.string().max(80),
+        size: z.number().int().min(0).optional(),
+    }))
+        .refine((r) => Object.keys(r).length <= 20),
+});
+/** The Windows build for this CPU, or null when the manifest has none or its file name or hash is unexpected. */
+export function pickCliBinary(m, arch) {
+    const b = m.binaries['win32-' + arch];
+    if (!b)
+        return null;
+    const file = CLI_FILE.exec(b.filename);
+    if (!file || file[1] !== arch || !SHA256.test(b.sha256))
+        return null;
+    return {
+        version: m.version,
+        url: UNITY_CLI_CDN + '/' + m.version + '/' + b.filename,
+        sha256: b.sha256.toLowerCase(),
+        size: b.size ?? 0,
+    };
+}
+/** No telemetry, hints, pager, elevation prompt or first-run set-up (the skills are synced by us when asked). */
+export const UNITY_CLI_ENV = {
+    UNITY_NO_CLI_INVOKED_TELEMETRY: '1',
+    UNITY_NO_AGENT_HINTS: '1',
+    UNITY_CLI_SKIP_SETUP: '1',
+    UNITY_NO_PAGER: '1',
+    UNITY_NO_ELEVATE: '1',
+};
+/** `unity install <version> -c <changeset> -m <ids> --cm`. --download-directory is not in the docs: from the plan. */
+export function installArgs(version, changeset, modules, dir) {
+    return [
+        'install',
+        version,
+        ...(changeset ? ['-c', changeset] : []),
+        ...(modules.length ? ['-m', ...modules, '--cm'] : []),
+        '--download-directory',
+        dir,
+    ];
+}
+/** `unity install-modules -e <version> -m <ids> --cm`. --download-directory is not in the docs: from the plan. */
+export function installModulesArgs(version, modules, dir) {
+    return ['install-modules', '-e', version, '-m', ...modules, '--cm', '--download-directory', dir];
+}
+/** Where the CLI installs editors. `--set` is not in the docs (they say "run install-path --help"): from the plan. */
+export function installPathArgs(dir) {
+    return ['install-path', '--set', dir];
+}
+/** `unity editors add <path...>` registers editors installed outside the Hub (the docs pass their folders). */
+export function editorsAddArgs(exes) {
+    return ['editors', 'add', ...exes];
+}
+/** `unity license status` is not in the docs; --format json is the global output option. */
+export function licenceStatusArgs() {
+    return ['license', 'status', '--format', 'json'];
+}

package/dist/shared/unity/editors.d.ts

@@ -0,0 +1,46 @@
+export interface UnityFs {
+    exists(file: string): boolean;
+    list(dir: string): string[];
+}
+export interface UnityEditor {
+    readonly version: string;
+    /** The folder that holds Editor\Unity.exe. */
+    readonly root: string;
+    readonly exe: string;
+    readonly origin: 'pc' | 'data';
+    readonly writable: boolean;
+    /** Module ids found installed (android, webgl, ios, windows-il2cpp). */
+    readonly modules: readonly string[];
+}
+export declare const ORIGIN_LABELS: {
+    readonly pc: "this PC, read-only";
+    readonly data: "the data disk, kept between sandboxes";
+};
+/** The modules installed in an editor folder. */
+export declare function editorModules(root: string, fs: UnityFs): string[];
+export interface EditorSearch {
+    /** This PC's editors as mapped read-only (id = the version). */
+    readonly mapped: readonly {
+        readonly guest: string;
+        readonly id: string;
+    }[];
+    /** tools\unity\editors on the data disk. */
+    readonly dataRoot: string;
+}
+export declare function findEditors(search: EditorSearch, fs: UnityFs): UnityEditor[];
+export interface WantedEditor {
+    readonly version: string;
+    readonly changeset: string | null;
+}
+export interface EditorChoice {
+    readonly editor: UnityEditor | null;
+    /** What to install on the data disk, when nothing usable is there. */
+    readonly install: WantedEditor | null;
+    readonly reason: string;
+}
+/**
+ * The editor for a project: exactly the version it asks for. This PC's (read-only) when it has every module, then the
+ * data disk's, else install it when the licence is accepted. A PC editor that lacks modules is still used when nothing
+ * can be installed.
+ */
+export declare function chooseEditor(editors: readonly UnityEditor[], wanted: WantedEditor | null, modules: readonly string[], canInstall: boolean): EditorChoice;

package/dist/shared/unity/editors.js

@@ -0,0 +1,89 @@
+// The Unity editors a sandbox has (this PC's, read-only, and the data disk's) and which one a project opens with. An
+// editor is never swapped for another version: opening a project in another Unity upgrades its files. Pure apart from
+// the file reads it is given.
+import path from 'node:path';
+import { UNITY_VERSION } from './version.js';
+const win = path.win32;
+export const ORIGIN_LABELS = {
+    pc: 'this PC, read-only',
+    data: 'the data disk, kept between sandboxes',
+};
+/** Folders under Editor\Data\PlaybackEngines that show a module is installed (windows-il2cpp: verify on an editor). */
+const MODULE_FOLDERS = {
+    android: ['AndroidPlayer'],
+    webgl: ['WebGLSupport'],
+    ios: ['iOSSupport'],
+    'windows-il2cpp': [
+        'windowsstandalonesupport\\Variations\\win64_player_development_il2cpp',
+        'windowsstandalonesupport\\Variations\\win64_development_il2cpp',
+    ],
+};
+/** The modules installed in an editor folder. */
+export function editorModules(root, fs) {
+    const engines = win.join(root, 'Editor', 'Data', 'PlaybackEngines');
+    return Object.entries(MODULE_FOLDERS)
+        .filter(([, folders]) => folders.some((f) => fs.exists(win.join(engines, f))))
+        .map(([id]) => id);
+}
+/** A data editor counts once its install finished: .complete.json (ours) or a Hub/CLI modules.json. */
+function isComplete(root, fs) {
+    return fs.exists(win.join(root, '.complete.json')) || fs.exists(win.join(root, 'modules.json'));
+}
+export function findEditors(search, fs) {
+    const found = [];
+    for (const m of search.mapped) {
+        const exe = win.join(m.guest, 'Editor', 'Unity.exe');
+        if (UNITY_VERSION.test(m.id) && fs.exists(exe))
+            found.push({
+                version: m.id,
+                root: m.guest,
+                exe,
+                origin: 'pc',
+                writable: false,
+                modules: editorModules(m.guest, fs),
+            });
+    }
+    for (const name of fs.list(search.dataRoot)) {
+        if (name.startsWith('.staging-') || !UNITY_VERSION.test(name))
+            continue;
+        const root = win.join(search.dataRoot, name);
+        const exe = win.join(root, 'Editor', 'Unity.exe');
+        if (isComplete(root, fs) && fs.exists(exe))
+            found.push({ version: name, root, exe, origin: 'data', writable: true, modules: editorModules(root, fs) });
+    }
+    return found;
+}
+/**
+ * The editor for a project: exactly the version it asks for. This PC's (read-only) when it has every module, then the
+ * data disk's, else install it when the licence is accepted. A PC editor that lacks modules is still used when nothing
+ * can be installed.
+ */
+export function chooseEditor(editors, wanted, modules, canInstall) {
+    if (!wanted)
+        return { editor: null, install: null, reason: 'no ProjectSettings/ProjectVersion.txt' };
+    const v = wanted.version;
+    const same = editors.filter((e) => e.version === v);
+    const pc = same.find((e) => e.origin === 'pc');
+    const data = same.find((e) => e.origin === 'data');
+    const missing = (e) => modules.find((m) => !e?.modules.includes(m));
+    const asks = 'the project asks for ' + v;
+    if (pc && missing(pc) === undefined)
+        return { editor: pc, install: null, reason: asks };
+    if (data) {
+        const lack = pc ? missing(pc) : undefined;
+        return {
+            editor: data,
+            install: null,
+            reason: lack === undefined ? asks : v + ' from this PC lacks ' + lack + '; using the data disk copy',
+        };
+    }
+    if (canInstall)
+        return { editor: null, install: wanted, reason: v + ' is not here yet; installing it on the data disk' };
+    if (pc)
+        return { editor: pc, install: null, reason: asks };
+    return {
+        editor: null,
+        install: null,
+        reason: v + ' is not on this PC or the data disk; accept the Unity licence (Unity set-up settings) to install it',
+    };
+}

package/dist/shared/unity/guide.d.ts

@@ -0,0 +1,9 @@
+import type { UnityStatus } from './status.js';
+export interface UnityGuideProject {
+    /** The project's folder in the sandbox. */
+    readonly workspace: string;
+}
+/** The guide's Unity lines for these projects (none when Unity is not set up). */
+export declare function unityGuideLines(status: UnityStatus, projects: readonly UnityGuideProject[]): string[];
+/** One line about a project's editor, for the status the agent and the page show. */
+export declare function unitySummaryLine(status: UnityStatus, workspace: string): string;

package/dist/shared/unity/guide.js

@@ -0,0 +1,84 @@
+// The Unity lines of the sandbox guide (the managed CLAUDE.md and AGENTS.md): which editor each project opens with and
+// the plain commands an agent builds, tests and imports with. Pure, from the status the sandbox wrote (status.ts).
+import path from 'node:path';
+import { ORIGIN_LABELS } from './editors.js';
+const win = path.win32;
+function sameDir(a, b) {
+    return a.toLowerCase() === b.toLowerCase();
+}
+function exeOf(root) {
+    return win.join(root, 'Editor', 'Unity.exe');
+}
+/** The guide's Unity lines for these projects (none when Unity is not set up). */
+export function unityGuideLines(status, projects) {
+    const lines = [];
+    const several = projects.length > 1;
+    let first = null;
+    const bridges = new Set();
+    let withoutBridge = false;
+    for (const p of projects) {
+        const choice = status.projects.find((s) => sameDir(s.workspace, p.workspace));
+        const editor = choice?.editor ? status.editors.find((e) => sameDir(e.root, choice.editor)) : undefined;
+        if (!choice || !editor)
+            continue;
+        const exe = exeOf(editor.root);
+        const name = several ? ' (' + win.basename(p.workspace) + ')' : '';
+        first ??= { exe, workspace: p.workspace };
+        lines.push('- Unity' +
+            name +
+            ': editor ' +
+            editor.version +
+            ' at `' +
+            exe +
+            '` (' +
+            ORIGIN_LABELS[editor.origin] +
+            '; ' +
+            choice.reason +
+            '). Build or run code without opening it: `"' +
+            exe +
+            '" -batchmode -nographics -quit -projectPath "' +
+            p.workspace +
+            '" -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.' +
+            (editor.writable ? '' : " It is the user's PC copy, read-only: never add modules to it."));
+        if (choice.bridge)
+            bridges.add(choice.bridge);
+        else
+            withoutBridge = true;
+    }
+    if (!lines.length)
+        return lines;
+    if (status.cli)
+        lines.push('- `unity` (Unity CLI ' +
+            status.cli.version +
+            ') is on PATH: `unity editors -i`, `unity build`, `unity test`, `unity open <project>` (opens it signed in).');
+    if (bridges.has('pipeline'))
+        lines.push('- The open editor can be driven with `unity command` and `unity eval` (Unity Pipeline package); MCP clients use sbx-unity.');
+    if (bridges.has('coplay'))
+        lines.push('- The open editor can be driven with MCP for Unity (sbx-unity-mcp in Apps).');
+    if (withoutBridge)
+        lines.push("- 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.");
+    if (status.pcAssets.length && first)
+        lines.push("- The user's Unity Asset Store downloads (read-only): `" +
+            status.pcAssets[0] +
+            '`; import one with the editor closed: `"' +
+            first.exe +
+            '" -batchmode -nographics -quit -projectPath "' +
+            first.workspace +
+            '" -importPackage "<file>"`.' +
+            (status.assetCache.dir ? ' Downloads made here go to `' + status.assetCache.dir + '` (kept).' : ''));
+    if (status.licence.state !== 'active')
+        lines.push('- Unity licence: ' +
+            status.licence.detail +
+            ". Batch mode fails without one: ask the user to sign in to Unity on the sandbox tool's Unity page.");
+    return lines;
+}
+/** One line about a project's editor, for the status the agent and the page show. */
+export function unitySummaryLine(status, workspace) {
+    const choice = status.projects.find((s) => sameDir(s.workspace, workspace));
+    if (!choice)
+        return 'Unity: not set up for this project';
+    const editor = choice.editor ? status.editors.find((e) => sameDir(e.root, choice.editor)) : undefined;
+    return editor
+        ? 'Unity ' + editor.version + ' (' + ORIGIN_LABELS[editor.origin] + '; ' + choice.reason + ')'
+        : 'Unity: no editor (' + choice.reason + ')';
+}

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

@@ -0,0 +1,9 @@
+export * from './version.js';
+export * from './editors.js';
+export * from './release.js';
+export * from './cli.js';
+export * from './mcp.js';
+export * from './manifest.js';
+export * from './asset-cache.js';
+export * from './status.js';
+export * from './guide.js';

package/dist/shared/unity/index.js

@@ -0,0 +1,11 @@
+// Unity editors, the release API, the Unity CLI, the editor bridge and the Unity status, shared by the sandbox and this
+// PC (pure).
+export * from './version.js';
+export * from './editors.js';
+export * from './release.js';
+export * from './cli.js';
+export * from './mcp.js';
+export * from './manifest.js';
+export * from './asset-cache.js';
+export * from './status.js';
+export * from './guide.js';

package/dist/shared/unity/manifest.d.ts

@@ -0,0 +1,10 @@
+export declare const PIPELINE_PACKAGE = "com.unity.pipeline";
+export declare const COPLAY_PACKAGE = "com.coplaydev.unity-mcp";
+export declare const COPLAY_PACKAGE_URL = "https://github.com/CoplayDev/unity-mcp.git?path=/MCPForUnity#v10.3.0";
+/** The Pipeline version added when none is given (0.10 is the one the plan was written against). */
+export declare const DEFAULT_PIPELINE_VERSION = "0.10.0";
+export type Bridge = 'pipeline' | 'coplay';
+/** Which bridge the project has, or null (also for a file that is not a manifest). */
+export declare function bridgeOf(text: string): Bridge | null;
+/** The manifest with the bridge added or removed: key order, 2-space indent, trailing newline and CRLF kept. */
+export declare function withBridge(text: string, bridge: Bridge, on: boolean, pipelineVersion?: string): string;

package/dist/shared/unity/manifest.js

@@ -0,0 +1,53 @@
+// Packages/manifest.json and the editor bridge: the package that lets `unity command` / `unity eval` (Unity Pipeline,
+// Unity 6 and later) or MCP for Unity (Coplay) drive a running editor. Edited only when the user asks. Pure text.
+export const PIPELINE_PACKAGE = 'com.unity.pipeline';
+export const COPLAY_PACKAGE = 'com.coplaydev.unity-mcp';
+export const COPLAY_PACKAGE_URL = 'https://github.com/CoplayDev/unity-mcp.git?path=/MCPForUnity#v10.3.0';
+/** The Pipeline version added when none is given (0.10 is the one the plan was written against). */
+export const DEFAULT_PIPELINE_VERSION = '0.10.0';
+const MAX_MANIFEST_BYTES = 1024 * 1024;
+const SEMVER = /^\d{1,6}\.\d{1,6}\.\d{1,6}(-[0-9A-Za-z.-]{1,50})?(\+[0-9A-Za-z.-]{1,50})?$/;
+function parseManifest(text) {
+    if (Buffer.byteLength(text) > MAX_MANIFEST_BYTES)
+        throw new Error('Packages/manifest.json is over 1 MB');
+    const json = JSON.parse(text.replace(/^\uFEFF/, ''));
+    if (typeof json !== 'object' || json === null || Array.isArray(json))
+        throw new Error('Packages/manifest.json is not an object');
+    const m = json;
+    if (m.dependencies !== undefined &&
+        (typeof m.dependencies !== 'object' || m.dependencies === null || Array.isArray(m.dependencies)))
+        throw new Error('Packages/manifest.json: dependencies is not an object');
+    return m;
+}
+/** Which bridge the project has, or null (also for a file that is not a manifest). */
+export function bridgeOf(text) {
+    try {
+        const deps = parseManifest(text).dependencies ?? {};
+        if (PIPELINE_PACKAGE in deps)
+            return 'pipeline';
+        if (COPLAY_PACKAGE in deps)
+            return 'coplay';
+        return null;
+    }
+    catch {
+        // Not JSON or not a manifest: no bridge to report.
+        return null;
+    }
+}
+/** The manifest with the bridge added or removed: key order, 2-space indent, trailing newline and CRLF kept. */
+export function withBridge(text, bridge, on, pipelineVersion) {
+    const m = parseManifest(text);
+    const name = bridge === 'pipeline' ? PIPELINE_PACKAGE : COPLAY_PACKAGE;
+    if (on) {
+        const version = pipelineVersion ?? DEFAULT_PIPELINE_VERSION;
+        if (bridge === 'pipeline' && !SEMVER.test(version))
+            throw new Error('not a package version: ' + version);
+        const deps = (m.dependencies ??= {});
+        deps[name] = bridge === 'pipeline' ? version : COPLAY_PACKAGE_URL;
+    }
+    else if (m.dependencies) {
+        delete m.dependencies[name];
+    }
+    const out = JSON.stringify(m, null, 2) + '\n';
+    return text.includes('\r\n') ? out.replace(/\n/g, '\r\n') : out;
+}

package/dist/shared/unity/mcp.d.ts

@@ -0,0 +1,8 @@
+export declare const UNITY_MCP_NAME = "sbx-unity";
+export interface UnityMcpServer {
+    readonly type: 'stdio';
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly env: Readonly<Record<string, string>>;
+}
+export declare function unityCliMcpServer(unityExe: string, projectPath: string | null): UnityMcpServer;

package/dist/shared/unity/mcp.js

@@ -0,0 +1,12 @@
+// The Unity CLI as an MCP server (`unity mcp --cli-tools`, stdio) for Claude Code and Codex. Read-only tools always;
+// the open editor's tools when the project has the Unity Pipeline package.
+import { UNITY_CLI_ENV } from './cli.js';
+export const UNITY_MCP_NAME = 'sbx-unity';
+export function unityCliMcpServer(unityExe, projectPath) {
+    return {
+        type: 'stdio',
+        command: unityExe,
+        args: ['mcp', '--cli-tools'],
+        env: { ...UNITY_CLI_ENV, ...(projectPath ? { UNITY_PROJECT_PATH: projectPath } : {}) },
+    };
+}

package/dist/shared/unity/release.d.ts

@@ -0,0 +1,28 @@
+/** The request for one editor version (Windows, x86_64, one result). */
+export declare function releaseUrl(version: string): string;
+export interface UnityRelease {
+    readonly version: string;
+    readonly changeset: string;
+    readonly editor: {
+        readonly url: string;
+        /** As Unity writes it: "md5-<base64>". */
+        readonly integrity: string | null;
+        readonly downloadBytes: number;
+        readonly installedBytes: number;
+    };
+    readonly modules: readonly {
+        readonly id: string;
+        readonly downloadBytes: number;
+        readonly installedBytes: number;
+        readonly integrity: string | null;
+        /** The ids of its sub-modules (android: the SDK, NDK and OpenJDK parts). */
+        readonly children: readonly string[];
+        /** The sub-modules' sizes together. */
+        readonly childDownloadBytes: number;
+        readonly childInstalledBytes: number;
+    }[];
+}
+/** The first release an API answer holds (the EXE installer), or null when it holds none or has another shape. */
+export declare function pickRelease(json: unknown): UnityRelease | null;
+/** Room an install needs: (editor download + installed + the chosen modules with their children) plus 10%. */
+export declare function installNeedBytes(r: UnityRelease, modules: readonly string[]): number;