windows-development-sandbox 1.25.1 → 1.27.0

package/dist/app/features/unity/unity.run.js

@@ -0,0 +1,363 @@
+// The Unity area's work: what the sandbox last found (tools\unity\status.json, written by the guest, so it is read with
+// its schema and its text made safe), what this PC has that the next sandbox maps (its editors and Asset Store
+// downloads: bounded reads), opening Unity Hub and signing in (exec requests in the running sandbox) and adding or
+// removing the editor bridge in a project's Packages/manifest.json (only on request, after a confirmation).
+import fs from 'node:fs';
+import path from 'node:path';
+import { humanBytes } from '../../../core/disk.js';
+import { assertNoLinks, errMsg, fail, safeText } from '../../../core/util/index.js';
+import { ProjectsService } from '../../../cli/services/projects-service.js';
+import { SandboxChannel } from '../../../host/channel/index.js';
+import { isSandboxRunning } from '../../../host/sandbox/index.js';
+import { pcEnv } from '../../../host/accounts/index.js';
+import { assetCacheEnv, findUnityEditorsOnPc, unityAssetCacheDirs, unityPcFiles, } from '../../../host/pc-installs/unity.js';
+import { readBoundedFile, readValid, writeFileAtomic } from '../../../shared/io/index.js';
+import { RunDir } from '../../../shared/channel/index.js';
+import { assetPackages, bridgeOf, COPLAY_PACKAGE_URL, DEFAULT_PIPELINE_VERSION, ORIGIN_LABELS, parseProjectVersion, supportsPipeline, UNITY_STATUS_FILE, UnityStatusSchema, withBridge, } from '../../../shared/unity/index.js';
+import { implement } from '../../context.js';
+import { addEditorBridge, openUnityHub, removeEditorBridge, unityOverview, unitySignIn, } from './unity.def.js';
+const win = path.win32;
+const MAX_PACKAGES_SHOWN = 40;
+const MAX_MANIFEST_READ = 1024 * 1024 + 1;
+const PIPELINE_INDEX_URL = 'https://packages.unity.com/com.unity.pipeline';
+const MAX_INDEX_BYTES = 2 * 1024 * 1024;
+const GUEST_EXPLORER = 'C:\\Windows\\explorer.exe';
+const SEMVER = /^\d{1,6}\.\d{1,6}\.\d{1,6}(-[0-9A-Za-z.-]{1,50})?(\+[0-9A-Za-z.-]{1,50})?$/;
+const s = (text) => safeText(text);
+const sn = (text) => (text === null ? null : safeText(text));
+export function readStatus(dataPath) {
+    const file = path.join(dataPath, 'tools', 'unity', UNITY_STATUS_FILE);
+    try {
+        assertNoLinks(dataPath, file);
+    }
+    catch {
+        return null; // A link under the data folder: never followed.
+    }
+    return readValid(UnityStatusSchema, file);
+}
+const settingText = (v) => (Array.isArray(v) ? v.join(', ') || 'none' : String(v));
+/** The overview from the sandbox's status and this PC's own look (no sandbox needed). */
+export function unityOverviewOf(ctx, status, pcLook, hostFolders = []) {
+    const config = ctx.loaded.config;
+    let pc = { editors: [], assets: [] };
+    let problem = null;
+    try {
+        pc = pcLook();
+    }
+    catch (e) {
+        problem = 'Could not look at this PC: ' + errMsg(e);
+    }
+    const u = config.toolchains.unity;
+    const hostFolderOf = (workspace) => {
+        const name = win.basename(workspace).toLowerCase();
+        const same = hostFolders.filter((f) => win.basename(f).toLowerCase() === name);
+        return same.length === 1 ? same[0] : null;
+    };
+    const editorLabel = (root) => {
+        if (root === null)
+            return null;
+        const e = status?.editors.find((x) => x.root.toLowerCase() === root.toLowerCase());
+        return s(e ? 'Unity ' + e.version : root);
+    };
+    return {
+        setUp: status !== null,
+        checkedAt: status ? s(status.updatedAt) : null,
+        cli: status?.cli ? { version: s(status.cli.version), path: s(status.cli.path) } : null,
+        editors: (status?.editors ?? []).map((e) => ({
+            version: s(e.version),
+            dir: s(e.root),
+            where: ORIGIN_LABELS[e.origin],
+            writable: e.writable,
+            modules: e.modules.map(s),
+            sizeBytes: e.sizeBytes,
+            projects: (status?.projects ?? [])
+                .filter((p) => p.editor?.toLowerCase() === e.root.toLowerCase())
+                .map((p) => s(win.basename(p.workspace))),
+        })),
+        projects: (status?.projects ?? []).map((p) => ({
+            project: s(win.basename(p.workspace)),
+            folder: hostFolderOf(p.workspace),
+            version: sn(p.version),
+            editor: editorLabel(p.editor),
+            reason: s(p.reason),
+            bridge: p.bridge,
+            pipeline: p.version !== null && supportsPipeline(p.version),
+        })),
+        licence: {
+            state: status?.licence.state ?? 'unknown',
+            kind: s(status?.licence.kind ?? ''),
+            detail: s(status?.licence.detail ?? ''),
+            user: sn(status?.licence.user ?? null),
+        },
+        hub: { installed: status?.hub.installed ?? false, setting: u.hub },
+        assetCache: { mode: status?.assetCache.mode ?? u.assetCache, dir: sn(status?.assetCache.dir ?? null) },
+        agentTools: {
+            cliVersion: u.cliVersion,
+            mcp: sn(status?.mcp ?? null),
+            mcpSetting: u.mcp,
+            skills: status?.skills ?? false,
+            skillsSetting: u.agentSkills,
+        },
+        pc: { setting: settingText(config.pcInstalls.unityEditors), editors: pc.editors, problem },
+        assets: { setting: settingText(config.pcInstalls.unityAssets), folders: pc.assets },
+        problem: sn(status?.problem ?? null),
+        settings: {
+            enabled: settingText(u.enabled),
+            acceptLicense: u.acceptLicense,
+            version: u.version,
+            modules: settingText(u.modules),
+            hub: u.hub,
+            keepVersions: u.keepVersions,
+            mcp: u.mcp,
+            agentSkills: u.agentSkills,
+            cliVersion: u.cliVersion,
+            assetCache: u.assetCache,
+        },
+    };
+}
+/** This PC's disk for the packages (bounded lists). */
+export const PC_ASSET_FS = {
+    list: (dir) => {
+        try {
+            return fs.readdirSync(dir).slice(0, 5000);
+        }
+        catch {
+            return []; // Not a folder: nothing in it.
+        }
+    },
+    isDir: (dir) => {
+        try {
+            return fs.lstatSync(dir).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    },
+    size: (file) => {
+        try {
+            const st = fs.lstatSync(file);
+            return st.isFile() ? st.size : null;
+        }
+        catch {
+            return null;
+        }
+    },
+};
+/** What this PC has for the next sandbox: its editors and its Asset Store packages. */
+function lookAtPc(ctx) {
+    const config = ctx.loaded.config.pcInstalls;
+    const pc = pcEnv();
+    const files = unityPcFiles(pc);
+    const editors = config.unityEditors === false
+        ? []
+        : findUnityEditorsOnPc(files, Array.isArray(config.unityEditors) ? config.unityEditors.map(String) : true).map((e) => ({ version: e.id, folder: e.host }));
+    const assets = config.unityAssets === false
+        ? []
+        : unityAssetCacheDirs(files, assetCacheEnv(pc)).map((folder) => {
+            const packages = assetPackages(folder, PC_ASSET_FS);
+            return {
+                folder,
+                packages: packages.slice(0, MAX_PACKAGES_SHOWN).map((p) => ({
+                    publisher: p.publisher,
+                    category: p.category,
+                    name: p.name,
+                    size: humanBytes(p.sizeBytes),
+                })),
+                more: Math.max(0, packages.length - MAX_PACKAGES_SHOWN),
+            };
+        });
+    return { editors, assets };
+}
+export const unityOverviewRun = implement(unityOverview, async (ctx) => {
+    let hostFolders = [];
+    try {
+        hostFolders = (await new ProjectsService(ctx).list()).projects.map((p) => p.folder);
+    }
+    catch {
+        // No project list: the page shows the projects without bridge buttons.
+    }
+    return unityOverviewOf(ctx, readStatus(ctx.dataPath), () => lookAtPc(ctx), hostFolders);
+});
+// ---- Unity Hub and sign-in (the running sandbox) ----
+async function inSandbox(ctx, argv, seconds) {
+    if (!isSandboxRunning())
+        fail('No sandbox is running.', 'Start one for a Unity project; Unity opens in its window.');
+    const status = new RunDir(ctx.dataPath).readSandboxStatus();
+    if (status?.phase !== 'ready')
+        fail('The sandbox is not ready yet.', 'Try again in a moment.');
+    const result = await new SandboxChannel(ctx.dataPath).exec(argv, status.guestWorkspace ?? 'C:\\', seconds);
+    // explorer.exe returns 1 even when it started the program.
+    if (!result.ok && !(argv[0] === GUEST_EXPLORER && result.exitCode === 1))
+        fail('The sandbox could not do it: ' + safeText(result.message));
+}
+export const openUnityHubRun = implement(openUnityHub, async (ctx, _input, io) => {
+    const hub = readStatus(ctx.dataPath)?.hub;
+    if (!hub?.installed || !hub.path)
+        fail('Unity Hub is not installed in this sandbox.', 'Turn on Unity Hub in the Unity set-up settings and restart.');
+    io.progress('Opening Unity Hub in the sandbox…');
+    await inSandbox(ctx, [GUEST_EXPLORER, hub.path], 30);
+    return {
+        message: 'Unity Hub opens in the sandbox window. Sign in once; the licence is kept for the next sandboxes.',
+    };
+});
+export const unitySignInRun = implement(unitySignIn, async (ctx, _input, io) => {
+    const status = readStatus(ctx.dataPath);
+    io.progress('Opening the Unity sign-in in the sandbox…');
+    if (status?.hub.installed && status.hub.path)
+        await inSandbox(ctx, [GUEST_EXPLORER, status.hub.path], 30);
+    else if (status?.cli)
+        await inSandbox(ctx, [status.cli.path, 'auth', 'login'], 300);
+    else
+        fail('Unity is not set up in a sandbox yet.', 'Start a sandbox for a Unity project first.');
+    return { message: 'Sign in in the sandbox window; the licence is kept for the next sandboxes.' };
+});
+// ---- The editor bridge ----
+/** The newest Unity Pipeline package version, from Unity's package registry (bounded, checked as a version). */
+export async function latestPipelineVersion(fetcher = fetch) {
+    const response = await fetcher(PIPELINE_INDEX_URL, { signal: AbortSignal.timeout(15_000) });
+    if (!response.ok)
+        throw new Error('Unity answered ' + response.status);
+    const reader = response.body?.getReader();
+    if (!reader)
+        throw new Error('Unity sent nothing');
+    const chunks = [];
+    let total = 0;
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        total += value.length;
+        if (total > MAX_INDEX_BYTES) {
+            await reader.cancel();
+            throw new Error('the package list is over 2 MB');
+        }
+        chunks.push(Buffer.from(value));
+    }
+    const json = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    const latest = json?.['dist-tags']?.latest;
+    if (typeof latest !== 'string' || !SEMVER.test(latest))
+        throw new Error('no usable version in the package list');
+    return latest;
+}
+/** A project of this PC: its manifest file and the editor version it asks for. */
+export function unityProjectProblem(dir) {
+    if (!win.isAbsolute(dir))
+        return 'Give the full path of the Unity project folder.';
+    const version = readBoundedFile(win.join(dir, 'ProjectSettings', 'ProjectVersion.txt'), 64 * 1024);
+    if (!version || !parseProjectVersion(version.toString('utf8')))
+        return dir + ' is not a Unity project (no ProjectSettings\\ProjectVersion.txt).';
+    return readBoundedFile(win.join(dir, 'Packages', 'manifest.json'), MAX_MANIFEST_READ)
+        ? null
+        : dir + ' has no Packages\\manifest.json.';
+}
+function manifestOf(dir) {
+    const problem = unityProjectProblem(dir);
+    if (problem)
+        fail(problem, 'Pick the folder that has ProjectSettings and Packages in it.');
+    const file = win.join(dir, 'Packages', 'manifest.json');
+    assertNoLinks(dir, file);
+    const text = readBoundedFile(file, MAX_MANIFEST_READ).toString('utf8');
+    const version = parseProjectVersion(readBoundedFile(win.join(dir, 'ProjectSettings', 'ProjectVersion.txt'), 64 * 1024).toString('utf8'));
+    return { file, text, unity: version.version };
+}
+/** Adds the editor bridge to a project's manifest after the confirmation; the rest of the file is kept. */
+export async function addBridgeToProject(dir, wanted, hooks) {
+    const { file, text, unity } = manifestOf(dir);
+    const have = bridgeOf(text);
+    if (have)
+        return { file, message: win.basename(dir) + ' has the editor bridge already (' + bridgeName(have) + ').' };
+    const pipeline = supportsPipeline(unity);
+    const bridge = wanted ?? (pipeline ? 'pipeline' : 'coplay');
+    if (bridge === 'pipeline' && !pipeline)
+        fail('Unity ' + unity + ' cannot take the Unity Pipeline package.', 'It needs Unity 6 or later: use the other bridge.');
+    let version = DEFAULT_PIPELINE_VERSION;
+    let note = '';
+    if (bridge === 'pipeline') {
+        try {
+            version = await hooks.pipelineVersion();
+        }
+        catch (e) {
+            note = ' (could not ask Unity for the newest version: ' + errMsg(e) + '; used ' + version + ')';
+        }
+    }
+    const what = bridge === 'pipeline'
+        ? 'com.unity.pipeline ' + version
+        : 'MCP for Unity (' + COPLAY_PACKAGE_URL.split('?')[0] + ')';
+    if (!(await hooks.confirm(file, what)))
+        return { file, message: 'Nothing was changed.' };
+    writeFileAtomic(file, withBridge(text, bridge, true, version));
+    return {
+        file,
+        message: 'Added ' +
+            what +
+            ' to ' +
+            file +
+            note +
+            '.' +
+            (bridge === 'coplay' ? ' Turn on MCP for Unity in Apps so agents can reach it.' : ''),
+    };
+}
+/** Takes the editor bridge out of a project's manifest after the confirmation. */
+export async function removeBridgeFromProject(dir, hooks) {
+    const { file, text } = manifestOf(dir);
+    const have = bridgeOf(text);
+    if (!have)
+        return { file, message: win.basename(dir) + ' has no editor bridge.' };
+    if (!(await hooks.confirm(file, 'remove ' + bridgeName(have))))
+        return { file, message: 'Nothing was changed.' };
+    writeFileAtomic(file, withBridge(text, have, false));
+    return { file, message: 'Removed ' + bridgeName(have) + ' from ' + file + '.' };
+}
+const bridgeName = (b) => (b === 'pipeline' ? 'Unity Pipeline' : 'MCP for Unity');
+async function projectOf(ctx, given, io) {
+    if (given)
+        return win.resolve(given);
+    let known = [];
+    try {
+        known = (await new ProjectsService(ctx).list()).projects
+            .map((p) => p.folder)
+            .filter((f) => unityProjectProblem(f) === null);
+    }
+    catch {
+        // No project list: ask for the folder.
+    }
+    if (known.length === 1)
+        return known[0];
+    if (known.length > 1) {
+        const picked = await io.choose({
+            title: 'Which Unity project?',
+            lines: [],
+            choices: known.map((f) => ({ value: f, label: win.basename(f), hint: f })),
+        });
+        if (picked)
+            return picked;
+    }
+    const dir = await io.path({
+        title: 'Which Unity project folder?',
+        lines: ['The folder that holds Assets, Packages and ProjectSettings.'],
+        pathKind: 'dir',
+        validate: (v) => unityProjectProblem(win.resolve(v)) ?? true,
+    });
+    if (!dir)
+        fail('No folder given.', 'Nothing was changed.');
+    return win.resolve(dir);
+}
+export const addBridgeRun = implement(addEditorBridge, async (ctx, input, io) => {
+    const dir = await projectOf(ctx, input.project, io);
+    const edit = await addBridgeToProject(dir, input.bridge, {
+        pipelineVersion: () => latestPipelineVersion(),
+        confirm: (file, what) => io.confirm({
+            title: 'Change the project?',
+            lines: ['This adds ' + what + ' to ' + file + '.', 'Nothing else in the project changes.'],
+            yes: 'Add',
+        }),
+    });
+    return { message: edit.message };
+});
+export const removeBridgeRun = implement(removeEditorBridge, async (ctx, input, io) => {
+    const dir = await projectOf(ctx, input.project, io);
+    const edit = await removeBridgeFromProject(dir, {
+        confirm: (file, what) => io.confirm({ title: 'Change the project?', lines: ['This will ' + what + ' in ' + file + '.'], yes: 'Remove' }),
+    });
+    return { message: edit.message };
+});

package/dist/app/registry.js

@@ -21,6 +21,7 @@ import { vpnLoginRun, vpnLogoutRun, vpnStatusRun } from './features/vpn/index.js
 import { githubLoginRun, githubLogoutRun, githubStatusRun } from './features/github/index.js';
 import { accessStatusRun, allowDeviceRun, lanOffRun, lanOnRun, revokeAccessRun, revokeAllAccessRun, } from './features/access/index.js';
 import { forgetEngineFolderRun, openEpicLauncherRun, registerEngineFolderRun, unrealOverviewRun, } from './features/unreal/index.js';
+import { addBridgeRun, openUnityHubRun, removeBridgeRun, unityOverviewRun, unitySignInRun, } from './features/unity/index.js';
 export const IMPLEMENTATIONS = [
     sandboxStatusRun,
     showWindowRun,
@@ -114,6 +115,11 @@ export const IMPLEMENTATIONS = [
     registerEngineFolderRun,
     forgetEngineFolderRun,
     openEpicLauncherRun,
+    unityOverviewRun,
+    openUnityHubRun,
+    unitySignInRun,
+    addBridgeRun,
+    removeBridgeRun,
 ];
 export function implementationOf(id) {
     return IMPLEMENTATIONS.find((i) => i.def.id === id);

package/dist/bin/agent-sandbox.js

@@ -2,8 +2,8 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   run
-} from "./chunk-3GAXLATK.js";
-import "./chunk-F4PVBN23.js";
+} from "./chunk-JXL6ZOO3.js";
+import "./chunk-6WWMBCT2.js";
 
 // src/bin/agent-sandbox.ts
 run(process.argv.slice(2));