windows-development-sandbox 1.25.1 → 1.27.0

package/dist/guest/apps/store-app.js

@@ -0,0 +1,19 @@
+// A Microsoft Store app in the sandbox: the PC put its package files in the data folder (toolsapps<id>.package,
+// with store-package.json). Windows in the sandbox is new on every boot, so the app is installed again each boot with
+// Add-AppxPackage (sandbox\scripts\install-store-package.ps1), from the package kept on the data disk. The files are
+// checked against the manifest's SHA-256 first (store-check.ts). Windows checks the publisher's signature itself.
+import { runScriptWithJsonAsync } from '../runtime/process.js';
+import { tool } from '../toolchains/tool-env.js';
+import { checkedPackage } from './store-check.js';
+/** Where the PC left an app's package. */
+export function storePackageDir(appId) {
+    return tool('apps', appId + '.package');
+}
+/** Installs the app from its kept package; resolves when Windows has it. */
+export async function installStoreApp(appId, packageName) {
+    const { main, dependencies } = await checkedPackage(storePackageDir(appId));
+    await runScriptWithJsonAsync('install-store-package.ps1', 'ListFile', { main, dependencies }, [
+        '-PackageName',
+        packageName,
+    ]);
+}

package/dist/guest/apps/store-check.d.ts

@@ -0,0 +1,8 @@
+/** The SHA-256 of a file, read in pieces (the package is hundreds of MB). */
+export declare function fileSha256(file: string): Promise<string>;
+export interface CheckedPackage {
+    readonly main: string;
+    readonly dependencies: string[];
+}
+/** The package in `dir` when its manifest is valid and every file is there as hashed; throws otherwise. */
+export declare function checkedPackage(dir: string): Promise<CheckedPackage>;

package/dist/guest/apps/store-check.js

@@ -0,0 +1,33 @@
+// The package files of a Store app the PC left in the data folder, checked against the SHA-256 in store-package.json.
+// No runtime imports: the self-test loads this file.
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { STORE_PACKAGE_MANIFEST, StorePackageManifestSchema } from '../../shared/apps/store-package.js';
+import { readValid } from '../../shared/io/json.js';
+const READ_CHUNK = 1024 * 1024;
+/** The SHA-256 of a file, read in pieces (the package is hundreds of MB). */
+export function fileSha256(file) {
+    return new Promise((resolve, reject) => {
+        const hash = crypto.createHash('sha256');
+        const stream = fs.createReadStream(file, { highWaterMark: READ_CHUNK });
+        stream.on('data', (chunk) => hash.update(chunk));
+        stream.on('error', reject);
+        stream.on('end', () => resolve(hash.digest('hex')));
+    });
+}
+/** The package in `dir` when its manifest is valid and every file is there as hashed; throws otherwise. */
+export async function checkedPackage(dir) {
+    const manifest = readValid(StorePackageManifestSchema, path.join(dir, STORE_PACKAGE_MANIFEST));
+    if (!manifest)
+        throw new Error('the package was not handed over (this PC could not fetch it: see the launch notes)');
+    for (const f of manifest.files) {
+        if ((await fileSha256(path.join(dir, f.name)).catch(() => '')) !== f.sha256)
+            throw new Error(f.name + ' is missing or changed');
+    }
+    const full = (name) => path.join(dir, name);
+    return {
+        main: full(manifest.files.find((f) => f.role === 'main').name),
+        dependencies: manifest.files.filter((f) => f.role === 'dependency').map((f) => full(f.name)),
+    };
+}

package/dist/guest/boot/boot.js

@@ -99,7 +99,7 @@ function writeDbCommand() {
     writeDevToolCommands(dir);
     return dir;
 }
-/** sbx-steam, sbx-fivem, sbx-unity, sbx-android for the toolchains that are on: runtime\tool.js with that helper. */
+/** sbx-steam, sbx-fivem, sbx-android for the toolchains that are on: runtime\tool.js with that helper. */
 function writeDevToolCommands(dir) {
     const script = path.join(path.dirname(process.argv[1]), 'tool.js');
     for (const tool of devToolsFor(session.toolchains))

package/dist/guest/boot/guide.js

@@ -10,6 +10,9 @@ import { projectFolderLines, toolLines } from './guide-lines.js';
 import { sandboxScriptsDir } from '../../shared/scripts.js';
 import { findUproject, unrealGuideLines } from '../../shared/unreal/index.js';
 import { DISK } from '../toolchains/engines/unreal-engines.js';
+import { readValid } from '../../shared/io/json.js';
+import { UNITY_STATUS_FILE, UnityStatusSchema, unityGuideLines } from '../../shared/unity/index.js';
+import { tool } from '../toolchains/tool-env.js';
 import { readUnrealStatus } from '../toolchains/engines/unreal-status.js';
 const BEGIN = '<!-- agent-sandbox:begin (generated every boot, do not edit) -->';
 const END = '<!-- agent-sandbox:end -->';
@@ -48,6 +51,20 @@ function unrealLines(projects) {
         .filter((f) => status.projects.some((p) => p.workspace.toLowerCase() === f.toLowerCase()))
         .map((f) => ({ workspace: f, uproject: findUproject(f, DISK) })), { mixamo: { downloads: path.join(dataDir, 'downloads'), script: mixamoScript() } });
 }
+/** The Unity lines (editor per project, build/test/import commands) when the sandbox is set up for Unity. */
+function unityLines(projects) {
+    const any = session.toolchains.unity.enabled === true || projects.some((p) => p.tools?.some((t) => /^unity/.test(t)));
+    if (!any)
+        return [];
+    const status = readValid(UnityStatusSchema, path.join(tool('unity'), UNITY_STATUS_FILE));
+    if (!status?.updatedAt)
+        return [];
+    const folders = [workspace, ...projects.map((p) => p.guest)];
+    return unityGuideLines(status, folders
+        .filter((f, i) => folders.findIndex((g) => g.toLowerCase() === f.toLowerCase()) === i)
+        .filter((f) => status.projects.some((p) => p.workspace.toLowerCase() === f.toLowerCase()))
+        .map((f) => ({ workspace: f })));
+}
 /** Deliberately tiny: it is loaded into every conversation. */
 export function sandboxGuide(toolSummary, lan = 'blocked', projects = [], addons = []) {
     return [
@@ -69,6 +86,7 @@ export function sandboxGuide(toolSummary, lan = 'blocked', projects = [], addons
         ...mirrorLine(),
         ...toolLines(session.project, toolSummary, projects),
         ...unrealLines(projects),
+        ...unityLines(projects),
         // Agent add-ons that change how the agent works (rtk, Headroom, MCP servers, ccusage).
         ...addons,
         '- Persistent installs: `npm i -g` (per nvm version), `pip`, `cargo install`, `dotnet tool -g`, `uv tool`, `bun add -g`. Real installers must re-run each boot via a hook (ask the user).',

package/dist/guest/browser/comet.d.ts

@@ -1,5 +1,5 @@
 import { type CometPayload } from '../../shared/accounts/kinds/comet.js';
-import { type DevToolsEndpoint } from './cdp.js';
+import { CdpConnection, type DevToolsEndpoint } from './cdp.js';
 /** The port comet-mcp looks for (it connects to a Comet already listening there). */
 export declare const COMET_MCP_PORT = 9222;
 /** The addresses whose cookies are read back (their cookies and the parent domain's). */
@@ -16,6 +16,8 @@ export declare function cometLaunchArgs(port: number, profile?: string): string[
 export declare function cometShortcutArgs(port: number, profile?: string): string;
 /** Where a Comet running with this profile listens, from its DevToolsActivePort file; null when there is none. */
 export declare function devToolsEndpoint(profile?: string): DevToolsEndpoint | null;
+/** A connection to the Comet running with this profile, or null when none answers. */
+export declare function connect(profile: string): Promise<CdpConnection | null>;
 /**
  * The sign-in the running Comet holds now (perplexity.ai's own cookies, asked of one of its pages), or null when
  * Comet is not running with this profile, has no page open, or holds no sign-in. Never asks for another site's cookies.

package/dist/guest/browser/comet.js

@@ -56,7 +56,7 @@ export function devToolsEndpoint(profile = cometProfileDir()) {
     return bytes ? parseDevToolsActivePort(bytes.toString('utf8')) : null;
 }
 /** A connection to the Comet running with this profile, or null when none answers. */
-async function connect(profile) {
+export async function connect(profile) {
     const endpoint = devToolsEndpoint(profile);
     if (!endpoint)
         return null;

package/dist/guest/browser/perplexity-app.d.ts

@@ -0,0 +1,12 @@
+import { type CometPayload } from '../../shared/accounts/kinds/comet.js';
+/** The app's profile: on the sandbox's own disk, wiped with it. */
+export declare function perplexityAppProfileDir(): string;
+/**
+ * The powershell.exe arguments of the app's shortcut: start-store-app.ps1 with the package, the profile and a free
+ * DevTools port (0). `script` is the full path of the script in the launch folder.
+ */
+export declare function perplexityAppShortcutArgs(script: string, profile?: string): string;
+/** The sign-in the running app holds now, or null (not running with this profile, no page, signed out). */
+export declare function readAppSignIn(profile?: string): Promise<CometPayload | null>;
+/** Writes the sign-in into the running app; false when the app is not running with this profile. */
+export declare function restoreAppSignIn(payload: CometPayload, profile?: string): Promise<boolean>;

package/dist/guest/browser/perplexity-app.js

@@ -0,0 +1,60 @@
+// The Perplexity desktop app (a Microsoft Store package, Electron inside) in this sandbox: the profile folder it runs
+// with, the command line of its shortcut, and its sign-in over the DevTools port, the way Comet's is kept
+// (browser/comet.ts): only the allow-listed perplexity.ai cookies are read (Network.getCookies) and written back
+// (Storage.setCookies). The profile is on the sandbox's own disk: its cookie key is sealed to this sandbox's Windows
+// user, which is why the sign-in is not copied from the PC. No runtime imports: the sign-in adapter and the self-test
+// load this file.
+import fs from 'node:fs';
+import path from 'node:path';
+import { cookiesToRestore } from '../../shared/accounts/kinds/comet.js';
+import { PERPLEXITY_DESKTOP_PACKAGE } from '../../shared/apps/catalogue-agents-web.js';
+import { localAppData } from '../accounts/adapter.js';
+import { connect, readCometSignIn } from './comet.js';
+/** The app's profile: on the sandbox's own disk, wiped with it. */
+export function perplexityAppProfileDir() {
+    return path.join(localAppData(), 'AgentSandbox', 'perplexity-app-profile');
+}
+/**
+ * The powershell.exe arguments of the app's shortcut: start-store-app.ps1 with the package, the profile and a free
+ * DevTools port (0). `script` is the full path of the script in the launch folder.
+ */
+export function perplexityAppShortcutArgs(script, profile = perplexityAppProfileDir()) {
+    return [
+        '-NoLogo',
+        '-NoProfile',
+        '-WindowStyle',
+        'Hidden',
+        '-ExecutionPolicy',
+        'Bypass',
+        '-File',
+        '"' + script + '"',
+        '-PackageName',
+        PERPLEXITY_DESKTOP_PACKAGE,
+        '-UserDataDir',
+        '"' + profile + '"',
+        '-Port',
+        '0',
+    ].join(' ');
+}
+/** The sign-in the running app holds now, or null (not running with this profile, no page, signed out). */
+export function readAppSignIn(profile = perplexityAppProfileDir()) {
+    return readCometSignIn(profile);
+}
+/** Writes the sign-in into the running app; false when the app is not running with this profile. */
+export async function restoreAppSignIn(payload, profile = perplexityAppProfileDir()) {
+    const cookies = cookiesToRestore(payload, Math.floor(Date.now() / 1000));
+    if (!cookies.length)
+        return true;
+    if (!fs.existsSync(path.join(profile, 'DevToolsActivePort')))
+        return false;
+    const cdp = await connect(profile);
+    if (!cdp)
+        return false;
+    try {
+        await cdp.call('Storage.setCookies', { cookies });
+        return true;
+    }
+    finally {
+        cdp.close();
+    }
+}

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,36 @@
+// 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 {
+        await execAsync(unityExe, ['skill', 'sync', agent], { 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/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;