windows-development-sandbox 1.16.0 → 1.17.3

package/README.md

@@ -12,9 +12,10 @@
 
 </div>
 
-Run it in a project folder and you get a clean [Windows Sandbox](https://learn.microsoft.com/windows/security/application-security/application-isolation/windows-sandbox/windows-sandbox-overview)
-where that folder is the workspace, the tools and databases the project needs install themselves, and nothing else
-on your PC is reachable. Close it and it's gone. Your project, tools, databases and logins are kept for next time.
+Run it in a project folder to get a clean
+[Windows Sandbox](https://learn.microsoft.com/windows/security/application-security/application-isolation/windows-sandbox/windows-sandbox-overview).
+The folder is the workspace, the tools and databases it needs install themselves, and the rest of your PC is out of
+reach. Close it and it is gone. Your project, tools, databases and logins are kept for next time.
 
 ## Install
 
@@ -22,130 +23,129 @@ on your PC is reachable. Close it and it's gone. Your project, tools, databases
 irm https://github.com/JoshDiDuca/windows-development-sandbox/releases/latest/download/install.ps1 | iex
 ```
 
-It checks your PC, offers to turn on Windows Sandbox, and asks **1) Just me** or **2) Everyone on this PC** (needs
-admin). It brings its own private copy of Node.js; nothing else is installed system-wide, and no Start menu shortcut
-unless you ask for one. `sandbox update` installs newer versions (and can do it by itself), even while a sandbox runs:
-the sandbox keeps its version until it restarts. A version that fails to start is rolled back automatically, and
-`sandbox update --rollback` goes back one by hand.
+The installer checks your PC, offers to turn on Windows Sandbox, and asks **1) Just me** or **2) Everyone on this PC**
+(needs admin). It brings its own copy of Node.js and installs nothing else system-wide. It adds no Start menu shortcut
+unless you ask.
 
-Needs Windows 10/11 **Pro, Enterprise or Education**. Have Node.js 20+? `npm install -g windows-development-sandbox`
-works too. [Scopes, options (`-Version`, `-StartMenuShortcut` ...), upgrading, uninstall](docs/install.md)
+- `sandbox update` installs a newer version, and can do it by itself. A running sandbox keeps its version until it
+  restarts.
+- A new version that fails to start is rolled back for you. `sandbox update --rollback` goes back one version by hand.
+
+Needs Windows 10/11 **Pro, Enterprise or Education**. With Node.js 20+, `npm install -g windows-development-sandbox`
+works too. More: [install options, upgrading, uninstall](docs/install.md).
 
 ## Use
 
 ```powershell
 cd C:\code\my-app
 
-sandbox            # the menu: agents, sessions, apps, every setting, diagnostics ...
+sandbox            # the menu: agents, sessions, apps, settings, health ...
 sandbox claude     # Claude Code in a sandbox for this folder (or: claude-sandbox)
-sandbox claude -t  # ... in this terminal (Ctrl+] detaches, the session keeps running)
-sandbox start      # just the sandbox, no agent
+sandbox claude -t  # ... in this terminal (Ctrl+] detaches; the session keeps running)
+sandbox start      # the sandbox, no agent
 sandbox opencode   # any supported agent by name
 sandbox web open   # (Beta) the web UI in your browser, signed in
 ```
 
-The first start downloads what the project needs (a few minutes, once). After that, starts take seconds.
+The first start downloads what the project needs (a few minutes, once). Later starts take seconds.
 
-> `claude-sbx`, `codex-sbx`, `gemini-sbx` and `agent-sandbox` are the old command names. They still work for now; use
-> `sandbox <agent>` / `claude-sandbox` and `sandbox` instead.
+> The old names `claude-sbx`, `codex-sbx`, `gemini-sbx` and `agent-sandbox` still work for now. Use `sandbox <agent>`
+> (or `claude-sandbox`) and `sandbox` instead.
 
 ## What you get
 
-|  |  |
-|---|---|
-| **Safe by default** | The agent sees only your project folder. Credentials are stripped before anything is copied in, your LAN is blocked, and nothing the sandbox writes can run on your PC. |
-| **Languages** | Node, Python, Rust, C/C++ (GCC or MSVC), .NET (incl. .NET Framework targeting), Go, Java, Ruby, PHP, Deno, Bun, PowerShell 7, with pnpm, yarn, Volta, uv, pyenv, Maven, Gradle, Composer, gh ... |
-| **Apps and tools** | VS Code (set up for your languages, with their extensions) and Windows Terminal, plus 60 optional apps and tools by category: DBeaver, pgAdmin, Bruno, Godot, Blender, kubectl, jq, ripgrep ... and programs of your own. Agent add-ons too: rtk and Headroom (fewer tokens), ccusage, Playwright and Context7 MCP servers, claude-mem, REA. Playwright works out of the box with Edge |
-| **Databases** | PostgreSQL, MySQL, MongoDB, Redis and DynamoDB Local with a web UI, started when the project uses them, or any time with `--database` / `sandbox db` |
-| **Agents** | Claude Code, Codex, Gemini, opencode, Qwen, Crush, Copilot, Kilo, Amp, Cline, Continue, Kimi, Aider, DeepSeek agents |
-| **Smart** | Detects what the project needs from its files, respects version files, installs in parallel and reuses everything |
-| **Several projects** | `sandbox claude` from another project joins the running sandbox: its own folder, tools, versions, databases and environment, set up on demand. Start several agents at once (`--session claude@A --session codex@B`, or the menu) and attach to any of them from any terminal |
-| **Picks up where you left off** | After a crash or a restart, `sandbox resume` reopens the last sessions; `sandbox restart` restarts the agents in place and they continue their conversation |
-| **Leaves nothing behind** | When an agent's session ends, everything it started ends with it, background servers included. The web UI's server stops when no browser uses it, and nothing of this tool keeps running on your PC once the sandbox is closed |
-| **GitHub, safely** | Give sandboxes a fine-grained GitHub token you made for them (`sandbox github login`, `github.shareToken`): `gh` and `git push` work inside, and the token never lands in the sandbox's files |
-| **Feels like home** | Your desktop look, Claude settings, MCP servers and conversation history come along; history syncs back. Logins you save (`sandbox account`) are kept encrypted for your Windows user |
+|                           |                                                                                                                                                                                                                                                                                                                                                               |
+| ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Safe by default**       | The agent sees only your project folder. Credentials are stripped before anything is copied in, your LAN is blocked, and nothing the sandbox writes can run on your PC.                                                                                                                                                                                       |
+| **Languages**             | Node, Python, Rust, C/C++ (GCC or MSVC), .NET (with .NET Framework targeting), Go, Java, Ruby, PHP, Deno, Bun, PowerShell 7, Unreal Engine tools. Also pnpm, yarn, Volta, uv, pyenv, Maven, Gradle, Composer, gh ...                                                                                                                                          |
+| **Apps and tools**        | VS Code (set up for your languages) and Windows Terminal, plus about 80 optional apps by category: DBeaver, pgAdmin, Bruno, Godot, Blender, Ghidra, kubectl, jq, ripgrep ... and your own programs. Agent add-ons: rtk and Headroom (fewer tokens), ccusage, Playwright and Context7 MCP servers, claude-mem, REA. Playwright works with Edge out of the box. |
+| **Databases**             | PostgreSQL, MySQL, MongoDB, Redis and DynamoDB Local (with a web UI). They start when the project uses them, or any time with `--database` or `sandbox db`.                                                                                                                                                                                                   |
+| **Agents**                | Claude Code, Codex, Gemini, opencode, Qwen, Crush, Copilot, Kilo, Amp, Cline, Continue, Kimi, Aider and two DeepSeek agents.                                                                                                                                                                                                                                  |
+| **Smart setup**           | Finds what the project needs from its files, follows its version files, installs in parallel and reuses everything.                                                                                                                                                                                                                                           |
+| **Several projects**      | `sandbox claude` from another project joins the running sandbox, with that project's own folder, tools, versions, databases and environment. Start several agents at once (`--session claude@A --session codex@B`, or the menu) and attach to any of them from any terminal.                                                                                  |
+| **Pick up again**         | After a crash or restart, `sandbox resume` reopens the last sessions. `sandbox restart` restarts the agents in place, and they continue their conversations.                                                                                                                                                                                                  |
+| **Leaves nothing behind** | When an agent's session ends, everything it started ends too, background servers included. Nothing of this tool keeps running on your PC once the sandbox is closed.                                                                                                                                                                                          |
+| **GitHub, safely**        | Give sandboxes a fine-grained GitHub token made just for them (`sandbox github login`, `github.shareToken`). `gh` and `git push` then work inside, and the token is never written to the sandbox's files.                                                                                                                                                     |
+| **Feels like home**       | Your desktop look, Claude settings, MCP servers and conversation history come along, and history syncs back. Saved logins (`sandbox account`) are encrypted for your Windows user.                                                                                                                                                                            |
 
 ## Built for heavy workloads
 
-The sandbox behaves like a well-run PC of its own size: under load it slows down, it does not fail, and it never takes
-your PC down with it. Nothing needs setting up.
-
-- **Sized to what your PC can hold.** The sandbox gets only the memory your PC can keep in RAM for it, with room kept
-  for your PC itself (and more with vGPU on).
-- **Builds within a budget.** Agents see the processors and memory they may really use, and every session gets a
-  matching number of build jobs and links, written to `run\budget.json` for agents to plan with.
-- **Graduated throttling.** As memory fills, a governor in the sandbox turns one dial in steps: build programs get
-  lower CPU and memory priority, then a smaller share of the CPU, then compilers take turns while the waiting ones move
-  to the paging file. Builds get slower; nothing is stopped or killed, and agents, shells and Windows are never touched.
-- **Your PC has a say.** A watchdog on your PC watches its memory, CPU and disks and asks the sandbox to ease off, at
-  once and all the way when your PC is nearly out of memory.
-- **A last resort that only protects.** Only at the very edge of the sandbox's own memory limit, where Windows inside
-  it would otherwise start failing, is a build refused memory so that the sandbox stays up.
-- **Answers after the fact.** `sandbox doctor` checks your paging file, and `sandbox logs --crash` explains a past
-  freeze or crash: the gap, blue screens, hardware and memory events, and whether vGPU was on.
-
-Details and settings: [troubleshooting](docs/troubleshooting.md#the-sandbox-closes-under-heavy-load) and
-[configuration](docs/configuration.md#cpu-ram-and-gpu).
+Under load the sandbox slows down instead of failing, and it never takes your PC down with it. Nothing needs setting
+up.
+
+- **Sized to fit.** The sandbox gets only the memory your PC can keep in RAM for it, with room left for your PC.
+- **A build budget.** Agents see the CPUs and memory they may really use. Each session gets a matching number of build
+  jobs, written to `run\budget.json` for agents to plan with.
+- **Slows down in steps.** As memory fills, build programs get lower priority, then less CPU, then compilers take
+  turns. Builds get slower, but nothing is killed, and agents, shells and Windows are never touched.
+- **Your PC has a say.** A watchdog on your PC asks the sandbox to ease off when your PC runs short of memory, CPU or
+  disk.
+- **A last resort.** Only at the very edge of the sandbox's memory limit is a build refused memory, so the sandbox
+  stays up.
+- **Answers afterwards.** `sandbox doctor` checks your paging file. `sandbox logs --crash` explains a past freeze or
+  crash.
+
+Details: [heavy load](docs/troubleshooting.md#the-sandbox-closes-under-heavy-load) and
+[CPU, RAM and GPU settings](docs/configuration.md#cpu-ram-and-gpu).
 
 ## Commands
 
-| Command | |
-|---|---|
-| `sandbox` | the menu, a full-screen app with a left navigation: start agents, attach to sessions, pick apps, edit every setting (yours and the project's), all commands, with search |
-| `sandbox <agent>`, `claude-sandbox` | start an agent; `-t` for this terminal, `--headless` for no window |
-| `sandbox start` | the sandbox without an agent |
-| `sandbox attach` / `sessions` / `status` | work with a running sandbox (this folder's project first) |
-| `sandbox shell` / `close <id>` | open PowerShell (or cmd) in a project as a session you can attach to; end a session |
-| `sandbox restart` / `resume` | restart the agents in place; reopen the last sessions |
-| `sandbox projects` | the projects a sandbox can open without a restart: roots, `all`, exclude |
-| `sandbox db [start\|stop <name>]` | list, start or stop databases (`sbx-db` inside) |
-| `sandbox exec -- <cmd>` | run a command inside |
-| `sandbox config get\|set\|reset\|list` | read and change any setting from the command line (`export` / `import` to share them) |
-| `sandbox account` | save, switch and rename agent logins |
-| `sandbox github` / `vpn` | the GitHub token for sandboxes; the VPN login and status |
-| `sandbox web` | (Beta) the web UI: start, stop, status, open |
-| `sandbox stop` / `hide` / `show` | shut down, hide or show the window |
-| `sandbox data` / `storage` | what's stored and how big, freeing space, moving the data folder |
-| `sandbox setup` / `doctor` / `repair` | check this PC, see what will be installed, fix common problems |
-| `sandbox engine` | the engines and what each can do on this PC; `engine clean` stops HCS systems left running |
-| `sandbox logs [-f] [--crash]` | the sandbox log, or the report of the last crash |
-| `sandbox update [--rollback]` / `--version` | update (or go back one version); the installed version |
-
-All commands and options: [docs/commands.md](docs/commands.md)
+| Command                                  |                                                                                   |
+| ---------------------------------------- | --------------------------------------------------------------------------------- |
+| `sandbox`                                | the menu: start agents, attach to sessions, pick apps, change any setting, search |
+| `sandbox <agent>`, `claude-sandbox`      | start an agent; `-t` for this terminal, `--headless` for no window                |
+| `sandbox start`                          | the sandbox without an agent                                                      |
+| `sandbox attach` / `sessions` / `status` | work with a running sandbox (this folder's project first)                         |
+| `sandbox shell` / `close <id>`           | open PowerShell or cmd in a project as a session; end a session                   |
+| `sandbox restart` / `resume`             | restart the agents in place; reopen the last sessions                             |
+| `sandbox projects`                       | which projects a sandbox can open without a restart                               |
+| `sandbox db [start\|stop <name>]`        | list, start or stop databases (`sbx-db` inside)                                   |
+| `sandbox exec -- <cmd>`                  | run a command inside                                                              |
+| `sandbox config get\|set\|reset\|list`   | read and change settings (`export` / `import` to share them)                      |
+| `sandbox account`                        | save, switch and rename agent logins                                              |
+| `sandbox github` / `vpn`                 | the GitHub token for sandboxes; the VPN login and status                          |
+| `sandbox web`                            | (Beta) the web UI: start, stop, status, open                                      |
+| `sandbox stop` / `hide` / `show`         | shut down; hide or show the window                                                |
+| `sandbox data` / `storage`               | what is stored and how big; free space; move the data folder                      |
+| `sandbox setup` / `doctor` / `repair`    | check this PC, see what will be installed, fix common problems                    |
+| `sandbox engine`                         | (Alpha) the engines and what each can do on this PC                               |
+| `sandbox logs [-f] [--crash]`            | the sandbox log, or the report of the last crash                                  |
+| `sandbox update [--rollback]`            | update, or go back one version (`--version` shows the installed one)              |
+
+Every command and option: [docs/commands.md](docs/commands.md).
 
 ## Beta and alpha features
 
-These are off until you turn them on, and one setting turns each off again. Windows Sandbox stays the default and
-keeps every feature it has.
+These are off until you turn them on, and one setting turns each off again. Windows Sandbox stays the default engine
+and keeps all its features.
 
-| Feature | Status | |
-|---|---|---|
-| **Web UI** (`sandbox web`, `web.enabled`) | Beta | Agents, sessions with live terminals, the sandbox's status, apps, accounts and every setting in your browser, with search (Ctrl+K) and a folder picker; on this PC only (loopback, signed in with a token). `web.openOnLaunch` opens it with every sandbox. [web-ui.md](docs/web-ui.md) |
-| **Agent commands** (`sandbox agent-commands on`) | Beta | Typing `claude`, `codex` ... in any folder starts it in a hidden sandbox and attaches your terminal |
-| **Contained storage** (`sandbox storage contained on`) | Beta | Tools, logins and logs in one disk image per data set, mounted only while a sandbox runs. One admin prompt per launch. [engines](docs/design/engines.md) |
-| **VPN** (`sandbox vpn`, `vpn.enabled`) | Alpha | The sandbox's traffic through NordVPN, your own OpenVPN profile or a WireGuard config, with a kill switch that is checked with a real connection. The first real try fixed the install and the kill switch; a tunnel carrying traffic is not confirmed yet: read [vpn.md](docs/vpn.md) first |
-| **HCS engine** (`sandbox.engine: hcs`, `sandbox engine`) | Alpha | Headless agents in a Hyper-V isolated Server Core container. `sandbox engine check hcs` shows what your PC lacks; starting it is not enabled yet. Its create, start and stop steps pass on GitHub's Windows Server 2022 and 2025 runners |
+| Feature                                                | Status | What it does                                                                                                                                                                                                    |
+| ------------------------------------------------------ | ------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Web UI** (`sandbox web`, `web.enabled`)              | Beta   | Agents, live terminals, status, apps, accounts and settings in your browser, with search (Ctrl+K). This PC only, signed in with a token; devices on your network if you allow them. [web-ui.md](docs/web-ui.md) |
+| **Agent commands** (`sandbox agent-commands on`)       | Beta   | Typing `claude`, `codex` ... in any folder starts that agent in a hidden sandbox and attaches your terminal.                                                                                                    |
+| **Contained storage** (`sandbox storage contained on`) | Beta   | Tools, logins and logs in one disk image, mounted only while a sandbox runs. One admin prompt per launch. [Details](docs/configuration.md#contained-storage-beta)                                               |
+| **VPN** (`sandbox vpn`, `vpn.enabled`)                 | Alpha  | The sandbox's traffic through NordVPN, your own OpenVPN profile or a WireGuard config, with a kill switch. A tunnel carrying traffic is not confirmed yet: read [vpn.md](docs/vpn.md) first.                    |
+| **HCS engine** (`sandbox.engine: hcs`)                 | Alpha  | Headless agents in a Hyper-V isolated Server Core container. `sandbox engine check hcs` shows what your PC lacks. Starting it is not enabled yet.                                                               |
 
 ## Known gaps
 
-- Adding a folder to a RUNNING sandbox needs Windows 11 24H2+ with the updated Windows Sandbox (`wsb share`,
-  untested). On older Windows, folders inside a project root open at once and anything else offers a restart.
-  [Details, and how to get `wsb`](docs/projects.md#adding-folders-to-a-running-sandbox-wsb-share). A way for older
-  Windows through HCS is designed and waiting for a test on a real PC ([design](docs/design/hcs-live-folders.md)).
-- Windows Sandbox runs one sandbox at a time per PC; every project and agent shares it.
+- Adding a folder to a **running** sandbox needs Windows 11 24H2+ with the updated Windows Sandbox (`wsb share`,
+  untested). On older Windows, folders inside a project root open at once, and anything else offers a restart.
+  [Details](docs/projects.md#adding-a-project-to-a-running-sandbox).
+- Windows Sandbox runs one sandbox per PC. Every project and agent shares it.
 - What is planned next: [roadmap](docs/roadmap.md).
 
 ## Documentation
 
-All docs, with one line each: [docs/README.md](docs/README.md). The main ones:
+All docs, one line each: [docs/README.md](docs/README.md). The main ones:
 
-- [Install](docs/install.md): requirements, other ways to install, upgrading, rolling back
-- [Commands](docs/commands.md): every command and option, the menu, sessions and attaching
-- [Tools and databases](docs/toolchains.md): languages, package managers, databases, agents, what is tested
+- [Install](docs/install.md): requirements, other ways to install, updating, uninstalling
+- [Commands](docs/commands.md): every command and option, the menu, sessions
+- [Tools and databases](docs/toolchains.md): languages, apps, databases, agents
 - [Configuration](docs/configuration.md): settings, project files, paths, accounts, hooks
-- [Several projects](docs/projects.md): project roots, adding a project to a running sandbox, what each agent can see
+- [Several projects](docs/projects.md): project roots, joining a running sandbox, what each agent can see
 - [Security](docs/security.md): how your PC is protected, secrets, git access
 - [Web UI](docs/web-ui.md) (Beta) and [VPN](docs/vpn.md) (Alpha)
-- [Troubleshooting](docs/troubleshooting.md): common problems, freezes and crash reports
-- [Changelog](CHANGELOG.md) and [roadmap](docs/roadmap.md): what shipped, what is next
+- [Troubleshooting](docs/troubleshooting.md): common problems, heavy load, crash reports
+- [Changelog](CHANGELOG.md) and [roadmap](docs/roadmap.md)
 - [Development](docs/development.md): building, testing, releasing (code layout in [CLAUDE.md](CLAUDE.md))

package/config.example.json

@@ -118,6 +118,12 @@
       "msvcVersion": "latest",
       "sdkVersion": "latest"
     },
+    "unreal": {
+      "enabled": "auto",
+      "acceptLicense": false,
+      "components": [],
+      "keepInstallFiles": true
+    },
     "cpp": {
       "enabled": "auto",
       "flexBison": true

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

@@ -14,7 +14,7 @@ import { ConfigFile } from '../settings/index.js';
 import { accessStatus, allowDevice, lanOff, lanOn, revokeAccess, revokeAllAccess } from './access.def.js';
 /** The access list of this user (the folder is the web state's private one). */
 export function accessStoreOf(ctx) {
-    return AccessStore.at(ctx.storageRoot, SecretStore.standard(), {
+    return AccessStore.at(ctx.storageRoot, SecretStore.standard(ctx.storageRoot), {
         // The self-test never changes folder permissions; its storage is a temp folder.
         protect: selfTestRunning() ? undefined : (dir) => protectPrivateFolder(dir),
     });

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-7EXDUNE7.js";
-import "./chunk-HIC4CUMY.js";
+} from "./chunk-QLGGAG3D.js";
+import "./chunk-REE3EMHD.js";
 
 // src/bin/agent-sandbox.ts
 run(process.argv.slice(2));

package/dist/bin/{chunk-7EXDUNE7.js → chunk-QLGGAG3D.js}

@@ -226,7 +226,7 @@ import {
   withOperationCommands,
   working,
   writeJson
-} from "./chunk-HIC4CUMY.js";
+} from "./chunk-REE3EMHD.js";
 
 // node_modules/commander/lib/error.js
 var require_error = __commonJS({

package/dist/bin/{chunk-HIC4CUMY.js → chunk-REE3EMHD.js}

@@ -25938,6 +25938,7 @@ var DEFAULTS = {
       linkSlots: "auto"
     },
     msvc: { enabled: "auto", acceptLicense: false, msvcVersion: "latest", sdkVersion: "latest" },
+    unreal: { enabled: "auto", acceptLicense: false, components: [], keepInstallFiles: true },
     cpp: { enabled: "auto", flexBison: true },
     dotnet: {
       enabled: "auto",
@@ -46053,7 +46054,7 @@ var SandboxSchema = external_exports.strictObject({
     "When the sandbox (or this PC) runs low on memory, slow builds down in steps, like a PC that gets slower instead of failing: build programs get lower CPU and memory priority, then less CPU, then compilers take turns (the waiting ones briefly suspended and trimmed to the paging file). Nothing is stopped or killed, and the agents themselves are never touched. Yours only: a project file cannot change it."
   ),
   vGpu: external_exports.boolean().describe(
-    "Virtual GPU. Off by default: Microsoft notes it widens the sandbox attack surface. The sandbox then uses this PC's graphics card, and with some graphics drivers heavy use can freeze the whole PC: turn it on only when a program in the sandbox needs the GPU (the mesa toolchain gives software OpenGL without it)."
+    "Virtual GPU. Off by default: Microsoft notes it widens the sandbox attack surface. The sandbox then uses this PC's graphics card, and with some graphics drivers heavy use can freeze the whole PC: turn it on only when a program in the sandbox needs the GPU (the mesa toolchain gives software OpenGL without it). Browsers in the sandbox never use it (they draw in software)."
   ),
   networking: external_exports.boolean().describe("Internet access. false is the only hard network isolation Windows Sandbox offers."),
   clipboard: external_exports.boolean().describe(
@@ -46215,6 +46216,21 @@ var ToolchainsSchema = external_exports.strictObject({
     msvcVersion: external_exports.string().min(1).describe('"latest" or an MSVC tools version prefix, e.g. "14.44".'),
     sdkVersion: external_exports.string().min(1).describe('"latest" or a Windows SDK build, e.g. "26100" or "10.0.22621".')
   }),
+  unreal: external_exports.strictObject({
+    enabled: enabled(
+      "Unreal Engine development: Visual Studio Community 2022 with the C++ game workload (MSVC, a Windows 11 SDK, .NET Framework targeting packs, Unreal integration and the Epic Games Launcher) and the DirectX End-User Runtime. A real installer: it runs every boot (~10 GB on the sandbox disk). The engine itself comes from the Epic Games Launcher or its source.",
+      "a .uproject or .uplugin"
+    ),
+    acceptLicense: external_exports.boolean().describe(
+      "Required to install: you accept the Visual Studio Community licence terms (https://visualstudio.microsoft.com/license-terms/) and the DirectX End-User Runtime licence."
+    ),
+    components: StringsSchema.describe(
+      'More Visual Studio workload or component IDs to add, e.g. ["Microsoft.VisualStudio.Component.VC.Llvm.Clang"].'
+    ),
+    keepInstallFiles: external_exports.boolean().describe(
+      "Keep an offline copy of the Visual Studio install files in tools\\visualstudio (~10 GB, made once), so later boots install without downloading them again. Skipped while that disk has too little room."
+    )
+  }),
   cpp: external_exports.strictObject({
     enabled: enabled(
       "MinGW-w64 GCC with CMake, Ninja, premake5 and mingw32-make (also Rust's linker).",
@@ -54689,7 +54705,23 @@ import { spawn as spawn8 } from "node:child_process";
 // src/host/secrets/secret-store.ts
 import { spawnSync as spawnSync19 } from "node:child_process";
 var TIMEOUT_MS2 = 6e4;
+var toolsFor = /* @__PURE__ */ new Map();
+function dpapiTool(storageRoot) {
+  if (!toolsFor.has(storageRoot)) {
+    let exe = null;
+    try {
+      exe = hostToolsExe(storageRoot);
+    } catch {
+    }
+    toolsFor.set(storageRoot, exe);
+  }
+  return toolsFor.get(storageRoot) ?? null;
+}
 var DpapiBox = class {
+  constructor(storageRoot) {
+    this.storageRoot = storageRoot;
+  }
+  storageRoot;
   kind = "dpapi1";
   seal(plain2) {
     return this.run("protect", plain2.toString("base64"));
@@ -54698,7 +54730,9 @@ var DpapiBox = class {
     return Buffer.from(this.run("unprotect", sealed), "base64");
   }
   run(mode, input2) {
-    const result = spawnSync19(SYSTEM.powershell(), nativeScript("protect-data.ps1", ["-Mode", mode]), {
+    const tools = this.storageRoot ? dpapiTool(this.storageRoot) : null;
+    const [exe, args] = tools ? [tools, [mode]] : [SYSTEM.powershell(), nativeScript("protect-data.ps1", ["-Mode", mode])];
+    const result = spawnSync19(exe, args, {
       input: input2,
       encoding: "utf8",
       windowsHide: true,
@@ -54726,17 +54760,17 @@ var SecretStore = class _SecretStore {
     this.box = box;
   }
   box;
-  /** Windows DPAPI, current user. */
-  static dpapi() {
-    return new _SecretStore(new DpapiBox());
+  /** Windows DPAPI, current user; with a storage folder, through its HostTools.exe (much faster than PowerShell). */
+  static dpapi(storageRoot = null) {
+    return new _SecretStore(new DpapiBox(storageRoot));
   }
   /** The test stand-in (not secure). */
   static memory() {
     return new _SecretStore(new MemoryBox());
   }
   /** What the program uses: DPAPI, except during the self-test (it never spawns Windows for this). */
-  static standard() {
-    return selfTestRunning() ? _SecretStore.memory() : _SecretStore.dpapi();
+  static standard(storageRoot = null) {
+    return selfTestRunning() ? _SecretStore.memory() : _SecretStore.dpapi(storageRoot);
   }
   /** True when `value` looks like something seal() made (any box). */
   static isSealed(value) {
@@ -55134,7 +55168,7 @@ function realLiveFolders(storageRoot, dataPath) {
   return new LiveFolders({
     storageRoot,
     dataPath,
-    secrets: SecretStore.standard(),
+    secrets: SecretStore.standard(storageRoot),
     elevated: new ScriptLivePort(),
     userSid: currentUserSid,
     isAlive: isSandboxRunning
@@ -56008,6 +56042,8 @@ var MAX_PLUGIN_BYTES = 1024 * 1024 * 1024;
 var MAX_SETTINGS_BYTES = 4 * 1024 * 1024;
 var MAX_DEPTH = 24;
 var INSTALLED = "installed_plugins.json";
+var RECORDS = [INSTALLED, "known_marketplaces.json"];
+var MAX_RECORD_BYTES2 = 4 * 1024 * 1024;
 function isObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -56054,7 +56090,7 @@ var PluginShare = class _PluginShare {
   /** When a sandbox ends: its plugins refresh the shared set. Never throws; returns the problem, if any. */
   saveQuietly(dataPath, claudeDir) {
     try {
-      if (_PluginShare.hasPlugins(claudeDir)) this.save(dataPath, claudeDir);
+      if (_PluginShare.hasPlugins(claudeDir) && !this.matches(claudeDir)) this.save(dataPath, claudeDir);
       return null;
     } catch (e) {
       return errMsg(e);
@@ -56108,9 +56144,24 @@ var PluginShare = class _PluginShare {
       if (isObject2(shared[key3])) merged[key3] = { ...shared[key3], ...isObject2(merged[key3]) ? merged[key3] : {} };
     writeSandboxJson(file2, merged);
   }
+  /**
+   * Whether the shared set already holds this Claude folder's plugins: the same plugin records and plugin settings.
+   * Copying a big plugins folder takes seconds, so a switch between accounts with the same plugins skips it.
+   */
+  matches(claudeDir) {
+    if (!this.hasShared()) return false;
+    const same3 = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+    for (const name2 of RECORDS) {
+      const own2 = readUntrusted(path67.join(claudeDir, "plugins", name2), MAX_RECORD_BYTES2);
+      if (!same3(own2, readUntrusted(path67.join(this.pluginsDir, name2), MAX_RECORD_BYTES2))) return false;
+    }
+    const shared = readUntrusted(this.settingsFile, MAX_SETTINGS_BYTES);
+    return same3(pluginSettings(claudeDir), isObject2(shared) ? shared : {});
+  }
   /** One step when an account is switched to. */
   sync(dataPath, claudeDir) {
     if (_PluginShare.hasPlugins(claudeDir)) {
+      if (this.matches(claudeDir)) return "nothing";
       this.save(dataPath, claudeDir);
       return "saved";
     }
@@ -56170,7 +56221,7 @@ function assertName(name2) {
 }
 var AccountStore = class {
   /** @param sharePlugins claudeProfile.sharePluginsAcrossAccounts: carry Claude plugins to the account switched to */
-  constructor(storageRoot, sharePlugins = false, secrets = SecretStore.standard()) {
+  constructor(storageRoot, sharePlugins = false, secrets = SecretStore.standard(storageRoot)) {
     this.storageRoot = storageRoot;
     this.sharePlugins = sharePlugins;
     this.secrets = secrets;
@@ -56345,7 +56396,7 @@ var AgentAccountStore = class {
   /**
    * @param loginFiles files of the login, relative to the folder they are read from and written to
    */
-  constructor(storageRoot, agent, loginFiles, secrets = SecretStore.standard()) {
+  constructor(storageRoot, agent, loginFiles, secrets = SecretStore.standard(storageRoot)) {
     this.storageRoot = storageRoot;
     this.agent = agent;
     this.loginFiles = loginFiles;
@@ -56508,7 +56559,7 @@ function checkGithubToken(token) {
   return githubTokenKind(token) ?? fail("That is not a GitHub personal access token.", "Run: sandbox github login");
 }
 var GithubToken = class {
-  constructor(storageRoot, secrets = SecretStore.standard()) {
+  constructor(storageRoot, secrets = SecretStore.standard(storageRoot)) {
     this.storageRoot = storageRoot;
     this.secrets = secrets;
   }
@@ -57191,6 +57242,7 @@ var MARKERS = {
   ],
   rust: ["Cargo.toml", "rust-toolchain", "rust-toolchain.toml"],
   msvc: ["*.vcxproj", "CMakePresets.json", "CMakeUserPresets.json"],
+  unreal: ["*.uproject", "*.uplugin"],
   cpp: [
     "CMakeLists.txt",
     "Makefile",
@@ -57249,6 +57301,11 @@ function decideToolchains(settings, entries, pcHas, hints = {}) {
       on: false,
       reason: "would be used (" + result.msvc.reason + "); set toolchains.msvc.acceptLicense to install it"
     };
+  if (settings.unreal.enabled === "auto" && result.unreal.on && !settings.unreal.acceptLicense)
+    result.unreal = {
+      on: false,
+      reason: "would be used (" + result.unreal.reason + "); set toolchains.unreal.acceptLicense to install it"
+    };
   if (result.rust.on && !result.msvc.on && !result.cpp.on && settings.cpp.enabled !== false)
     result.cpp = { on: true, reason: "the linker for Rust" };
   if (result.python.on && settings.uv.enabled === "auto" && settings.python.tools.length > 0 && !result.uv.on)
@@ -59144,7 +59201,7 @@ function loginProblem(c2) {
   return null;
 }
 var VpnLogin = class {
-  constructor(storageRoot, secrets = SecretStore.standard()) {
+  constructor(storageRoot, secrets = SecretStore.standard(storageRoot)) {
     this.storageRoot = storageRoot;
     this.secrets = secrets;
   }
@@ -70288,7 +70345,7 @@ var TlsStore = class {
 
 // src/app/features/access/access.run.ts
 function accessStoreOf(ctx) {
-  return AccessStore.at(ctx.storageRoot, SecretStore.standard(), {
+  return AccessStore.at(ctx.storageRoot, SecretStore.standard(ctx.storageRoot), {
     // The self-test never changes folder permissions; its storage is a temp folder.
     protect: selfTestRunning() ? void 0 : (dir) => protectPrivateFolder(dir)
   });
@@ -78297,7 +78354,7 @@ async function attachOpened(ctx, session) {
     nextStep("sandbox attach " + session);
     return 0;
   }
-  const { attach: attach2 } = await import("./chunk-PXTLKIV4.js");
+  const { attach: attach2 } = await import("./chunk-XYUVIVJT.js");
   return attach2({ ...ctx, options: { ...ctx.options, positionals: [session] } });
 }
 function definitionHandler(def) {
@@ -78389,7 +78446,7 @@ function remoteAudit(ctx) {
   };
 }
 function remoteGate(ctx) {
-  const secrets = SecretStore.standard();
+  const secrets = SecretStore.standard(ctx.storageRoot);
   let ownerSid = "";
   try {
     ownerSid = currentUserSid();

package/dist/bin/{chunk-PXTLKIV4.js → chunk-XYUVIVJT.js}

@@ -1,7 +1,7 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   attach
-} from "./chunk-HIC4CUMY.js";
+} from "./chunk-REE3EMHD.js";
 export {
   attach
 };

package/dist/bin/claude-host.js

@@ -2,8 +2,8 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   run
-} from "./chunk-7EXDUNE7.js";
-import "./chunk-HIC4CUMY.js";
+} from "./chunk-QLGGAG3D.js";
+import "./chunk-REE3EMHD.js";
 
 // src/bin/claude-host.ts
 var args = process.argv.slice(2);

package/dist/bin/claude-sbx.js

@@ -2,8 +2,8 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   run
-} from "./chunk-7EXDUNE7.js";
-import "./chunk-HIC4CUMY.js";
+} from "./chunk-QLGGAG3D.js";
+import "./chunk-REE3EMHD.js";
 
 // src/bin/claude-sbx.ts
 run(process.argv.slice(2), { harness: "claude" });

package/dist/bin/codex-sbx.js

@@ -2,8 +2,8 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   run
-} from "./chunk-7EXDUNE7.js";
-import "./chunk-HIC4CUMY.js";
+} from "./chunk-QLGGAG3D.js";
+import "./chunk-REE3EMHD.js";
 
 // src/bin/codex-sbx.ts
 run(process.argv.slice(2), { harness: "codex" });

package/dist/bin/gemini-sbx.js

@@ -2,8 +2,8 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   run
-} from "./chunk-7EXDUNE7.js";
-import "./chunk-HIC4CUMY.js";
+} from "./chunk-QLGGAG3D.js";
+import "./chunk-REE3EMHD.js";
 
 // src/bin/gemini-sbx.ts
 run(process.argv.slice(2), { harness: "gemini" });

package/dist/bin/sandbox.js

@@ -2,8 +2,8 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   run
-} from "./chunk-7EXDUNE7.js";
-import "./chunk-HIC4CUMY.js";
+} from "./chunk-QLGGAG3D.js";
+import "./chunk-REE3EMHD.js";
 
 // src/bin/sandbox.ts
 run(process.argv.slice(2));

package/dist/bin/sbx-hide.js

@@ -2,8 +2,8 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   run
-} from "./chunk-7EXDUNE7.js";
-import "./chunk-HIC4CUMY.js";
+} from "./chunk-QLGGAG3D.js";
+import "./chunk-REE3EMHD.js";
 
 // src/bin/sbx-hide.ts
 run(process.argv.slice(2), { command: "hide" });