windows-development-sandbox 1.5.0 → 1.7.0

package/node_modules/ws/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "ws",
+  "version": "8.22.0",
+  "description": "Simple to use, blazing fast and thoroughly tested websocket client and server for Node.js",
+  "keywords": [
+    "HyBi",
+    "Push",
+    "RFC-6455",
+    "WebSocket",
+    "WebSockets",
+    "real-time"
+  ],
+  "homepage": "https://github.com/websockets/ws",
+  "bugs": "https://github.com/websockets/ws/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/websockets/ws.git"
+  },
+  "author": "Einar Otto Stangvik <einaros@gmail.com> (http://2x.io)",
+  "license": "MIT",
+  "main": "index.js",
+  "exports": {
+    ".": {
+      "browser": "./browser.js",
+      "import": "./wrapper.mjs",
+      "require": "./index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "browser": "browser.js",
+  "engines": {
+    "node": ">=10.0.0"
+  },
+  "files": [
+    "browser.js",
+    "index.js",
+    "lib/*.js",
+    "wrapper.mjs"
+  ],
+  "scripts": {
+    "test": "nyc --reporter=lcov --reporter=text mocha --throw-deprecation test/*.test.js",
+    "integration": "mocha --throw-deprecation test/*.integration.js",
+    "lint": "eslint . && prettier --check --ignore-path .gitignore \"**/*.{json,md,yaml,yml}\""
+  },
+  "peerDependencies": {
+    "bufferutil": "^4.0.1",
+    "utf-8-validate": ">=5.0.2"
+  },
+  "peerDependenciesMeta": {
+    "bufferutil": {
+      "optional": true
+    },
+    "utf-8-validate": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "benchmark": "^2.1.4",
+    "bufferutil": "^4.0.1",
+    "eslint": "^10.0.1",
+    "eslint-config-prettier": "^10.0.1",
+    "eslint-plugin-prettier": "^5.0.0",
+    "globals": "^17.0.0",
+    "mocha": "^8.4.0",
+    "nyc": "^15.0.0",
+    "prettier": "^3.0.0",
+    "utf-8-validate": "^6.0.0"
+  },
+  "allowScripts": {
+    "bufferutil": true,
+    "utf-8-validate": true
+  }
+}

package/node_modules/ws/wrapper.mjs

@@ -0,0 +1,21 @@
+import createWebSocketStream from './lib/stream.js';
+import extension from './lib/extension.js';
+import PerMessageDeflate from './lib/permessage-deflate.js';
+import Receiver from './lib/receiver.js';
+import Sender from './lib/sender.js';
+import subprotocol from './lib/subprotocol.js';
+import WebSocket from './lib/websocket.js';
+import WebSocketServer from './lib/websocket-server.js';
+
+export {
+  createWebSocketStream,
+  extension,
+  PerMessageDeflate,
+  Receiver,
+  Sender,
+  subprotocol,
+  WebSocket,
+  WebSocketServer
+};
+
+export default WebSocket;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "windows-development-sandbox",
-  "version": "1.5.0",
+  "version": "1.7.0",
   "description": "A disposable Windows Sandbox for development, with or without an AI agent (Claude Code, Codex, Gemini, opencode, ...): the folder you run it from is the workspace, toolchains and databases for your project install themselves, and nothing else on your PC is reachable.",
   "type": "module",
   "license": "MIT",
@@ -42,7 +42,7 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.json && node scripts/bundle.mjs && node scripts/schemas.mjs",
+    "build": "tsc -p tsconfig.json && node scripts/bundle.mjs && node scripts/bundle-web.mjs && node scripts/schemas.mjs",
     "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
     "rebuild": "npm run clean && npm run build",
     "test": "npm run build && node dist/bin/agent-sandbox.js self-test",
@@ -53,9 +53,9 @@
     "install:global": "node scripts/install-global.mjs",
     "publish:npm": "node scripts/publish-npm.mjs",
     "doctor": "node dist/bin/agent-sandbox.js doctor",
-    "lint": "eslint src scripts",
-    "format": "prettier --write src scripts",
-    "format:check": "prettier --check src scripts"
+    "lint": "eslint src scripts web",
+    "format": "prettier --write src scripts web",
+    "format:check": "prettier --check src scripts web"
   },
   "publishConfig": {
     "access": "public"
@@ -79,6 +79,7 @@
     "ignore": "^7.0.12",
     "jsonc-parser": "^3.3.1",
     "lodash": "^4.18.1",
+    "ws": "^8.22.0",
     "zod": "^4.6.5"
   },
   "bundleDependencies": [
@@ -87,15 +88,24 @@
     "ignore",
     "jsonc-parser",
     "lodash",
+    "ws",
     "zod"
   ],
   "devDependencies": {
     "@eslint/js": "^9.39.5",
     "@types/lodash": "^4.17.26",
     "@types/node": "^22.0.0",
+    "@types/react": "^18.3.31",
+    "@types/react-dom": "^18.3.7",
+    "@types/ws": "^8.18.2",
+    "@xterm/addon-fit": "^0.11.0",
+    "@xterm/xterm": "^6.0.0",
+    "bootstrap": "^5.3.8",
     "esbuild": "^0.28.2",
     "eslint": "^9.39.5",
     "prettier": "^3.9.10",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
     "typescript": "^5.8.0",
     "typescript-eslint": "^8.71.2"
   },

package/sandbox/csharp/EnvBroadcast.cs

@@ -0,0 +1,33 @@
+// Tells running programs (Explorer, Windows Terminal) that the machine environment changed, so new windows and tabs
+// read the current PATH. Loaded by scripts\set-machine-environment.ps1 (Add-Type). C# 5.
+using System;
+using System.ComponentModel;
+using System.Runtime.InteropServices;
+
+namespace AgentSandbox
+{
+    public static class EnvBroadcast
+    {
+        private static readonly IntPtr HwndBroadcast = new IntPtr(0xffff);
+        private const uint WmSettingChange = 0x001A;
+        private const uint SmtoAbortIfHung = 0x0002;
+        private const uint TimeoutMs = 2000;
+
+        private static class NativeMethods
+        {
+            [DllImport("user32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+            public static extern IntPtr SendMessageTimeout(IntPtr window, uint message, UIntPtr wParam, string lParam, uint flags, uint timeout, out UIntPtr result);
+        }
+
+        /// <summary>Broadcasts WM_SETTINGCHANGE "Environment". Throws on failure.</summary>
+        public static void Notify()
+        {
+            UIntPtr result;
+            IntPtr sent = NativeMethods.SendMessageTimeout(HwndBroadcast, WmSettingChange, UIntPtr.Zero, "Environment", SmtoAbortIfHung, TimeoutMs, out result);
+            if (sent == IntPtr.Zero)
+            {
+                throw new Win32Exception(Marshal.GetLastWin32Error());
+            }
+        }
+    }
+}

package/sandbox/csharp/PathSync.cs

@@ -0,0 +1,90 @@
+// Prints the PATH a new shell should have: the machine and user PATH from the registry (variables expanded, no
+// duplicates), then anything only this process has. Shell start-up files (PowerShell profile, cmd AutoRun, Git Bash
+// profile.d) call it so every new shell sees tools added after its parent started. Built per boot by csc. C# 5.
+// Usage: pathsync [--machine <path> --user <path> --process <path>] (the options replace the registry/environment
+// values, for tests).
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using Microsoft.Win32;
+
+namespace AgentSandbox
+{
+    public static class PathSync
+    {
+        private const string MachineKey = @"SYSTEM\CurrentControlSet\Control\Session Manager\Environment";
+        private const string UserKey = "Environment";
+
+        public static int Main(string[] args)
+        {
+            string machine = null;
+            string user = null;
+            string process = null;
+            for (int i = 0; i + 1 < args.Length; i += 2)
+            {
+                if (args[i] == "--machine") { machine = args[i + 1]; }
+                else if (args[i] == "--user") { user = args[i + 1]; }
+                else if (args[i] == "--process") { process = args[i + 1]; }
+            }
+            if (machine == null) { machine = ReadRegistry(Registry.LocalMachine, MachineKey); }
+            if (user == null) { user = ReadRegistry(Registry.CurrentUser, UserKey); }
+            if (process == null) { process = Environment.GetEnvironmentVariable("PATH") ?? ""; }
+
+            List<string> result = new List<string>();
+            HashSet<string> seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+            // Entries only this process has come first: a parent put them there on purpose (a virtual environment).
+            HashSet<string> registry = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+            foreach (string folder in Split(machine + ";" + user)) { registry.Add(Key(folder)); }
+            string runnerNode = RunnerNode();
+            foreach (string folder in Split(process))
+            {
+                if (registry.Contains(Key(folder)) || Key(folder) == runnerNode) { continue; }
+                Add(result, seen, folder);
+            }
+            foreach (string folder in Split(machine)) { Add(result, seen, folder); }
+            foreach (string folder in Split(user)) { Add(result, seen, folder); }
+            Console.Out.Write(string.Join(";", result.ToArray()));
+            return 0;
+        }
+
+        private static string ReadRegistry(RegistryKey root, string subKey)
+        {
+            using (RegistryKey key = root.OpenSubKey(subKey))
+            {
+                if (key == null) { return ""; }
+                object value = key.GetValue("Path", "", RegistryValueOptions.DoNotExpandEnvironmentNames);
+                return value == null ? "" : value.ToString();
+            }
+        }
+
+        /// <summary>The runner's own Node (AGENT_TOOLS\node) is not meant for shells: nvm's node is.</summary>
+        private static string RunnerNode()
+        {
+            string tools = Environment.GetEnvironmentVariable("AGENT_TOOLS");
+            return string.IsNullOrEmpty(tools) ? "" : Key(Path.Combine(tools, "node"));
+        }
+
+        private static IEnumerable<string> Split(string path)
+        {
+            foreach (string part in Environment.ExpandEnvironmentVariables(path).Split(';'))
+            {
+                string folder = part.Trim().Trim('"');
+                if (folder.Length > 0) { yield return folder; }
+            }
+        }
+
+        private static string Key(string folder)
+        {
+            const char Slash = (char)92;
+            string key = folder.Replace('/', Slash);
+            if (key.Length > 3) { key = key.TrimEnd(Slash); }
+            return key.ToLowerInvariant();
+        }
+
+        private static void Add(List<string> result, HashSet<string> seen, string folder)
+        {
+            if (seen.Add(Key(folder))) { result.Add(folder); }
+        }
+    }
+}

package/sandbox/scripts/install-shell-path.ps1

@@ -0,0 +1,73 @@
+#Requires -Version 5.1
+# Every new shell starts with the CURRENT machine + user PATH, whatever its parent had: tools added later in the boot
+# (python, rust, pwsh, agents ...) reach Windows Terminal tabs, Explorer launches and every other shell this way. The
+# start-up files call pathsync.exe (sandbox\csharp\PathSync.cs, built each boot):
+#   Windows PowerShell and PowerShell 7: the all-users profile.ps1
+#   cmd.exe: HKLM\Software\Microsoft\Command Processor AutoRun -> shell-path.cmd (does nothing for `cmd /c`)
+#   Git Bash: etc\profile.d\agent-sandbox-path.sh
+# -Helper is pathsync.exe. -PwshDir and -GitRoot are optional. -Root writes under that folder instead of the machine
+# (tests): no registry is touched then.
+param(
+    [Parameter(Mandatory = $true)][string]$Helper,
+    [string]$PwshDir = '',
+    [string]$GitRoot = '',
+    [string]$Root = ''
+)
+$ErrorActionPreference = 'Stop'
+
+$marker = 'agent-sandbox path sync'
+
+function Write-Ours([string]$file, [string]$text) {
+    if (Test-Path -LiteralPath $file) {
+        if (-not (Select-String -LiteralPath $file -SimpleMatch $marker -Quiet)) { return }
+    } else {
+        New-Item -ItemType Directory -Force -Path (Split-Path -Parent $file) | Out-Null
+    }
+    [IO.File]::WriteAllText($file, $text, (New-Object Text.UTF8Encoding($false)))
+}
+
+$profileText = "# $marker`r`n" +
+    "try { `$p = & '$Helper'; if (`$p) { `$env:Path = `$p } } catch { }`r`n"
+
+$windowsProfileDir = if ($Root) { Join-Path $Root 'windowspowershell' } else { Join-Path $env:windir 'System32\WindowsPowerShell\v1.0' }
+Write-Ours (Join-Path $windowsProfileDir 'profile.ps1') $profileText
+if ($PwshDir -and (Test-Path -LiteralPath $PwshDir)) { Write-Ours (Join-Path $PwshDir 'profile.ps1') $profileText }
+
+# cmd: interactive only. `cmd /c ...` (what programs and for /f start) has /c in its command line and leaves at once, which
+# also stops the loop of the for /f below.
+$cmdFile = Join-Path (Split-Path -Parent $Helper) 'shell-path.cmd'
+$cmdText = "@echo off`r`n" +
+    "rem $marker`r`n" +
+    "setlocal enabledelayedexpansion`r`n" +
+    "set `"_L=!cmdcmdline!`"`r`n" +
+    "if not `"!_L:/c=!`"==`"!_L!`" exit /b 0`r`n" +
+    "if not `"!_L:/r=!`"==`"!_L!`" exit /b 0`r`n" +
+    "set `"_P=`"`r`n" +
+    "for /f `"delims=`" %%P in ('`"$Helper`"') do set `"_P=%%P`"`r`n" +
+    "if not defined _P exit /b 0`r`n" +
+    "endlocal & set `"PATH=%_P%`"`r`n"
+if (-not (Test-Path -LiteralPath $cmdFile) -or (Select-String -LiteralPath $cmdFile -SimpleMatch $marker -Quiet)) {
+    [IO.File]::WriteAllText($cmdFile, $cmdText, [Text.Encoding]::ASCII)
+}
+if (-not $Root) {
+    $key = 'HKLM:\Software\Microsoft\Command Processor'
+    $current = (Get-ItemProperty -Path $key -Name AutoRun -ErrorAction SilentlyContinue).AutoRun
+    if (-not $current -or $current -like '*shell-path.cmd*') {
+        if (-not (Test-Path $key)) { New-Item -Path $key -Force | Out-Null }
+        Set-ItemProperty -Path $key -Name AutoRun -Value "if exist `"$cmdFile`" call `"$cmdFile`""
+    }
+}
+
+if ($GitRoot -and (Test-Path -LiteralPath (Join-Path $GitRoot 'etc\profile.d'))) {
+    $posixHelper = $Helper -replace '\\', '/'
+    $shText = "# $marker`n" +
+        "_w=`"`$('$posixHelper' 2>/dev/null)`"`n" +
+        "if [ -n `"`$_w`" ]; then`n" +
+        "  _n=`"`$(cygpath -u -p `"`$_w`" 2>/dev/null)`"`n" +
+        "  _o=`$IFS; IFS=:`n" +
+        "  for _d in `$_n; do case `":`$PATH:`" in *`":`$_d:`"*) ;; *) PATH=`"`$PATH:`$_d`" ;; esac; done`n" +
+        "  IFS=`$_o; export PATH`n" +
+        "fi`n" +
+        "unset _w _n _o _d`n"
+    Write-Ours (Join-Path $GitRoot 'etc\profile.d\agent-sandbox-path.sh') $shText
+}

package/sandbox/scripts/set-machine-environment.ps1

@@ -2,28 +2,61 @@
 # Machine-wide environment variables and PATH folders, so every new terminal tab and anything an agent starts sees the
 # same tools (guest/setup/environment.ts). -SettingsFile is JSON written by the runtime:
 #   vars: { name: value }   set machine-wide (with additive: only the ones not set yet)
-#   path: string | null      replaces the machine PATH
+#   path: string | null      replaces the machine PATH (already ordered and de-duplicated by the runtime)
 #   add: [folders]           added to PATH when missing: in front, or (additive) at the end
+#   create: [folders]        created first (folders a tool fills in later, such as pip's Scripts)
+# The PATH is always saved without duplicates (case, trailing slash) and Explorer / Windows Terminal are told.
 param([Parameter(Mandatory = $true)][string]$SettingsFile)
 $ErrorActionPreference = 'Stop'
 
 $settings = Get-Content -LiteralPath $SettingsFile -Raw -Encoding UTF8 | ConvertFrom-Json
 $additive = [bool]$settings.additive
 
+function Get-Key([string]$folder) {
+    $key = $folder.Trim().Trim('"')
+    if ($key.Length -gt 3) { $key = $key.TrimEnd('\', '/') }
+    return $key.ToLowerInvariant()
+}
+
+function Join-Folders([string[]]$folders) {
+    $seen = @{}
+    $kept = foreach ($folder in $folders) {
+        if ([string]::IsNullOrWhiteSpace($folder)) { continue }
+        $key = Get-Key $folder
+        if ($seen.ContainsKey($key)) { continue }
+        $seen[$key] = $true
+        $folder.Trim()
+    }
+    return ($kept -join ';')
+}
+
+foreach ($folder in @($settings.create)) {
+    if ($folder) { New-Item -ItemType Directory -Force -Path $folder | Out-Null }
+}
+
 foreach ($variable in $settings.vars.PSObject.Properties) {
     if ($additive -and [Environment]::GetEnvironmentVariable($variable.Name, 'Machine')) { continue }
     [Environment]::SetEnvironmentVariable($variable.Name, [string]$variable.Value, 'Machine')
 }
 
 if ($null -ne $settings.path) {
-    [Environment]::SetEnvironmentVariable('Path', [string]$settings.path, 'Machine')
+    [Environment]::SetEnvironmentVariable('Path', (Join-Folders ([string]$settings.path -split ';')), 'Machine')
 }
 
 if ($settings.add) {
     $current = [Environment]::GetEnvironmentVariable('Path', 'Machine') -split ';'
-    $missing = @($settings.add | Where-Object { $current -notcontains $_ })
+    $known = @{}
+    foreach ($folder in $current) { $known[(Get-Key $folder)] = $true }
+    $missing = @($settings.add | Where-Object { -not $known.ContainsKey((Get-Key $_)) })
     if ($missing.Count) {
         $combined = if ($additive) { $current + $missing } else { $missing + $current }
-        [Environment]::SetEnvironmentVariable('Path', ($combined -join ';'), 'Machine')
+        [Environment]::SetEnvironmentVariable('Path', (Join-Folders $combined), 'Machine')
     }
 }
+
+try {
+    Add-Type -Path (Join-Path $PSScriptRoot '..\csharp\EnvBroadcast.cs')
+    [AgentSandbox.EnvBroadcast]::Notify()
+} catch {
+    # Programs started later read the registry anyway; only windows that are already open miss the news.
+}

package/schemas/config.schema.json

@@ -227,7 +227,7 @@
         "root": {
           "type": "string",
           "minLength": 1,
-          "description": "Where everything is kept on this PC (tools, databases, logins, launches)."
+          "description": "Where everything is kept on this PC (tools, databases, logins, launches). The default is a private folder for you under %ProgramData%\\AgentSandbox\\users, which works for installs for one user and for everyone. sandbox storage move <folder> moves it."
         },
         "persistAgentState": {
           "type": "boolean",
@@ -313,6 +313,45 @@
       },
       "additionalProperties": false
     },
+    "vpn": {
+      "type": "object",
+      "properties": {
+        "enabled": {
+          "type": "boolean",
+          "description": "Send the sandbox's traffic through a VPN. Only the sandbox: your PC's own connection is untouched. Needs a saved login first (sandbox vpn login). The agent in the sandbox can read that login and can turn the tunnel off (it is the administrator there)."
+        },
+        "provider": {
+          "type": "string",
+          "enum": [
+            "nordvpn",
+            "openvpn-file"
+          ],
+          "description": "nordvpn: a recommended NordVPN server is picked at every launch. openvpn-file: your own .ovpn file (configFile)."
+        },
+        "protocol": {
+          "type": "string",
+          "enum": [
+            "udp",
+            "tcp"
+          ],
+          "description": "udp is faster; tcp gets through networks that block udp."
+        },
+        "country": {
+          "type": "string",
+          "pattern": "^([A-Za-z][A-Za-z .'-]{0,39})?$",
+          "description": "nordvpn: the country of the server, e.g. uk, us or Germany. Empty = the best server anywhere."
+        },
+        "configFile": {
+          "type": "string",
+          "description": "openvpn-file: the .ovpn file on this PC (its certificates inside it). Files that run programs (script-security, up, down, plugin ...) are refused. A project's file can never set this."
+        },
+        "killSwitch": {
+          "type": "boolean",
+          "description": "Block all traffic that does not go through the tunnel: when the tunnel cannot start, the sandbox stays offline instead of using your normal connection. A project can only turn this on, never off."
+        }
+      },
+      "additionalProperties": false
+    },
     "provisioning": {
       "type": "object",
       "properties": {
@@ -1147,6 +1186,22 @@
       },
       "additionalProperties": false
     },
+    "web": {
+      "type": "object",
+      "properties": {
+        "enabled": {
+          "type": "boolean",
+          "description": "(Beta) Allow the web UI: your sandbox sessions in a browser on this PC. Off by default, and nothing starts it by itself yet: sandbox web start works either way and runs it until sandbox web stop (or a restart of the PC)."
+        },
+        "port": {
+          "type": "integer",
+          "minimum": 1024,
+          "maximum": 65535,
+          "description": "Port of the web UI on 127.0.0.1 (this PC only). Pick another when it is taken."
+        }
+      },
+      "additionalProperties": false
+    },
     "agentCommands": {
       "type": "object",
       "properties": {
@@ -1236,6 +1291,7 @@
               "sourcegit",
               "githubdesktop",
               "lazygit",
+              "jj",
               "7zip",
               "winmerge",
               "everything",
@@ -1288,7 +1344,9 @@
               "ffmpeg",
               "sqlite",
               "shellcheck",
-              "gitleaks"
+              "gitleaks",
+              "ast-grep",
+              "rust-analyzer"
             ]
           },
           "description": "Apps from the catalogue to install in every sandbox (the Apps screen in the menu lists them by category). Each is downloaded once and kept."
@@ -1388,6 +1446,10 @@
           "type": "boolean",
           "description": "Refresh these settings from this PC on every launch."
         },
+        "sharePluginsAcrossAccounts": {
+          "type": "boolean",
+          "description": "When you switch Claude accounts, copy your Claude plugins (and which ones are enabled) into a data set that has none yet. Off by default: plugins are code that runs in your sessions."
+        },
         "syncHistory": {
           "type": "boolean",
           "description": "Bring conversation history in, and sync new history back (path-translated)."
@@ -1457,9 +1519,10 @@
               "type": "string"
             },
             "additionalProperties": {
-              "type": "string"
+              "type": "string",
+              "secret": true
             },
-            "description": "Environment variables for the agent."
+            "description": "Environment variables for the agent (API keys go here). Their values are shown as *** and are handed to the sandbox in a one-shot file, never kept in the launch folder. The agent can read its own environment."
           },
           "home": {
             "description": "Where its login lives inside the sandbox; leave out when the agent cannot be pointed at a folder (then its login is not kept between sandboxes).",
@@ -1501,6 +1564,18 @@
             },
             "additionalProperties": false
           },
+          "localState": {
+            "description": "Environment variable -> folder below the agent's own state folder (state\\<agent>) for SQLite databases. SQLite cannot run in a mapped folder, so the agent runs from a copy on the sandbox's disk (the variable points to it) that is copied from and back to that folder.",
+            "type": "object",
+            "propertyNames": {
+              "type": "string",
+              "pattern": "^[A-Za-z_][A-Za-z0-9_]*$"
+            },
+            "additionalProperties": {
+              "type": "string",
+              "pattern": "^(?!.*(^|[\\\\/])\\.\\.([\\\\/]|$))[A-Za-z0-9._ -]+([\\\\/][A-Za-z0-9._ -]+)*$"
+            }
+          },
           "resumeArguments": {
             "description": "Arguments used when the agent is restarted in place (e.g. after an account switch) so it resumes the conversation.",
             "type": "array",

package/schemas/sandbox-config.schema.json

@@ -183,6 +183,16 @@
       },
       "additionalProperties": false
     },
+    "vpn": {
+      "type": "object",
+      "properties": {
+        "killSwitch": {
+          "type": "boolean",
+          "description": "Block all traffic that does not go through the tunnel: when the tunnel cannot start, the sandbox stays offline instead of using your normal connection. A project can only turn this on, never off."
+        }
+      },
+      "additionalProperties": false
+    },
     "provisioning": {
       "type": "object",
       "properties": {
@@ -1040,6 +1050,7 @@
               "sourcegit",
               "githubdesktop",
               "lazygit",
+              "jj",
               "7zip",
               "winmerge",
               "everything",
@@ -1092,7 +1103,9 @@
               "ffmpeg",
               "sqlite",
               "shellcheck",
-              "gitleaks"
+              "gitleaks",
+              "ast-grep",
+              "rust-analyzer"
             ]
           },
           "description": "Apps from the catalogue to install in every sandbox (the Apps screen in the menu lists them by category). Each is downloaded once and kept."

package/dist/cli/commands/repair/checks.d.ts

@@ -1,2 +0,0 @@
-import { type RepairCheck } from './types.js';
-export declare const CHECKS: RepairCheck[];