windows-development-sandbox 1.25.1 → 1.27.1

package/dist/shared/unity/status.js

@@ -0,0 +1,45 @@
+// What the sandbox last found for Unity (tools\unity\status.json): the CLI, the editors, which editor each project
+// opens with, the licence, the Asset Store cache. The sandbox writes it; the Unity page on this PC reads it with this
+// schema (bounded strings and lists) and prints its text through safeText.
+import { z } from 'zod';
+/** The file in tools\unity. */
+export const UNITY_STATUS_FILE = 'status.json';
+const Text = (max = 400) => z.string().max(max);
+export const UnityStatusSchema = z.object({
+    updatedAt: Text(40),
+    cli: z.object({ version: Text(40), path: Text() }).nullable(),
+    editors: z
+        .array(z.object({
+        version: Text(40),
+        root: Text(),
+        origin: z.enum(['pc', 'data']),
+        writable: z.boolean(),
+        modules: z.array(Text(60)).max(20),
+        sizeBytes: z.number().int().min(0).nullable(),
+    }))
+        .max(32),
+    projects: z
+        .array(z.object({
+        workspace: Text(),
+        /** The version its ProjectVersion.txt asks for. */
+        version: Text(40).nullable(),
+        /** The root of the editor it opens with, null when there is none for it. */
+        editor: Text().nullable(),
+        reason: Text(),
+        bridge: z.enum(['pipeline', 'coplay']).nullable(),
+    }))
+        .max(64),
+    licence: z.object({
+        state: z.enum(['active', 'none', 'invalid', 'unknown']),
+        kind: Text(60),
+        detail: Text(),
+        user: Text(256).nullable(),
+    }),
+    assetCache: z.object({ mode: z.enum(['persisted', 'pc', 'local']), dir: Text().nullable() }),
+    pcAssets: z.array(Text()).max(4),
+    hub: z.object({ installed: z.boolean(), path: Text().nullable() }),
+    /** The MCP server's name when it was registered. */
+    mcp: Text(100).nullable(),
+    skills: z.boolean(),
+    problem: Text(600).nullable(),
+});

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

@@ -0,0 +1,27 @@
+export declare const UNITY_VERSION: RegExp;
+/** A changeset (short revision) as Unity prints it. */
+export declare const UNITY_CHANGESET: RegExp;
+export interface UnityVersion {
+    readonly major: number;
+    readonly minor: number;
+    readonly patch: number;
+    /** a (alpha), b (beta), f (final), p (patch). */
+    readonly stage: 'a' | 'b' | 'f' | 'p';
+    readonly build: number;
+}
+export declare function parseUnityVersion(text: string): UnityVersion | null;
+/** Negative when a is older than b, 0 when equal; an unreadable version sorts first. */
+export declare function compareUnityVersions(a: string, b: string): number;
+export interface ProjectVersion {
+    readonly version: string;
+    readonly changeset: string | null;
+}
+/** The editor a ProjectVersion.txt asks for: m_EditorVersion, and the changeset of m_EditorVersionWithRevision. */
+export declare function parseProjectVersion(text: string): ProjectVersion | null;
+/**
+ * The editor to open a project with: its own ProjectVersion.txt always wins (another version upgrades its files); the
+ * setting's version ("project" or e.g. "6000.0.32f1") is only for folders without one.
+ */
+export declare function wantedVersion(projectFile: string | null, setting: string): ProjectVersion | null;
+/** The Unity Pipeline package (and so `unity command` / `unity eval`) needs Unity 6 or later. */
+export declare function supportsPipeline(version: string): boolean;

package/dist/shared/unity/version.js

@@ -0,0 +1,75 @@
+// Unity editor versions ("6000.0.58f2") and the ProjectSettings/ProjectVersion.txt that names one. Pure; the text read
+// from a project is bounded (the first 50 lines of at most 64 KB).
+export const UNITY_VERSION = /^(\d{1,4})\.(\d{1,3})\.(\d{1,3})([abfp])(\d{1,3})$/;
+/** A changeset (short revision) as Unity prints it. */
+export const UNITY_CHANGESET = /^[0-9a-f]{12}$/;
+const MAX_PROJECT_VERSION_BYTES = 64 * 1024;
+const MAX_PROJECT_VERSION_LINES = 50;
+const STAGES = 'abfp';
+export function parseUnityVersion(text) {
+    const m = UNITY_VERSION.exec(text);
+    if (!m)
+        return null;
+    return {
+        major: Number(m[1]),
+        minor: Number(m[2]),
+        patch: Number(m[3]),
+        stage: m[4],
+        build: Number(m[5]),
+    };
+}
+/** Negative when a is older than b, 0 when equal; an unreadable version sorts first. */
+export function compareUnityVersions(a, b) {
+    const x = parseUnityVersion(a);
+    const y = parseUnityVersion(b);
+    if (!x || !y)
+        return x ? 1 : y ? -1 : a.localeCompare(b);
+    return (x.major - y.major ||
+        x.minor - y.minor ||
+        x.patch - y.patch ||
+        STAGES.indexOf(x.stage) - STAGES.indexOf(y.stage) ||
+        x.build - y.build);
+}
+/** The editor a ProjectVersion.txt asks for: m_EditorVersion, and the changeset of m_EditorVersionWithRevision. */
+export function parseProjectVersion(text) {
+    let version = null;
+    let changeset = null;
+    const lines = text.slice(0, MAX_PROJECT_VERSION_BYTES).split('\n', MAX_PROJECT_VERSION_LINES);
+    for (const raw of lines) {
+        const line = raw.replace(/^\uFEFF/, '').trim();
+        if (line.startsWith('m_EditorVersionWithRevision:')) {
+            const rest = line.slice('m_EditorVersionWithRevision:'.length).trim();
+            const open = rest.indexOf('(');
+            const close = rest.indexOf(')', open);
+            const v = (open < 0 ? rest : rest.slice(0, open)).trim();
+            if (UNITY_VERSION.test(v))
+                version ??= v;
+            if (open >= 0 && close > open) {
+                const cs = rest.slice(open + 1, close).trim();
+                if (UNITY_CHANGESET.test(cs))
+                    changeset = cs;
+            }
+        }
+        else if (line.startsWith('m_EditorVersion:')) {
+            const v = line.slice('m_EditorVersion:'.length).trim();
+            if (UNITY_VERSION.test(v))
+                version = v;
+        }
+    }
+    return version ? { version, changeset } : null;
+}
+/**
+ * The editor to open a project with: its own ProjectVersion.txt always wins (another version upgrades its files); the
+ * setting's version ("project" or e.g. "6000.0.32f1") is only for folders without one.
+ */
+export function wantedVersion(projectFile, setting) {
+    const own = projectFile === null ? null : parseProjectVersion(projectFile);
+    if (own)
+        return own;
+    return setting !== 'project' && UNITY_VERSION.test(setting) ? { version: setting, changeset: null } : null;
+}
+/** The Unity Pipeline package (and so `unity command` / `unity eval`) needs Unity 6 or later. */
+export function supportsPipeline(version) {
+    const v = parseUnityVersion(version);
+    return v !== null && v.major >= 6000;
+}

package/dist/shared/unreal/status.d.ts

@@ -28,6 +28,7 @@ export declare const UnrealStatusSchema: z.ZodObject<{
     }, z.core.$strip>>;
     launcher: z.ZodObject<{
         installed: z.ZodBoolean;
+        exe: z.ZodDefault<z.ZodNullable<z.ZodString>>;
         installLocation: z.ZodNullable<z.ZodString>;
         problem: z.ZodNullable<z.ZodString>;
         freeBytes: z.ZodNullable<z.ZodNumber>;

package/dist/shared/unreal/status.js

@@ -30,6 +30,8 @@ export const UnrealStatusSchema = z.object({
         .max(64),
     launcher: z.object({
         installed: z.boolean(),
+        /** Its program (Program Files or Program Files (x86), by launcher version); null when there is none. */
+        exe: Text().nullable().default(null),
         /** Where the launcher installs engines; null when it could not be set. */
         installLocation: Text().nullable(),
         /** Why engines would not go to the data disk (shown loudly), null when they do. */

package/dist/web/index.html

@@ -6,7 +6,7 @@
     <title>Sandbox</title>
     <link rel="icon" href="data:," />
     <link rel="stylesheet" href="/main-XT7T6ODM.css" />
-    <script type="module" src="/main-FNE6XEHA.js"></script>
+    <script type="module" src="/main-VPMYTSUL.js"></script>
   </head>
   <body>
     <div id="root"></div>