windows-development-sandbox 1.5.0 → 1.9.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.9.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,31 @@
     "ignore",
     "jsonc-parser",
     "lodash",
+    "ws",
     "zod"
   ],
   "devDependencies": {
     "@eslint/js": "^9.39.5",
+    "@mantine/core": "^7.17.8",
+    "@mantine/form": "^7.17.8",
+    "@mantine/hooks": "^7.17.8",
+    "@mantine/modals": "^7.17.8",
+    "@mantine/notifications": "^7.17.8",
+    "@tabler/icons-react": "^3.49.0",
+    "@tanstack/react-query": "^5.104.3",
     "@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",
     "esbuild": "^0.28.2",
     "eslint": "^9.39.5",
+    "mantine-form-zod-resolver": "^1.3.0",
     "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/MemGov.cs

@@ -0,0 +1,398 @@
+// memgov.exe: the Windows side of the sandbox's memory governor (src/guest/governor). One long-running process the
+// daemon talks to over stdin/stdout, so the decisions stay in TypeScript and only the Win32 calls live here. C# 5.
+//
+//   stdout, a JSON line every --interval seconds (default 2):
+//     {"ramTotalMb":..,"ramAvailMb":..,"commitLimitMb":..,"commitAvailMb":..,"procs":[{"pid":..,"name":"rustc","mb":..,"prio":"normal"}]}
+//     procs = the processes in the agents' job (the job ptyhost makes for everything the agents start), nothing else.
+//   stdin, one command per line:
+//     priority <pid> <idle|below|normal>   lowers (or restores) the priority of a process in that job
+//     suspend <pid> <ms>                   pauses a process in that job, resumes it after ms (at most 30000)
+//     exit
+//
+// It only ever touches processes that are in the agents' job, never itself, and resumes everything it paused when it
+// ends or when the daemon goes away (stdin closes).
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Globalization;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+
+static class MemGov
+{
+    private const string AgentJobName = "Local\\AgentSandboxAgentsJob";
+    private const double BytesPerMb = 1024.0 * 1024.0;
+    private const int MaxProcesses = 1024;
+    private const int MaxSuspendMs = 30000;
+    private const uint JobObjectQuery = 0x0004;
+    private const int JobObjectBasicProcessIdList = 3;
+    private const uint ProcessQueryLimited = 0x1000;
+    private const uint ProcessSetInformation = 0x0200;
+    private const uint ProcessSuspendResume = 0x0800;
+    private const uint IdleClass = 0x00000040;
+    private const uint BelowNormalClass = 0x00004000;
+    private const uint NormalClass = 0x00000020;
+
+    // MEMORYSTATUSEX.
+    [StructLayout(LayoutKind.Sequential)]
+    private struct MemoryStatus
+    {
+        public uint Length;
+        public uint MemoryLoad;
+        public ulong TotalPhys;
+        public ulong AvailPhys;
+        public ulong TotalPageFile;
+        public ulong AvailPageFile;
+        public ulong TotalVirtual;
+        public ulong AvailVirtual;
+        public ulong AvailExtendedVirtual;
+    }
+
+    private static class NativeMethods
+    {
+        [DllImport("kernel32.dll", SetLastError = true)]
+        public static extern bool GlobalMemoryStatusEx(ref MemoryStatus status);
+
+        [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+        public static extern IntPtr OpenJobObjectW(uint access, bool inherit, string name);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        public static extern bool QueryInformationJobObject(IntPtr job, int infoClass, IntPtr info, int length, IntPtr returnLength);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        public static extern bool IsProcessInJob(IntPtr process, IntPtr job, out bool result);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        public static extern IntPtr OpenProcess(uint access, bool inherit, int pid);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        public static extern bool SetPriorityClass(IntPtr process, uint priorityClass);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        public static extern uint GetPriorityClass(IntPtr process);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        public static extern bool CloseHandle(IntPtr handle);
+
+        [DllImport("ntdll.dll")]
+        public static extern int NtSuspendProcess(IntPtr process);
+
+        [DllImport("ntdll.dll")]
+        public static extern int NtResumeProcess(IntPtr process);
+    }
+
+    private static readonly object Gate = new object();
+    private static readonly Dictionary<int, DateTime> Paused = new Dictionary<int, DateTime>();
+    private static IntPtr job = IntPtr.Zero;
+    private static volatile bool stop;
+
+    static int Main(string[] args)
+    {
+        if (args.Length == 0 || args[0] != "serve")
+        {
+            Console.Error.WriteLine("usage: memgov serve [--interval seconds]");
+            return 2;
+        }
+        int interval = 2;
+        for (int i = 1; i + 1 < args.Length; i++)
+        {
+            if (args[i] == "--interval")
+            {
+                int.TryParse(args[i + 1], NumberStyles.Integer, CultureInfo.InvariantCulture, out interval);
+            }
+        }
+        if (interval < 1)
+        {
+            interval = 2;
+        }
+        Thread commands = new Thread(ReadCommands);
+        commands.IsBackground = true;
+        commands.Start();
+        Thread resumer = new Thread(ResumeWhenDue);
+        resumer.IsBackground = true;
+        resumer.Start();
+        while (!stop)
+        {
+            try
+            {
+                Console.Out.WriteLine(Sample());
+                Console.Out.Flush();
+            }
+            catch (Exception)
+            {
+                // A sample that fails (a process ended while it was read) is skipped; the next one tries again.
+            }
+            for (int waited = 0; waited < interval * 10 && !stop; waited++)
+            {
+                Thread.Sleep(100);
+            }
+        }
+        ResumeAll();
+        return 0;
+    }
+
+    /// <summary>The job, opened once it exists (ptyhost makes it when the first agent starts).</summary>
+    private static IntPtr Job()
+    {
+        if (job == IntPtr.Zero)
+        {
+            job = NativeMethods.OpenJobObjectW(JobObjectQuery, false, AgentJobName);
+        }
+        return job;
+    }
+
+    private static string Sample()
+    {
+        MemoryStatus status = new MemoryStatus();
+        status.Length = (uint)Marshal.SizeOf(typeof(MemoryStatus));
+        if (!NativeMethods.GlobalMemoryStatusEx(ref status))
+        {
+            throw new Win32Exception(Marshal.GetLastWin32Error());
+        }
+        StringBuilder sb = new StringBuilder();
+        sb.Append("{\"ramTotalMb\":").Append(Mb(status.TotalPhys));
+        sb.Append(",\"ramAvailMb\":").Append(Mb(status.AvailPhys));
+        sb.Append(",\"commitLimitMb\":").Append(Mb(status.TotalPageFile));
+        sb.Append(",\"commitAvailMb\":").Append(Mb(status.AvailPageFile));
+        sb.Append(",\"procs\":[");
+        bool first = true;
+        int self = Process.GetCurrentProcess().Id;
+        foreach (int pid in JobProcessIds())
+        {
+            if (pid == self)
+            {
+                continue;
+            }
+            try
+            {
+                using (Process p = Process.GetProcessById(pid))
+                {
+                    if (!first)
+                    {
+                        sb.Append(',');
+                    }
+                    first = false;
+                    sb.Append("{\"pid\":").Append(pid.ToString(CultureInfo.InvariantCulture));
+                    sb.Append(",\"name\":").Append(Json(p.ProcessName));
+                    sb.Append(",\"mb\":").Append(Mb((ulong)p.PrivateMemorySize64));
+                    sb.Append(",\"prio\":\"").Append(PriorityName(pid)).Append("\"}");
+                }
+            }
+            catch (Exception)
+            {
+                // The process ended while it was read.
+            }
+        }
+        return sb.Append("]}").ToString();
+    }
+
+    private static List<int> JobProcessIds()
+    {
+        List<int> ids = new List<int>();
+        IntPtr handle = Job();
+        if (handle == IntPtr.Zero)
+        {
+            return ids;
+        }
+        // JOBOBJECT_BASIC_PROCESS_ID_LIST: two counts, then the ids (pointer-sized).
+        int length = 8 + IntPtr.Size * MaxProcesses;
+        IntPtr buffer = Marshal.AllocHGlobal(length);
+        try
+        {
+            if (!NativeMethods.QueryInformationJobObject(handle, JobObjectBasicProcessIdList, buffer, length, IntPtr.Zero))
+            {
+                return ids;
+            }
+            int count = Marshal.ReadInt32(buffer, 4);
+            for (int i = 0; i < count && i < MaxProcesses; i++)
+            {
+                ids.Add((int)Marshal.ReadIntPtr(buffer, 8 + i * IntPtr.Size).ToInt64());
+            }
+        }
+        finally
+        {
+            Marshal.FreeHGlobal(buffer);
+        }
+        return ids;
+    }
+
+    private static string PriorityName(int pid)
+    {
+        IntPtr process = NativeMethods.OpenProcess(ProcessQueryLimited, false, pid);
+        if (process == IntPtr.Zero)
+        {
+            return "normal";
+        }
+        try
+        {
+            uint c = NativeMethods.GetPriorityClass(process);
+            return c == IdleClass ? "idle" : c == BelowNormalClass ? "below" : "normal";
+        }
+        finally
+        {
+            NativeMethods.CloseHandle(process);
+        }
+    }
+
+    /// <summary>Whether pid is a process of the agents' job and not this one: the only ones this program touches.</summary>
+    private static bool Allowed(int pid)
+    {
+        return pid != Process.GetCurrentProcess().Id && JobProcessIds().Contains(pid);
+    }
+
+    private static void ReadCommands()
+    {
+        string line;
+        while ((line = Console.In.ReadLine()) != null)
+        {
+            try
+            {
+                Run(line.Trim().Split(' '));
+            }
+            catch (Exception)
+            {
+                // A bad command is ignored.
+            }
+            if (stop)
+            {
+                return;
+            }
+        }
+        // The daemon is gone: put everything back and end.
+        stop = true;
+    }
+
+    private static void Run(string[] parts)
+    {
+        if (parts.Length == 1 && parts[0] == "exit")
+        {
+            stop = true;
+            return;
+        }
+        int pid;
+        if (parts.Length < 3 || !int.TryParse(parts[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out pid) || !Allowed(pid))
+        {
+            return;
+        }
+        if (parts[0] == "priority")
+        {
+            uint cls = parts[2] == "idle" ? IdleClass : parts[2] == "below" ? BelowNormalClass : NormalClass;
+            IntPtr process = NativeMethods.OpenProcess(ProcessSetInformation, false, pid);
+            if (process != IntPtr.Zero)
+            {
+                NativeMethods.SetPriorityClass(process, cls);
+                NativeMethods.CloseHandle(process);
+            }
+        }
+        else if (parts[0] == "suspend")
+        {
+            int ms;
+            if (!int.TryParse(parts[2], NumberStyles.Integer, CultureInfo.InvariantCulture, out ms) || ms < 1)
+            {
+                return;
+            }
+            Suspend(pid, Math.Min(ms, MaxSuspendMs));
+        }
+    }
+
+    private static void Suspend(int pid, int ms)
+    {
+        lock (Gate)
+        {
+            if (Paused.ContainsKey(pid))
+            {
+                return;
+            }
+            IntPtr process = NativeMethods.OpenProcess(ProcessSuspendResume, false, pid);
+            if (process == IntPtr.Zero)
+            {
+                return;
+            }
+            try
+            {
+                NativeMethods.NtSuspendProcess(process);
+                Paused[pid] = DateTime.UtcNow.AddMilliseconds(ms);
+            }
+            finally
+            {
+                NativeMethods.CloseHandle(process);
+            }
+        }
+    }
+
+    private static void Resume(int pid)
+    {
+        IntPtr process = NativeMethods.OpenProcess(ProcessSuspendResume, false, pid);
+        if (process != IntPtr.Zero)
+        {
+            NativeMethods.NtResumeProcess(process);
+            NativeMethods.CloseHandle(process);
+        }
+    }
+
+    /// <summary>A paused process always comes back: when its time is up (checked every 100 ms).</summary>
+    private static void ResumeWhenDue()
+    {
+        while (true)
+        {
+            Thread.Sleep(100);
+            lock (Gate)
+            {
+                List<int> due = new List<int>();
+                foreach (KeyValuePair<int, DateTime> p in Paused)
+                {
+                    if (p.Value <= DateTime.UtcNow)
+                    {
+                        due.Add(p.Key);
+                    }
+                }
+                foreach (int pid in due)
+                {
+                    Resume(pid);
+                    Paused.Remove(pid);
+                }
+            }
+        }
+    }
+
+    private static void ResumeAll()
+    {
+        lock (Gate)
+        {
+            foreach (int pid in new List<int>(Paused.Keys))
+            {
+                Resume(pid);
+            }
+            Paused.Clear();
+        }
+    }
+
+    private static string Mb(ulong bytes)
+    {
+        return Math.Floor(bytes / BytesPerMb).ToString("0", CultureInfo.InvariantCulture);
+    }
+
+    private static string Json(string value)
+    {
+        StringBuilder sb = new StringBuilder("\"");
+        foreach (char c in value)
+        {
+            if (c == '"' || c == '\\')
+            {
+                sb.Append('\\').Append(c);
+            }
+            else if (c < 0x20)
+            {
+                sb.Append("\\u").Append(((int)c).ToString("x4", CultureInfo.InvariantCulture));
+            }
+            else
+            {
+                sb.Append(c);
+            }
+        }
+        return sb.Append('"').ToString();
+    }
+}

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); }
+        }
+    }
+}