windows-development-sandbox 1.25.1 → 1.27.1

package/dist/guest/daemon/daemon.js

@@ -13,6 +13,7 @@ import { warn } from '../runtime/log.js';
 import { errMsg } from '../../core/util/errors.js';
 import { flushAccounts } from './accounts.js';
 import { captureLauncherEngines } from '../toolchains/engines/unreal-engines.js';
+import { captureUnityEditors } from '../toolchains/engines/unity.js';
 const POLL_MS = 400;
 const MEM_SAVE_MS = 120000;
 export class Daemon {
@@ -50,6 +51,7 @@ export class Daemon {
             void flushAccounts();
             // Engines the Epic Games Launcher installed on the data disk since: kept for the next sandbox.
             void captureLauncherEngines().catch((e) => warn('Unreal launcher save: ' + errMsg(e)));
+            void captureUnityEditors().catch((e) => warn('Unity editors: ' + errMsg(e)));
         }
     }
     handle(req) {

package/dist/guest/devtools/devtool.d.ts

@@ -1,4 +1,4 @@
-export type DevToolName = 'steam' | 'fivem' | 'unity' | 'android';
+export type DevToolName = 'steam' | 'fivem' | 'android';
 export interface DevTool {
     readonly name: DevToolName;
     /** One line for its usage and the agent's guide. */

package/dist/guest/devtools/registry.js

@@ -1,8 +1,7 @@
 import { androidTool } from './android.js';
 import { fivemTool } from './fivem.js';
 import { steamTool } from './steam.js';
-import { unityTool } from './unity.js';
-export const DEVTOOLS = [steamTool, fivemTool, unityTool, androidTool];
+export const DEVTOOLS = [steamTool, fivemTool, androidTool];
 /** The helpers for the toolchains that are on (resolved by the host; "auto" counts as off here). */
 export function devToolsFor(t) {
     return DEVTOOLS.filter((tool) => t[tool.name].enabled === true);

package/dist/guest/entries/tool.js

@@ -1,4 +1,4 @@
-// The sbx-<name> helpers (sbx-steam, sbx-fivem, sbx-unity, sbx-android): `tool.js <name> <args...>` runs that helper.
+// The sbx-<name> helpers (sbx-steam, sbx-fivem, sbx-android): `tool.js <name> <args...>` runs that helper.
 import { errMsg } from '../../core/util/errors.js';
 import { DEVTOOLS, devToolByName } from '../devtools/registry.js';
 const [name, ...args] = process.argv.slice(2);

package/dist/guest/setup/addon-mcp.d.ts

@@ -1,9 +1,14 @@
+import { type McpServerConfig } from '../../shared/apps/index.js';
 /** The Unreal editor's MCP server (Unreal 5.8's ModelContextProtocol plugin), set by the Unreal engines step. */
 export declare const UNREAL_MCP_NAME = "sbx-unreal-editor";
+/** The engines' own MCP servers: not an Apps add-on, set by the engine's step each boot, and sent to Codex too. */
+export declare const ENGINE_MCP_NAMES: readonly ["sbx-unreal-editor", "sbx-unity"];
 /**
- * Adds the Unreal editor's MCP server (its address) to the next writeAddonMcpServers, or takes it away (null). It only
- * answers while the editor runs with the plugin on; until then Claude Code lists it as not connected.
+ * Adds an engine's MCP server to the next writeAddonMcpServers, or takes it away (null). A server for an editor only
+ * answers while the editor runs; until then Claude Code lists it as not connected.
  */
+export declare function setEngineMcp(name: (typeof ENGINE_MCP_NAMES)[number], server: McpServerConfig | null): void;
+/** Adds the Unreal editor's MCP server (its address) to the next writeAddonMcpServers, or takes it away (null). */
 export declare function setUnrealMcp(url: string | null): void;
 /** Sets the add-ons' MCP servers in the sandbox's .claude.json (and Codex's config.toml); the names that are on. */
 export declare function writeAddonMcpServers(): string[];

package/dist/guest/setup/addon-mcp.js

@@ -6,6 +6,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { addonMcpServer, APPS, codexWithAddonMcpServers, withAddonMcpServers, } from '../../shared/apps/index.js';
+import { UNITY_MCP_NAME } from '../../shared/unity/index.js';
 import { writeJsonAtomic } from '../../shared/io/json.js';
 import { cometExe } from '../browser/comet.js';
 import { exists, mkdirp } from '../runtime/fs.js';
@@ -15,15 +16,24 @@ import { log, warn } from '../runtime/log.js';
 import { installedMcpAddons } from './agent-addons.js';
 /** The Unreal editor's MCP server (Unreal 5.8's ModelContextProtocol plugin), set by the Unreal engines step. */
 export const UNREAL_MCP_NAME = 'sbx-unreal-editor';
-let unrealMcp = null;
+/** The engines' own MCP servers: not an Apps add-on, set by the engine's step each boot, and sent to Codex too. */
+export const ENGINE_MCP_NAMES = [UNREAL_MCP_NAME, UNITY_MCP_NAME];
+const engineMcp = new Map();
 /** The names of every MCP server the sandbox can add (the ones it may remove). */
-const ADDON_MCP_NAMES = [...APPS.flatMap((a) => (a.mcp ? [a.mcp.name] : [])), UNREAL_MCP_NAME];
+const ADDON_MCP_NAMES = [...APPS.flatMap((a) => (a.mcp ? [a.mcp.name] : [])), ...ENGINE_MCP_NAMES];
 /**
- * Adds the Unreal editor's MCP server (its address) to the next writeAddonMcpServers, or takes it away (null). It only
- * answers while the editor runs with the plugin on; until then Claude Code lists it as not connected.
+ * Adds an engine's MCP server to the next writeAddonMcpServers, or takes it away (null). A server for an editor only
+ * answers while the editor runs; until then Claude Code lists it as not connected.
  */
+export function setEngineMcp(name, server) {
+    if (server)
+        engineMcp.set(name, server);
+    else
+        engineMcp.delete(name);
+}
+/** Adds the Unreal editor's MCP server (its address) to the next writeAddonMcpServers, or takes it away (null). */
 export function setUnrealMcp(url) {
-    unrealMcp = url ? { type: 'http', url } : null;
+    setEngineMcp(UNREAL_MCP_NAME, url ? { type: 'http', url } : null);
 }
 /** Variables only this sandbox can tell an add-on's server (where Comet is). */
 function placeEnv(id) {
@@ -46,7 +56,7 @@ export function writeAddonMcpServers() {
     writeCodexAddonMcpServers(on);
     const servers = {
         ...Object.fromEntries(on.map(({ mcp, server }) => [mcp.name, server])),
-        ...(unrealMcp ? { [UNREAL_MCP_NAME]: unrealMcp } : {}),
+        ...Object.fromEntries(engineMcp),
     };
     const file = path.join(claudeDir, '.claude.json');
     let state = {};
@@ -85,12 +95,12 @@ function writeCodexAddonMcpServers(on) {
     const servers = Object.fromEntries(on
         .filter(({ mcp }) => mcp.codex)
         .map(({ mcp, server }) => [mcp.name, { ...server, ...(mcp.envVars?.length ? { envVars: mcp.envVars } : {}) }]));
-    if (unrealMcp)
-        servers[UNREAL_MCP_NAME] = unrealMcp;
+    for (const [name, server] of engineMcp)
+        servers[name] = server;
     const before = exists(file) ? fs.readFileSync(file, 'utf8') : '';
     if (!before && !Object.keys(servers).length)
         return;
-    const known = [...APPS.flatMap((a) => (a.mcp?.codex ? [a.mcp.name] : [])), UNREAL_MCP_NAME];
+    const known = [...APPS.flatMap((a) => (a.mcp?.codex ? [a.mcp.name] : [])), ...ENGINE_MCP_NAMES];
     const result = codexWithAddonMcpServers(before, servers, known);
     for (const name of result.skipped)
         warn('Codex MCP servers from Apps: ' + name + ' is already in config.toml in another form, left as it is');

package/dist/guest/setup/github-token.js

@@ -1,6 +1,6 @@
-// The GitHub token the host handed over (github.shareToken, only with git access "full"): gh logs in with it in a
-// folder on the sandbox's own disk (gone with the sandbox, never in the persistent state), and https git asks gh. The
-// token goes to gh on stdin, never in an argument, a file of ours or a log line.
+// The GitHub token the host handed over (github.shareToken or github.usePcLogin, only with git access "full"): gh logs
+// in with it in a folder on the sandbox's own disk (gone with the sandbox, never in the persistent state), and https
+// git asks gh. The token goes to gh on stdin, never in an argument, a file of ours or a log line.
 import fs from 'node:fs';
 import { spawnSync } from 'node:child_process';
 import { ghLoginCommand, ghOutputText, ghSetupGitCommand } from '../../shared/github/index.js';
@@ -61,5 +61,5 @@ export function loginGithub(token, env) {
         addMachineEnvironment({ GH_CONFIG_DIR: env.GH_CONFIG_DIR }, []);
         throw e;
     }
-    log('gh and https git to github.com use the GitHub token from your PC (github.shareToken); the agent can read it.');
+    log('gh and https git to github.com use the GitHub login from your PC (github.shareToken or github.usePcLogin); the agent can read it.');
 }

package/dist/guest/setup/unity-agent.d.ts

@@ -0,0 +1,11 @@
+export interface UnityAgentInput {
+    readonly unityExe: string;
+    readonly projectPath: string | null;
+    readonly mcp: boolean;
+    readonly skills: boolean;
+}
+/** Sets up what is asked; returns the MCP server's name when it was registered and whether the skills were synced. */
+export declare function setupUnityAgentTools(i: UnityAgentInput): Promise<{
+    mcp: string | null;
+    skills: boolean;
+}>;

package/dist/guest/setup/unity-agent.js

@@ -0,0 +1,39 @@
+// Unity for the agents: the Unity CLI's MCP server (sbx-unity) and its skills in the sandbox's Claude Code and Codex.
+// The project is never changed. A failure is a warning: the editor itself still works without the agent tools.
+import path from 'node:path';
+import { UNITY_CLI_ENV, UNITY_MCP_NAME, unityCliMcpServer } from '../../shared/unity/index.js';
+import { execAsync } from '../runtime/process.js';
+import { log, warn } from '../runtime/log.js';
+import { claudeDir, session, stateDir } from '../runtime/session.js';
+import { setEngineMcp, writeAddonMcpServers } from './addon-mcp.js';
+/** Syncs Unity's skills for one agent, with that agent's home folder in its variable; false on failure. */
+async function syncSkills(unityExe, agent) {
+    const home = agent === 'claude' ? { CLAUDE_CONFIG_DIR: claudeDir } : { CODEX_HOME: path.join(stateDir, 'codex') };
+    try {
+        // The Unity CLI's client names: claude-code, codex.
+        await execAsync(unityExe, ['skill', 'sync', agent === 'claude' ? 'claude-code' : 'codex'], {
+            env: { ...process.env, ...UNITY_CLI_ENV, ...home },
+        });
+        return true;
+    }
+    catch (e) {
+        warn('Unity skills for ' + agent + ' were not synced: ' + (e instanceof Error ? e.message : String(e)));
+        return false;
+    }
+}
+/** Sets up what is asked; returns the MCP server's name when it was registered and whether the skills were synced. */
+export async function setupUnityAgentTools(i) {
+    setEngineMcp(UNITY_MCP_NAME, i.mcp ? unityCliMcpServer(i.unityExe, i.projectPath) : null);
+    const names = writeAddonMcpServers();
+    const mcp = names.includes(UNITY_MCP_NAME) ? UNITY_MCP_NAME : null;
+    let skills = false;
+    if (i.skills) {
+        const results = [await syncSkills(i.unityExe, 'claude')];
+        if (session.agents?.codex)
+            results.push(await syncSkills(i.unityExe, 'codex'));
+        skills = results.some(Boolean);
+        if (skills)
+            log('Unity skills synced for the agents');
+    }
+    return { mcp, skills };
+}

package/dist/guest/toolchains/engines/epic-launcher.d.ts

@@ -1,5 +1,5 @@
 import { type LauncherEntry } from '../../../shared/unreal/index.js';
-/** The launcher's program (launcher 17+ is 64-bit; older ones were in Win32). */
+/** The launcher's program: newer MSIs install into Program Files, older ones into Program Files (x86). */
 export declare function launcherExe(): string | null;
 /** Downloads the launcher's MSI ahead of the install (once). */
 export declare function fetchLauncher(): Promise<void>;

package/dist/guest/toolchains/engines/epic-launcher.js

@@ -22,14 +22,18 @@ const SAVED_MANIFESTS = path.join(SAVED_DIR, 'Manifests');
 const SAVED_ENTRIES = path.join(SAVED_DIR, 'LauncherInstalled.json');
 const programData = () => process.env.ProgramData ?? 'C:\\ProgramData';
 const localAppData = () => process.env.LOCALAPPDATA ?? '';
-/** The launcher's program (launcher 17+ is 64-bit; older ones were in Win32). */
+/** The launcher's program: newer MSIs install into Program Files, older ones into Program Files (x86). */
 export function launcherExe() {
-    const root = path.join(process.env['ProgramFiles(x86)'] ?? 'C:\\Program Files (x86)', 'Epic Games', 'Launcher');
-    for (const arch of ['Win64', 'Win32']) {
-        const exe = path.join(root, 'Portal', 'Binaries', arch, 'EpicGamesLauncher.exe');
-        if (exists(exe))
-            return exe;
-    }
+    const roots = [
+        process.env.ProgramFiles ?? 'C:\\Program Files',
+        process.env['ProgramFiles(x86)'] ?? 'C:\\Program Files (x86)',
+    ];
+    for (const root of roots)
+        for (const arch of ['Win64', 'Win32']) {
+            const exe = path.join(root, 'Epic Games', 'Launcher', 'Portal', 'Binaries', arch, 'EpicGamesLauncher.exe');
+            if (exists(exe))
+                return exe;
+        }
     return null;
 }
 /** Downloads the launcher's MSI ahead of the install (once). */

package/dist/guest/toolchains/engines/unity-cli.d.ts

@@ -0,0 +1,24 @@
+export interface UnityCli {
+    readonly exe: string;
+    readonly version: string;
+}
+export interface UnityRun {
+    readonly code: number;
+    readonly stdout: string;
+}
+export interface UnityRunOptions {
+    /** TEMP and TMP for the run (inside the staging folder of an install). */
+    readonly temp?: string;
+    readonly cwd?: string;
+    readonly timeoutMs?: number;
+    /** Extra variables (the asset cache). */
+    readonly env?: Readonly<Record<string, string>>;
+}
+/** The pinned Unity CLI on the data disk, downloaded when it is not there yet ("latest" asks the manifest first). */
+export declare function ensureUnityCli(version: string): Promise<UnityCli>;
+/** Downloads the CLI ahead of its step; a failure is ignored (the step downloads again). */
+export declare function prefetchUnityCli(version: string): Promise<void>;
+/** Runs the CLI without blocking; the exit code and the start of its output (at most 1 MB). Never throws on a code. */
+export declare function runUnityCli(exe: string, args: readonly string[], o?: UnityRunOptions): Promise<UnityRun>;
+/** runUnityCli that throws with the end of the output when the exit code is not 0. */
+export declare function runUnityCliChecked(exe: string, args: readonly string[], o?: UnityRunOptions): Promise<string>;

package/dist/guest/toolchains/engines/unity-cli.js

@@ -0,0 +1,74 @@
+// The Unity CLI (`unity`): its pinned build downloaded once into tools\unity\cli\<version> (checked against the SHA-256
+// Unity publishes, and its signature when it has one), and the way every other Unity step runs it.
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { fetchBounded, downloader } from '../../../shared/download/index.js';
+import { CliManifestSchema, cliManifestUrl, pickCliBinary, UNITY_CLI_ENV, } from '../../../shared/unity/index.js';
+import { log } from '../../runtime/log.js';
+import { net } from '../../runtime/pools.js';
+import { ensurePersisted } from '../persisted.js';
+import { arch } from '../tool-env.js';
+const MB = 1024 * 1024;
+const MAX_MANIFEST_BYTES = 256 * 1024;
+const MAX_OUTPUT_BYTES = 1024 * 1024;
+/** The binary the manifest of a CLI version names for this CPU. */
+async function resolveCli(version) {
+    const text = await net.run(() => fetchBounded(cliManifestUrl(version), MAX_MANIFEST_BYTES));
+    const parsed = CliManifestSchema.safeParse(JSON.parse(text));
+    const binary = parsed.success ? pickCliBinary(parsed.data, arch) : null;
+    if (!binary)
+        throw new Error('the Unity CLI manifest for ' + version + ' has no usable Windows build');
+    return binary;
+}
+/** The pinned Unity CLI on the data disk, downloaded when it is not there yet ("latest" asks the manifest first). */
+export async function ensureUnityCli(version) {
+    const binary = await resolveCli(version);
+    const installed = await ensurePersisted({
+        name: 'unity/cli',
+        version: binary.version,
+        needBytes: 200 * MB,
+        marker: 'unity.exe',
+        what: 'Unity CLI ' + binary.version,
+        keepVersions: 2,
+    }, async (staging) => {
+        log('Downloading the Unity CLI ' + binary.version + ' ...');
+        // The CLI is not known to be signed: the SHA-256 from Unity's manifest is the check.
+        await downloader.file(binary.url, path.join(staging, 'unity.exe'), { sha256: binary.sha256 });
+    });
+    return { exe: path.join(installed.dir, 'unity.exe'), version: binary.version };
+}
+/** Downloads the CLI ahead of its step; a failure is ignored (the step downloads again). */
+export async function prefetchUnityCli(version) {
+    await ensureUnityCli(version);
+}
+/** Runs the CLI without blocking; the exit code and the start of its output (at most 1 MB). Never throws on a code. */
+export function runUnityCli(exe, args, o = {}) {
+    return new Promise((resolve, reject) => {
+        const temp = o.temp ? { TEMP: o.temp, TMP: o.temp } : {};
+        const child = spawn(exe, [...args], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true,
+            ...(o.cwd ? { cwd: o.cwd } : {}),
+            env: { ...process.env, ...UNITY_CLI_ENV, ...temp, ...(o.env ?? {}) },
+            ...(o.timeoutMs ? { timeout: o.timeoutMs } : {}),
+        });
+        let stdout = '';
+        const take = (chunk) => {
+            if (stdout.length < MAX_OUTPUT_BYTES)
+                stdout += chunk.slice(0, MAX_OUTPUT_BYTES - stdout.length);
+        };
+        child.stdout.setEncoding('utf8');
+        child.stderr.setEncoding('utf8');
+        child.stdout.on('data', take);
+        child.stderr.on('data', take);
+        child.once('error', reject);
+        child.once('close', (code) => resolve({ code: code ?? -1, stdout }));
+    });
+}
+/** runUnityCli that throws with the end of the output when the exit code is not 0. */
+export async function runUnityCliChecked(exe, args, o = {}) {
+    const r = await runUnityCli(exe, args, o);
+    if (r.code !== 0)
+        throw new Error('unity ' + args.slice(0, 2).join(' ') + ' failed with exit code ' + r.code + ': ' + r.stdout.trim().slice(-400));
+    return r.stdout;
+}

package/dist/guest/toolchains/engines/unity-hub.d.ts

@@ -0,0 +1,2 @@
+/** The Hub's program on the data disk, installed there when it is not (only with `hub` on). */
+export declare function ensureUnityHub(): Promise<string>;

package/dist/guest/toolchains/engines/unity-hub.js

@@ -0,0 +1,27 @@
+// Unity Hub (toolchains.unity.hub): kept on the data disk (tools\unity\hub\3), installed by its signed installer
+// unpacked there. For signing in to Unity Personal and installing editors by hand.
+import path from 'node:path';
+import { runInstaller } from '../../runtime/pools.js';
+import { shortcuts } from '../../apps/shortcuts.js';
+import { exists } from '../../runtime/fs.js';
+import { log } from '../../runtime/log.js';
+import { SIGNERS, signedInstaller } from '../installers.js';
+import { ensurePersisted } from '../persisted.js';
+import { UNITY_DIR } from './unity-status.js';
+const HUB_URL = 'https://public-cdn.cloud.unity3d.com/hub/prod/UnityHubSetup.exe';
+const HUB_MARKER = 'Unity Hub.exe';
+const GB = 1024 ** 3;
+/** The Hub's program on the data disk, installed there when it is not (only with `hub` on). */
+export async function ensureUnityHub() {
+    const setup = await signedInstaller(HUB_URL, path.join(UNITY_DIR, 'UnityHubSetup.exe'), 'Unity Hub (~150 MB once)', SIGNERS.unity);
+    const installed = await ensurePersisted({ name: 'unity/hub', version: '3', needBytes: 2 * GB, marker: HUB_MARKER, what: 'Unity Hub', keepVersions: 1 }, async (staging) => {
+        log('Installing Unity Hub ...');
+        const code = await runInstaller(setup, ['/S', '/D=' + staging]);
+        if (code !== 0)
+            throw new Error('the Unity Hub installer failed (exit ' + code + ')');
+    });
+    const exe = path.join(installed.dir, HUB_MARKER);
+    if (exists(exe))
+        shortcuts([{ name: 'Unity Hub', exe }]);
+    return exe;
+}

package/dist/guest/toolchains/engines/unity-release.d.ts

@@ -1,15 +1,4 @@
-export interface UnityDownload {
-    /** "editor", or a module id (android, webgl, windows-il2cpp, ios). */
-    readonly id: string;
-    readonly url: string;
-    /** The SRI hash (sha384-... or sha256-...). */
-    readonly integrity: string | null;
-    readonly sizeBytes: number | null;
-}
-export interface UnityRelease {
-    readonly version: string;
-    readonly changeset: string | null;
-    readonly downloads: readonly UnityDownload[];
-}
-/** The release of one editor version (6000.0.32f1), or null when Unity does not list it. */
-export declare function findUnityRelease(_version: string): Promise<UnityRelease | null>;
+import { type UnityRelease } from '../../../shared/unity/index.js';
+export type { UnityRelease };
+/** The release of one editor version (6000.0.58f2), or null when Unity does not list it or answers oddly. */
+export declare function findUnityRelease(version: string): Promise<UnityRelease | null>;

package/dist/guest/toolchains/engines/unity-release.js

@@ -1,6 +1,18 @@
-// Unity's release API (services.api.unity.com/unity/editor/release/v1/releases): the editor installer and module
-// downloads of one version, each with its SRI integrity hash. Not available yet.
-/** The release of one editor version (6000.0.32f1), or null when Unity does not list it. */
-export async function findUnityRelease(_version) {
-    return null;
+// Unity's release API (services.api.unity.com): the editor installer, its changeset and its modules for one version.
+// The answer is read with a size limit and checked by shared/unity/release.ts.
+import { fetchBounded } from '../../../shared/download/index.js';
+import { pickRelease, releaseUrl } from '../../../shared/unity/index.js';
+const MAX_ANSWER_BYTES = 2 * 1024 * 1024;
+/** The release of one editor version (6000.0.58f2), or null when Unity does not list it or answers oddly. */
+export async function findUnityRelease(version) {
+    const text = await fetchBounded(releaseUrl(version), MAX_ANSWER_BYTES);
+    let json;
+    try {
+        json = JSON.parse(text);
+    }
+    catch {
+        return null; // Not JSON: no release.
+    }
+    const release = pickRelease(json);
+    return release && release.version === version ? release : null;
 }

package/dist/guest/toolchains/engines/unity-status.d.ts

@@ -0,0 +1,11 @@
+import { type UnityStatus } from '../../../shared/unity/index.js';
+export declare const UNITY_DIR: string;
+/** The Unity CLI, one folder per version (unity.exe). */
+export declare const CLI_DIR: string;
+/** The editors on the data disk: one folder per version (Editor\Unity.exe). */
+export declare const EDITORS_DIR: string;
+/** Asset Store downloads made in the sandbox (assetCache "persisted"). */
+export declare const ASSET_DIR: string;
+export declare function readUnityStatus(): UnityStatus;
+/** Changes the status with `change` and writes it (whole, atomically). */
+export declare function updateUnityStatus(change: (s: UnityStatus) => UnityStatus): UnityStatus;

package/dist/guest/toolchains/engines/unity-status.js

@@ -0,0 +1,39 @@
+// tools\unity\status.json: what the sandbox found for Unity, for the guide and the Unity page on the PC. The boot's
+// project step writes its editor choice, the licence step the licence, the daemon the editors; every write keeps what
+// the other parts wrote.
+import path from 'node:path';
+import { readValid, writeJsonAtomic } from '../../../shared/io/json.js';
+import { UNITY_STATUS_FILE, UnityStatusSchema } from '../../../shared/unity/index.js';
+import { mkdirp } from '../../runtime/fs.js';
+import { tool } from '../tool-env.js';
+export const UNITY_DIR = tool('unity');
+/** The Unity CLI, one folder per version (unity.exe). */
+export const CLI_DIR = path.join(UNITY_DIR, 'cli');
+/** The editors on the data disk: one folder per version (Editor\Unity.exe). */
+export const EDITORS_DIR = path.join(UNITY_DIR, 'editors');
+/** Asset Store downloads made in the sandbox (assetCache "persisted"). */
+export const ASSET_DIR = path.join(UNITY_DIR, 'asset-store');
+const FILE = path.join(UNITY_DIR, UNITY_STATUS_FILE);
+const EMPTY = {
+    updatedAt: '',
+    cli: null,
+    editors: [],
+    projects: [],
+    licence: { state: 'unknown', kind: '', detail: 'not checked', user: null },
+    assetCache: { mode: 'local', dir: null },
+    pcAssets: [],
+    hub: { installed: false, path: null },
+    mcp: null,
+    skills: false,
+    problem: null,
+};
+export function readUnityStatus() {
+    return readValid(UnityStatusSchema, FILE) ?? EMPTY;
+}
+/** Changes the status with `change` and writes it (whole, atomically). */
+export function updateUnityStatus(change) {
+    const next = { ...change(readUnityStatus()), updatedAt: new Date().toISOString() };
+    mkdirp(UNITY_DIR);
+    writeJsonAtomic(FILE, next);
+    return next;
+}

package/dist/guest/toolchains/engines/unity.d.ts

@@ -1,4 +1,23 @@
+import { type UnityEditor, type WantedEditor } from '../../../shared/unity/index.js';
 import type { Toolchains } from '../../../core/types.js';
 import type { ToolCtx } from '../step.js';
 import type { ToolEnv } from '../tool-env.js';
-export declare function setupUnity(env: ToolEnv, _config: Toolchains['unity'], _ctx: ToolCtx): Promise<void>;
+import { type UnityCli } from './unity-cli.js';
+/** Every editor this sandbox has. */
+export declare function sandboxEditors(ctx: Pick<ToolCtx, 'pcInstalls'>): UnityEditor[];
+/**
+ * The editor a project asks for: its ProjectVersion.txt (read bounded) always wins, since opening a project in another
+ * version upgrades its files; the version the setting names is only for folders without one.
+ */
+export declare function wantedEditor(config: Pick<Toolchains['unity'], 'version'>, workspace: string): WantedEditor | null;
+/** Whether the project's editor is already here (a first install goes to the background). */
+export declare function unityEditorSaved(config: Toolchains['unity'], ctx: Pick<ToolCtx, 'pcInstalls'>): boolean;
+/**
+ * Installs one editor version on the data disk with the CLI (into a staging folder with TEMP inside it) and returns its
+ * folder. One heavy slot while the CLI runs.
+ */
+export declare function ensureUnityEditor(cli: UnityCli, version: string, changeset: string | null, modules: readonly string[], keepVersions: number): Promise<string>;
+/** While the sandbox runs: lists the editors again (the user may have installed one with Hub) for the status. */
+export declare function captureUnityEditors(): Promise<void>;
+/** The editors, the project's choice, the CLI, the licence, the asset cache: set up and written to the status. */
+export declare function setupUnity(env: ToolEnv, config: Toolchains['unity'], ctx: ToolCtx): Promise<void>;