windows-development-sandbox 1.18.3 → 1.20.0

package/dist/guest/agents/agent-files.js

@@ -15,19 +15,19 @@ export function agentCommand(name, harness) {
     return harness.npmBin ?? harness.uvBin ?? (harness.hostExecutable ?? name).replace(/\.exe$/i, '');
 }
 /** One shim per configured agent that can be installed here (a name that is not a plain command word is skipped). */
-export function agentShims(toolsDir, agents) {
+export function agentShims(toolsDir, agents, flags = {}) {
     return Object.entries(agents).flatMap(([name, harness]) => {
         const p = agentPaths(toolsDir, name, harness);
         const target = p.exe ?? p.cmd;
         const command = agentCommand(name, harness);
         return target && /^[A-Za-z0-9_-]+$/.test(command) && /^[A-Za-z0-9_-]+$/.test(name)
-            ? [{ name, command, target }]
+            ? [{ name, command, target, ...(flags[name]?.length ? { arguments: flags[name] } : {}) }]
             : [];
     });
 }
 /**
  * The text of `<command>.cmd`: runs the installed agent, or installs it first (`install` = node + installer script).
- * The agent's own arguments pass through %* untouched.
+ * The agent's own arguments pass through %* untouched, after the shim's flags if it has any.
  */
 export function shimText(shim, install) {
     return [
@@ -39,7 +39,7 @@ export function shimText(shim, install) {
         '"' + install.node + '" "' + install.script + '" install ' + shim.name,
         'if errorlevel 1 exit /b 1',
         ':run',
-        'endlocal & "%SBX_REAL%" %*',
+        'endlocal & "%SBX_REAL%" ' + (shim.arguments?.length ? shim.arguments.join(' ') + ' ' : '') + '%*',
         '',
     ].join('\r\n');
 }
@@ -61,19 +61,89 @@ export function localStateEntries(agents, stateDir, localRoot) {
 export function bootResetPaths(agents, stateDir) {
     return Object.entries(agents).flatMap(([agent, harness]) => (harness.bootReset ?? []).map((rel) => ({ agent, path: path.join(stateDir, agent, rel) })));
 }
+/** The marker the sandbox puts above the lines it writes into config.toml. */
+const CODEX_MARKER = '# Set by the sandbox';
 /**
- * Codex's config.toml with its own command sandbox off, or null when it already says which one to use. Inside Windows
- * Sandbox that inner sandbox only costs: its setup re-grants ACLs over the whole profile at every boot (minutes), and
- * every command hangs until it is done. A `sandbox_mode` the user set (before the first [table]) is kept.
+ * The flags every Codex start gets. Flags beat config.toml and a resumed thread's saved permissions, which is why the
+ * sandbox does not rely on the file. Full access with no questions is the one flag that skips Codex's Windows sandbox
+ * setup for certain. Pure.
+ */
+export function codexArguments(c) {
+    const out = c.sandboxMode === 'danger-full-access' && c.approvalPolicy === 'never'
+        ? ['--dangerously-bypass-approvals-and-sandbox']
+        : ['--sandbox', c.sandboxMode, '--ask-for-approval', c.approvalPolicy];
+    if (c.model)
+        out.push('-c', 'model="' + c.model + '"');
+    if (c.reasoningEffort !== 'default')
+        out.push('-c', 'model_reasoning_effort="' + c.reasoningEffort + '"');
+    return out;
+}
+/** The arguments an agent always starts with: its own, and for codex the sandbox's settings. */
+export function agentArguments(name, harness, codex) {
+    return name === 'codex' && codex ? [...harness.arguments, ...codexArguments(codex)] : [...harness.arguments];
+}
+/** The largest config.toml the sandbox edits. */
+export const MAX_CODEX_CONFIG_BYTES = 1024 * 1024;
+/**
+ * Codex's config.toml as the sandbox wants it, every other line byte for byte: the lines an older version wrote above
+ * the first table (sandbox_mode, approval_policy, under the marker comment) are gone, `[windows] sandbox` follows
+ * windowsSandbox ("off" removes the line, so Codex does not set up its own sandbox users), and
+ * mcp_oauth_credentials_store = "file" is added when it is not set. Running it again changes nothing. Pure.
+ */
+export function codexConfigOwned(toml, c) {
+    const eol = toml.includes('\r\n') ? '\r\n' : '\n';
+    const firstTable = toml.search(/^[ \t]*\[/m);
+    let top = firstTable < 0 ? toml : toml.slice(0, firstTable);
+    const tables = firstTable < 0 ? '' : toml.slice(firstTable);
+    top = top.replace(MARKED_LINES, '');
+    if (c.mcpLoginsInFile && !/^[ \t]*mcp_oauth_credentials_store[ \t]*=/m.test(top)) {
+        if (top && !top.endsWith('\n'))
+            top += eol;
+        top += 'mcp_oauth_credentials_store = "file"' + eol + (tables ? eol : '');
+    }
+    return top + codexWindowsSandbox(tables, c.windowsSandbox, eol);
+}
+/** The lines an older version wrote above the first table: its marker comment, then sandbox_mode / approval_policy. */
+const MARKED_LINES = new RegExp('^' + CODEX_MARKER + '[^\r\n]*\r?\n(?:(?:sandbox_mode|approval_policy)[ \t]*=[^\r\n]*\r?\n)*(?:[ \t]*\r?\n)?', 'm');
+/** The tables of config.toml (from the first one on) with `[windows] sandbox` set to the mode, or removed for "off". */
+function codexWindowsSandbox(tables, mode, eol) {
+    const setting = 'sandbox = "' + mode + '"';
+    const header = /^[ \t]*\[windows\][ \t]*(#[^\r\n]*)?(\r?\n|$)/m.exec(tables);
+    if (!header) {
+        if (mode === 'off')
+            return tables;
+        const gap = tables && !tables.endsWith('\n') ? eol : '';
+        return tables + gap + (tables ? eol : '') + '[windows]' + eol + setting + eol;
+    }
+    const bodyStart = header.index + header[0].length;
+    const next = tables.slice(bodyStart).search(/^[ \t]*\[/m);
+    const bodyEnd = next < 0 ? tables.length : bodyStart + next;
+    const body = tables.slice(bodyStart, bodyEnd);
+    const line = /^[ \t]*sandbox[ \t]*=[^\r\n]*(\r?\n|$)/m.exec(body);
+    let updated;
+    if (!line)
+        updated = mode === 'off' ? body : setting + eol + body;
+    else if (mode === 'off')
+        updated = body.slice(0, line.index) + body.slice(line.index + line[0].length);
+    else
+        updated = body.slice(0, line.index) + setting + line[1] + body.slice(line.index + line[0].length);
+    const head = tables.slice(0, bodyStart);
+    return (head.endsWith('\n') || !updated ? head : head + eol) + updated + tables.slice(bodyEnd);
+}
+/**
+ * Codex's config.toml with its own command sandbox off, or null when that changes nothing. Kept for callers that
+ * predate the codex settings; use codexConfigOwned.
  */
 export function codexConfigWithoutSandbox(toml) {
-    const firstTable = toml.search(/^\s*\[/m);
-    const topLevel = firstTable < 0 ? toml : toml.slice(0, firstTable);
-    if (/^\s*sandbox_mode\s*=/m.test(topLevel))
-        return null;
-    return ('# Set by the sandbox: Windows Sandbox already contains Codex, its own command sandbox would only slow it down.\n' +
-        'sandbox_mode = "danger-full-access"\n' +
-        (toml ? '\n' + toml : ''));
+    const out = codexConfigOwned(toml, {
+        sandboxMode: 'danger-full-access',
+        approvalPolicy: 'never',
+        model: '',
+        reasoningEffort: 'default',
+        windowsSandbox: 'off',
+        mcpLoginsInFile: true,
+    });
+    return out === toml ? null : out;
 }
 /** A SQLite database file or one of its -wal / -shm siblings. */
 export const isDatabaseFile = (name) => /\.(sqlite3?|db)(-wal|-shm)?$/i.test(name);

package/dist/guest/agents/local-state.d.ts

@@ -5,8 +5,11 @@ export declare function agentLocalStates(): LocalState[];
 export declare function localStateVars(): Record<string, string>;
 /** Boot: what an agent sealed to the last sandbox (bootReset) is deleted, so it sets it up again. Links are left. */
 export declare function resetMachineBound(): void;
-/** Boot: Codex runs its commands without its own sandbox (codexConfigWithoutSandbox), unless the user picked one. */
-export declare function codexWithoutInnerSandbox(): void;
+/**
+ * Boot: Codex's config.toml follows the codex settings (codexConfigOwned): no Windows sandbox setup of its own, its MCP
+ * logins in a file. The sandbox mode itself travels as launch flags (codexArguments), which beat this file.
+ */
+export declare function codexBootConfig(): void;
 /** Boot: the saved databases of every configured agent are copied to the sandbox's disk, where the agent runs them. */
 export declare function restoreLocalState(): void;
 /**

package/dist/guest/agents/local-state.js

@@ -10,7 +10,7 @@ import { execOutput } from '../runtime/process.js';
 import { log, warn } from '../runtime/log.js';
 import { session, stateDir } from '../runtime/session.js';
 import { errMsg } from '../../core/util/errors.js';
-import { bootResetPaths, codexConfigWithoutSandbox, isCopyableDatabaseFile, isDatabaseFile, localStateEntries, } from './agent-files.js';
+import { bootResetPaths, codexConfigOwned, MAX_CODEX_CONFIG_BYTES, isCopyableDatabaseFile, isDatabaseFile, localStateEntries, } from './agent-files.js';
 const SQLITE_HEADER = 'SQLite format 3\0';
 /** The sandbox-disk folder that holds the working copies. */
 const localRoot = () => path.join(localDir, 'agent-state');
@@ -102,17 +102,31 @@ export function resetMachineBound() {
         }
     }
 }
-/** Boot: Codex runs its commands without its own sandbox (codexConfigWithoutSandbox), unless the user picked one. */
-export function codexWithoutInnerSandbox() {
-    if (dryRun || !session.agents?.codex)
+/**
+ * Boot: Codex's config.toml follows the codex settings (codexConfigOwned): no Windows sandbox setup of its own, its MCP
+ * logins in a file. The sandbox mode itself travels as launch flags (codexArguments), which beat this file.
+ */
+export function codexBootConfig() {
+    if (dryRun || !session.agents?.codex || !session.codex)
         return;
     const file = path.join(stateDir, 'codex', 'config.toml');
-    const updated = codexConfigWithoutSandbox(exists(file) ? fs.readFileSync(file, 'utf8') : '');
-    if (updated === null)
-        return;
-    mkdirp(path.dirname(file));
-    fs.writeFileSync(file, updated, 'utf8');
-    log('codex: its own command sandbox is off (sandbox_mode = "danger-full-access" in config.toml).');
+    try {
+        const size = exists(file) ? fs.statSync(file).size : 0;
+        if (size > MAX_CODEX_CONFIG_BYTES) {
+            warn('codex: config.toml is over 1 MB; left as it is.');
+            return;
+        }
+        const before = size ? fs.readFileSync(file, 'utf8') : '';
+        const after = codexConfigOwned(before, session.codex);
+        if (after === before)
+            return;
+        mkdirp(path.dirname(file));
+        fs.writeFileSync(file, after, 'utf8');
+        log('codex: config.toml updated (Windows sandbox "' + session.codex.windowsSandbox + '").');
+    }
+    catch (e) {
+        warn('codex: could not update config.toml (' + errMsg(e) + ').');
+    }
 }
 /** Boot: the saved databases of every configured agent are copied to the sandbox's disk, where the agent runs them. */
 export function restoreLocalState() {

package/dist/guest/boot/boot.js

@@ -5,8 +5,8 @@ import { spawn } from 'node:child_process';
 import { writeGuides } from './guide.js';
 import { setupToolchains } from '../toolchains/index.js';
 import { agents } from '../agents/agent-installer.js';
-import { agentShims, sbxAgentText, shimText } from '../agents/agent-files.js';
-import { codexWithoutInnerSandbox, resetMachineBound, restoreLocalState } from '../agents/local-state.js';
+import { agentArguments, agentShims, codexArguments, sbxAgentText, shimText } from '../agents/agent-files.js';
+import { codexBootConfig, resetMachineBound, restoreLocalState } from '../agents/local-state.js';
 import { installShellPath } from '../setup/shell-path.js';
 import { linkProfileDirs } from '../agents/profile-links.js';
 import { restoreClaudeMem } from '../setup/claude-mem.js';
@@ -120,7 +120,7 @@ function writeDevToolCommands(dir) {
  */
 function writeAgentCommands(dir) {
     const install = { node: process.execPath, script: path.join(path.dirname(process.argv[1]), 'agent.js') };
-    for (const shim of agentShims(toolsDir, session.agents ?? {}))
+    for (const shim of agentShims(toolsDir, session.agents ?? {}, session.codex ? { codex: codexArguments(session.codex) } : {}))
         fs.writeFileSync(path.join(dir, shim.command + '.cmd'), shimText(shim, install));
     fs.writeFileSync(path.join(dir, 'sbx-agent.cmd'), sbxAgentText(install));
 }
@@ -280,7 +280,7 @@ export class Boot {
             await soft('Claude settings', () => syncClaudeProfile(this.secrets.claudeCredentials));
         await soft('claude-mem restore', restoreClaudeMem);
         await soft('Agent files of the last sandbox', resetMachineBound);
-        await soft('Codex without its own sandbox', codexWithoutInnerSandbox);
+        await soft('Codex settings', codexBootConfig);
         await soft('Agent databases restore', restoreLocalState);
         // Agent add-ons: MCP servers in the sandbox's Claude Code, and the Headroom proxy before the managed settings point
         // Claude Code at it (the guide reads them back, so it comes last).
@@ -316,7 +316,12 @@ export class Boot {
         if (dryRun) {
             const launch = agents.resolveLaunch(session.harnessName, session.harness);
             log('(dry run) would run: ' +
-                [launch.file, ...launch.args, ...session.harness.arguments, ...session.harnessArguments].join(' ') +
+                [
+                    launch.file,
+                    ...launch.args,
+                    ...agentArguments(session.harnessName, session.harness, session.codex),
+                    ...session.harnessArguments,
+                ].join(' ') +
                 ' | cwd=' +
                 workspace);
             runHooks('post-agent', env);

package/dist/guest/daemon/heartbeat.d.ts

@@ -1,6 +1,11 @@
 import type { Heartbeat } from '../../shared/channel/schema.js';
 import { type GovernorSnapshot } from '../governor/index.js';
 /** The heartbeat for these numbers (the governor's snapshot when it has one, else Windows' own free memory). */
-export declare function buildHeartbeat(snapshot: GovernorSnapshot | null, sessionCount: number, uptimeSeconds: number, freeBytes: number, totalBytes: number, at: string): Heartbeat;
+export declare function buildHeartbeat(snapshot: GovernorSnapshot | null, sessionCount: number, uptimeSeconds: number, freeBytes: number, totalBytes: number, at: string, ending?: boolean): Heartbeat;
+/**
+ * The last heartbeat of an orderly end (idle shutdown, `sandbox stop`, Windows shutting down): the host then knows the
+ * sandbox was not lost. A sandbox that just vanishes leaves a busy heartbeat instead.
+ */
+export declare function markEnding(): void;
 /** Writes the heartbeat now and every 10 seconds; a failed write is only a warning. */
-export declare function startHeartbeat(): void;
+export declare function startHeartbeat(sessionCount: () => number): void;

package/dist/guest/daemon/heartbeat.js

@@ -7,11 +7,10 @@ import { governor } from '../governor/index.js';
 import { run } from '../runtime/paths.js';
 import { warn } from '../runtime/log.js';
 import { errMsg } from '../../core/util/errors.js';
-import { sessions } from './sessions.js';
 const BEAT_MS = 10000;
 const clamp = (n, low, high) => Math.max(low, Math.min(high, n));
 /** The heartbeat for these numbers (the governor's snapshot when it has one, else Windows' own free memory). */
-export function buildHeartbeat(snapshot, sessionCount, uptimeSeconds, freeBytes, totalBytes, at) {
+export function buildHeartbeat(snapshot, sessionCount, uptimeSeconds, freeBytes, totalBytes, at, ending = false) {
     const ramFree = snapshot?.ramFreePercent ?? Math.round((freeBytes / Math.max(1, totalBytes)) * 100);
     return {
         at,
@@ -21,20 +20,40 @@ export function buildHeartbeat(snapshot, sessionCount, uptimeSeconds, freeBytes,
         step: clamp(snapshot?.step ?? 0, 0, 4),
         hostStep: clamp(snapshot?.hostStep ?? 0, 0, 4),
         topProcesses: (snapshot?.top ?? []).slice(0, 5).map((p) => ({ name: p.name.slice(0, 64), privateMb: p.mb })),
-        ...(snapshot?.diskQueue != null ? { diskQueueReported: snapshot.diskQueue } : {}),
-        phase: sessionCount > 0 ? 'working' : 'ready',
+        ...(snapshot?.diskQueue !== null && snapshot?.diskQueue !== undefined
+            ? { diskQueueReported: snapshot.diskQueue }
+            : {}),
+        phase: ending ? 'ending' : sessionCount > 0 ? 'working' : 'ready',
     };
 }
+/** How many sessions run (set by startHeartbeat; this file must not import the sessions, which end through it). */
+let countSessions = () => 0;
+function writeBeat(ending) {
+    try {
+        writeJsonAtomic(run.heartbeatFile, buildHeartbeat(governor.snapshot(), countSessions(), os.uptime(), os.freemem(), os.totalmem(), now(), ending));
+    }
+    catch (e) {
+        warn('heartbeat: ' + errMsg(e));
+    }
+}
+/**
+ * The last heartbeat of an orderly end (idle shutdown, `sandbox stop`, Windows shutting down): the host then knows the
+ * sandbox was not lost. A sandbox that just vanishes leaves a busy heartbeat instead.
+ */
+export function markEnding() {
+    writeBeat(true);
+}
 /** Writes the heartbeat now and every 10 seconds; a failed write is only a warning. */
-export function startHeartbeat() {
-    const beat = () => {
-        try {
-            writeJsonAtomic(run.heartbeatFile, buildHeartbeat(governor.snapshot(), sessions.count, os.uptime(), os.freemem(), os.totalmem(), now()));
-        }
-        catch (e) {
-            warn('heartbeat: ' + errMsg(e));
-        }
-    };
-    beat();
-    setInterval(beat, BEAT_MS).unref();
+export function startHeartbeat(sessionCount) {
+    countSessions = sessionCount;
+    writeBeat(false);
+    const timer = setInterval(() => writeBeat(false), BEAT_MS);
+    timer.unref();
+    // Windows shutting down or the console closing: say so, then end (the default for these signals).
+    for (const signal of ['SIGHUP', 'SIGBREAK', 'SIGTERM'])
+        process.on(signal, () => {
+            clearInterval(timer);
+            markEnding();
+            process.exit(0);
+        });
 }

package/dist/guest/daemon/idle-shutdown.js

@@ -9,6 +9,7 @@ import { log } from '../runtime/log.js';
 import { session } from '../runtime/session.js';
 import { safely } from './state.js';
 import { flushAccounts } from './accounts.js';
+import { markEnding } from './heartbeat.js';
 /** How long the sandbox must stay idle before it shuts down. */
 const GRACE_MS = 15000;
 export class IdleShutdown {
@@ -27,6 +28,7 @@ export class IdleShutdown {
             if (!this.idle())
                 return;
             log('Headless sandbox has no sessions left; shutting down.');
+            safely('heartbeat', markEnding);
             safely('claude-mem save', saveClaudeMem);
             safely('agent databases save', saveLocalState);
             // Renewed sign-ins go to the PC, and a held one (a Unity seat) is let go, before Windows stops.

package/dist/guest/daemon/sessions.js

@@ -18,6 +18,7 @@ import { freePort } from '../runtime/ports.js';
 import { primaryProject } from '../boot/project-status.js';
 import { endLeftoverTree, ensurePtyHost, ptyHostLogTail, recordedTrees, startPtyHost, waitForPtyHost, } from '../sessions/pty-host.js';
 import { agents } from '../agents/agent-installer.js';
+import { agentArguments } from '../agents/agent-files.js';
 import { saveClaudeMem } from '../setup/claude-mem.js';
 import { saveLocalState } from '../agents/local-state.js';
 import { projectHooks, runHooks, runHooksAsync } from '../setup/hooks.js';
@@ -108,7 +109,7 @@ const agentProgram = async (req, env, say) => {
     say('Preparing ' + req.harness);
     await agents.provision(req.harness, harness, env, false);
     const launch = agents.resolveLaunch(req.harness, harness);
-    const base = [...launch.args, ...harness.arguments];
+    const base = [...launch.args, ...agentArguments(req.harness, harness, session.codex)];
     return {
         command: commandLine(launch.file, [...base, ...req.args]),
         restartCommand: commandLine(launch.file, [...base, ...(harness.resumeArguments ?? [])]),

package/dist/guest/entries/daemon.js

@@ -25,5 +25,5 @@ safely('leftover processes', () => sessions.sweepLeftovers());
 safely('memory governor', () => governor.start());
 log('Memory governor: ' + governor.describe());
 safely('service sign-ins', startAccountWatch);
-safely('heartbeat', startHeartbeat);
+safely('heartbeat', () => startHeartbeat(() => sessions.count));
 new Daemon().start();

package/dist/guest/toolchains/installers.d.ts

@@ -1,12 +1,8 @@
-/** Who signs the installers the toolchains run (the subject of the signature). */
-export declare const SIGNERS: {
-    readonly microsoft: "CN=Microsoft Corporation, O=Microsoft Corporation, L=Redmond, S=Washington, C=US";
-    readonly valve: RegExp;
-    readonly unity: RegExp;
-};
-/** Whether a file's signature is the expected signer's. */
-export declare function signedBy(file: string, signer: string | RegExp): boolean;
+import { SIGNERS, type AppSigner } from '../../shared/signer.js';
+import { signedBy } from './signature.js';
+export { SIGNERS };
+export { signedBy };
 /** A downloader `verify` hook: refuses a file not signed by `signer` (it counts as integrity for requireChecksum). */
-export declare function signatureCheck(signer: string | RegExp, what: string): (file: string) => void;
+export declare function signatureCheck(signer: AppSigner, what: string): (file: string) => void;
 /** The installer at `file` (downloaded once from `url`), checked against its signer and, when given, its SHA-256. */
-export declare function signedInstaller(url: string, file: string, what: string, signer: string | RegExp, sha256?: string | null): Promise<string>;
+export declare function signedInstaller(url: string, file: string, what: string, signer: AppSigner, sha256?: string | null): Promise<string>;

package/dist/guest/toolchains/installers.js

@@ -5,18 +5,10 @@ import path from 'node:path';
 import { downloader } from '../../shared/download/index.js';
 import { exists, mkdirp } from '../runtime/fs.js';
 import { log } from '../runtime/log.js';
-import { MICROSOFT_SIGNER, signerOf } from './native/vcruntime.js';
-/** Who signs the installers the toolchains run (the subject of the signature). */
-export const SIGNERS = {
-    microsoft: MICROSOFT_SIGNER,
-    valve: /^CN="?Valve(,| Corp)/,
-    unity: /^CN="?Unity Technologies/,
-};
-/** Whether a file's signature is the expected signer's. */
-export function signedBy(file, signer) {
-    const subject = signerOf(file);
-    return typeof signer === 'string' ? subject === signer : signer.test(subject);
-}
+import { SIGNERS } from '../../shared/signer.js';
+import { signedBy } from './signature.js';
+export { SIGNERS };
+export { signedBy };
 /** A downloader `verify` hook: refuses a file not signed by `signer` (it counts as integrity for requireChecksum). */
 export function signatureCheck(signer, what) {
     return (file) => {

package/dist/guest/toolchains/native/autosdk.d.ts

@@ -0,0 +1,3 @@
+import { type ToolEnv } from '../tool-env.js';
+/** Makes the AutoSDK tree from the portable MSVC if it is missing for this MSVC and SDK, and points Unreal at it. */
+export declare function setupAutosdk(env: ToolEnv): Promise<void>;

package/dist/guest/toolchains/native/autosdk.js

@@ -0,0 +1,50 @@
+// Unreal without Visual Studio (toolchains.unreal.visualStudio = "autosdk", experimental): an AutoSDK tree made from
+// the portable MSVC (tools\msvc), at tools\unreal\autosdk, which UnrealBuildTool finds through UE_SDKS_ROOT. Made of
+// copies (mapped folders refuse links), once; kept between sandboxes. The editor's Visual Studio integration is not
+// available.
+import fs from 'node:fs';
+import path from 'node:path';
+import { z } from 'zod';
+import { writeJsonAtomic } from '../../../shared/io/json.js';
+import { robocopyFailed } from '../../../shared/io/robocopy-result.js';
+import { spawnAsync } from '../../../shared/download/index.js';
+import { SYSTEM } from '../../../shared/system.js';
+import { exists, mkdirp } from '../../runtime/fs.js';
+import { log } from '../../runtime/log.js';
+import { tool } from '../tool-env.js';
+import { hasCompiler, readInstalled, ROOT as MSVC_ROOT } from './msvc/tree.js';
+import { autosdkLayout } from './vs-request.js';
+const AUTOSDK_DIR = tool('unreal', 'autosdk');
+const MARKER = path.join(AUTOSDK_DIR, '.complete.json');
+const MarkerSchema = z.object({ msvc: z.string(), sdk: z.string() });
+function builtFor(msvc, sdk) {
+    try {
+        const done = MarkerSchema.parse(JSON.parse(fs.readFileSync(MARKER, 'utf8')));
+        return done.msvc === msvc && done.sdk === sdk;
+    }
+    catch {
+        return false; // No marker, or a half-written one: build again.
+    }
+}
+/** Makes the AutoSDK tree from the portable MSVC if it is missing for this MSVC and SDK, and points Unreal at it. */
+export async function setupAutosdk(env) {
+    const msvc = readInstalled();
+    if (!msvc || !hasCompiler(msvc.msvc))
+        throw new Error('toolchains.unreal.visualStudio = "autosdk" builds from the portable MSVC, which is not installed ' +
+            '(is toolchains.msvc off?)');
+    if (!builtFor(msvc.msvc, msvc.sdk)) {
+        log('Making the Unreal AutoSDK from MSVC ' + msvc.msvc + ' (~2 GB, once) ...');
+        fs.rmSync(MARKER, { force: true });
+        for (const pair of autosdkLayout(MSVC_ROOT, msvc.msvc, msvc.sdk, AUTOSDK_DIR)) {
+            mkdirp(pair.to);
+            const code = await spawnAsync(SYSTEM.robocopy(), [pair.from, pair.to, '/E', '/COPY:DAT', '/R:1', '/W:1', '/NP']);
+            if (robocopyFailed(code))
+                throw new Error('could not copy ' + pair.from + ' into the AutoSDK (robocopy ' + code + ')');
+        }
+        writeJsonAtomic(MARKER, { msvc: msvc.msvc, sdk: msvc.sdk });
+    }
+    if (!exists(MARKER))
+        throw new Error('the Unreal AutoSDK was not completed');
+    env.vars['UE_SDKS_ROOT'] = AUTOSDK_DIR;
+    env.summary.push('unreal autosdk: MSVC ' + msvc.msvc + ', Windows SDK ' + msvc.sdk + ' (UE_SDKS_ROOT=' + AUTOSDK_DIR + ')');
+}

package/dist/guest/toolchains/native/unreal.js

@@ -12,6 +12,7 @@ import { log } from '../../runtime/log.js';
 import { setupUnrealEngines } from '../engines/unreal-engines.js';
 import { SIGNERS, signedInstaller } from '../installers.js';
 import { tool } from '../tool-env.js';
+import { setupAutosdk } from './autosdk.js';
 import { installedVs } from './visual-studio.js';
 export { UNREAL_COMPONENTS } from './vs-request.js';
 const DIRECTX_URL = 'https://download.microsoft.com/download/8/4/A/84A35BF1-DAFE-4AE8-82AF-AD2AE20B6B14/directx_Jun2010_redist.exe';
@@ -39,6 +40,8 @@ export async function setupUnreal(env, config, ctx) {
         return;
     }
     await installDirectX();
+    if (config.visualStudio === 'autosdk')
+        await setupAutosdk(env);
     await setupUnrealEngines(env, config, ctx);
     const vs = installedVs();
     env.summary.push('unreal: ' +

package/dist/guest/toolchains/native/vcruntime.d.ts

@@ -1,7 +1,4 @@
 import { type ToolEnv } from '../tool-env.js';
-export declare const MICROSOFT_SIGNER = "CN=Microsoft Corporation, O=Microsoft Corporation, L=Redmond, S=Washington, C=US";
-/** The subject of a valid Authenticode signature, or '' when the file is unsigned or tampered with. */
-export declare const signerOf: (file: string) => string;
 /**
  * A real installer (it writes to System32), so it runs on every boot; the installer itself is kept in persistent
  * storage and only run when Microsoft's signature on it checks out. Resolves true when this call ran the installer.

package/dist/guest/toolchains/native/vcruntime.js

@@ -3,17 +3,14 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { spawnAsync } from '../../../shared/download/index.js';
 import { dryRun } from '../../runtime/paths.js';
-import { scriptOutput } from '../../runtime/process.js';
 import { exists } from '../../runtime/fs.js';
 import { log } from '../../runtime/log.js';
 import { downloadFile } from '../install.js';
+import { SIGNERS, signedBy } from '../installers.js';
 import { tool } from '../tool-env.js';
 const VC_REDIST = 'https://aka.ms/vs/17/release/vc_redist.x64.exe';
-export const MICROSOFT_SIGNER = 'CN=Microsoft Corporation, O=Microsoft Corporation, L=Redmond, S=Washington, C=US';
 /** 1638: a newer version is already installed; 3010: installed, a restart would finish it (not needed for the DLLs). */
 const OK_EXIT_CODES = [0, 1638, 3010];
-/** The subject of a valid Authenticode signature, or '' when the file is unsigned or tampered with. */
-export const signerOf = (file) => scriptOutput('get-signer.ps1', ['-Path', file]).trim();
 /**
  * A real installer (it writes to System32), so it runs on every boot; the installer itself is kept in persistent
  * storage and only run when Microsoft's signature on it checks out. Resolves true when this call ran the installer.
@@ -32,7 +29,7 @@ export async function setupVcRuntime(env, summary = true) {
             log('Downloading the Visual C++ runtime (~25 MB once) ...');
             await downloadFile(VC_REDIST, installer);
         }
-        if (signerOf(installer) !== MICROSOFT_SIGNER) {
+        if (!signedBy(installer, SIGNERS.microsoft)) {
             fs.rmSync(installer, { force: true });
             throw new Error('vc_redist.x64.exe is not signed by Microsoft; deleted it (it is downloaded again next boot)');
         }

package/dist/guest/toolchains/native/visual-studio.d.ts

@@ -1,6 +1,6 @@
 import { type ToolEnv } from '../tool-env.js';
-import type { VsRequest } from './vs-request.js';
-export { BUILD_TOOLS_COMPONENTS, UNREAL_COMPONENTS, visualStudioWanted, type VsRequest } from './vs-request.js';
+import { type VsRequest } from './vs-request.js';
+export { BUILD_TOOLS_COMPONENTS, UNREAL_COMPONENTS, unrealUsesAutosdk, visualStudioWanted, type VsRequest, } from './vs-request.js';
 /** The newest Visual Studio (or Build Tools) with the C++ compiler: its folder and version, or null. */
 export declare function installedVs(): {
     path: string;