windows-development-sandbox 1.10.0 → 1.11.4

package/native/csharp/HcsHost/AssemblyInfo.cs

@@ -8,7 +8,7 @@ using System.Runtime.InteropServices;
 [assembly: AssemblyCompany("windows-development-sandbox (open source)")]
 [assembly: AssemblyProduct("Windows Development Sandbox")]
 [assembly: AssemblyCopyright("MIT License, windows-development-sandbox contributors")]
-[assembly: AssemblyVersion("1.10.0.0")]
-[assembly: AssemblyFileVersion("1.10.0.0")]
-[assembly: AssemblyInformationalVersion("1.10.0")]
+[assembly: AssemblyVersion("1.11.4.0")]
+[assembly: AssemblyFileVersion("1.11.4.0")]
+[assembly: AssemblyInformationalVersion("1.11.4")]
 [assembly: ComVisible(false)]

package/native/csharp/HostTools/AssemblyInfo.cs

@@ -8,7 +8,7 @@ using System.Runtime.InteropServices;
 [assembly: AssemblyCompany("windows-development-sandbox (open source)")]
 [assembly: AssemblyProduct("Windows Development Sandbox")]
 [assembly: AssemblyCopyright("MIT License, windows-development-sandbox contributors")]
-[assembly: AssemblyVersion("1.10.0.0")]
-[assembly: AssemblyFileVersion("1.10.0.0")]
-[assembly: AssemblyInformationalVersion("1.10.0")]
+[assembly: AssemblyVersion("1.11.4.0")]
+[assembly: AssemblyFileVersion("1.11.4.0")]
+[assembly: AssemblyInformationalVersion("1.11.4")]
 [assembly: ComVisible(false)]

package/native/csharp/HostTools/MemoryStatus.cs

@@ -6,6 +6,7 @@ using System.ComponentModel;
 using System.Diagnostics;
 using System.Globalization;
 using System.Runtime.InteropServices;
+using System.Threading;
 using Microsoft.Win32;
 
 namespace AgentSandbox
@@ -108,18 +109,73 @@ namespace AgentSandbox
         {
             try
             {
-                using (PerformanceCounter counter = new PerformanceCounter("PhysicalDisk", "Current Disk Queue Length", "_Total", true))
+                // Made once and kept: creating a performance counter costs far more than reading one.
+                if (diskCounter == null && !noDiskCounter)
                 {
-                    return ",\"diskQueue\":" + Math.Round(counter.NextValue()).ToString("0", CultureInfo.InvariantCulture);
+                    diskCounter = new PerformanceCounter("PhysicalDisk", "Current Disk Queue Length", "_Total", true);
                 }
+                if (diskCounter == null)
+                {
+                    return "";
+                }
+                return ",\"diskQueue\":" + Math.Round(diskCounter.NextValue()).ToString("0", CultureInfo.InvariantCulture);
             }
             catch (Exception)
             {
                 // No performance counters on this PC: the watchdog then looks at memory and CPU only.
+                noDiskCounter = true;
+                diskCounter = null;
                 return "";
             }
         }
 
+        private static PerformanceCounter diskCounter;
+        private static bool noDiskCounter;
+        private static volatile bool inputClosed;
+
+        /// <summary>
+        /// memory-status --serve S: one JSON line every S seconds until stdin closes (the watcher keeps one of these
+        /// instead of starting a program every few seconds). Returns the exit code.
+        /// </summary>
+        public static int Serve(int seconds)
+        {
+            Thread reader = new Thread(WaitForInputToClose);
+            reader.IsBackground = true;
+            reader.Start();
+            while (!inputClosed)
+            {
+                try
+                {
+                    Console.Out.WriteLine(Json());
+                    Console.Out.Flush();
+                }
+                catch (Exception)
+                {
+                    // One reading that fails is skipped; the next one tries again.
+                }
+                for (int waited = 0; waited < seconds * 10 && !inputClosed; waited++)
+                {
+                    Thread.Sleep(100);
+                }
+            }
+            return 0;
+        }
+
+        private static void WaitForInputToClose()
+        {
+            try
+            {
+                while (Console.In.ReadLine() != null)
+                {
+                }
+            }
+            catch (Exception)
+            {
+                // A broken input counts as closed.
+            }
+            inputClosed = true;
+        }
+
         private static string Mb(ulong bytes)
         {
             return Math.Floor(bytes / BytesPerMb).ToString("0", CultureInfo.InvariantCulture);

package/native/csharp/HostTools/Program.cs

@@ -1,7 +1,8 @@
 // HostTools.exe: what the host side asks of Windows without PowerShell. Built on first use by host/native.ts (csc).
 //   keep-awake --owner-pid N    this PC stays awake until process N ends (sandbox.keepAwake)
 //   stop-events --since <iso>   the Windows events since then that can end a sandbox, as JSON (host/life)
-//   memory-status               this PC's RAM and commit (what a sandbox's memory is charged against), as JSON
+//   memory-status [--serve S]   this PC's RAM and commit (what a sandbox's memory is charged against), as JSON; with
+//                               --serve one line every S seconds until stdin closes
 //   hide-window --wait S        hides the sandbox window once it appears; prints the hidden handles as JSON
 //   show-window --handles a,b   shows those windows (else any sandbox window); prints how many
 //   user-path --add|--remove D  D first on, or off, your PATH; exit 3 when PATH would be too long
@@ -42,6 +43,11 @@ static class Program
                 Console.Out.Write(StopEventsJson(since));
                 return 0;
             case "memory-status":
+                int every;
+                if (args.Length >= 3 && args[1] == "--serve" && int.TryParse(args[2], out every) && every >= 1 && every <= 3600)
+                {
+                    return AgentSandbox.HostMemory.Serve(every);
+                }
                 try
                 {
                     Console.Out.Write(AgentSandbox.HostMemory.Json());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "windows-development-sandbox",
-  "version": "1.10.0",
+  "version": "1.11.4",
   "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/bundle-web.mjs && node scripts/schemas.mjs",
+    "build": "tsc -p tsconfig.json && tsc -p web/tsconfig.json --noEmit && 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",
@@ -55,7 +55,9 @@
     "doctor": "node dist/bin/agent-sandbox.js doctor",
     "lint": "eslint src scripts web",
     "format": "prettier --write src scripts web",
-    "format:check": "prettier --check src scripts web"
+    "format:check": "prettier --check src scripts web",
+    "web:preview": "node dist/selftest/support/web-preview.js",
+    "web:shots": "node scripts/web-shots.mjs"
   },
   "publishConfig": {
     "access": "public"
@@ -98,6 +100,7 @@
     "@mantine/hooks": "^7.17.8",
     "@mantine/modals": "^7.17.8",
     "@mantine/notifications": "^7.17.8",
+    "@mantine/spotlight": "7.17.8",
     "@tabler/icons-react": "^3.49.0",
     "@tanstack/react-query": "^5.104.3",
     "@types/lodash": "^4.17.26",
@@ -106,10 +109,14 @@
     "@types/react-dom": "^18.3.7",
     "@types/ws": "^8.18.2",
     "@xterm/addon-fit": "^0.11.0",
+    "@xterm/addon-search": "0.16.0",
+    "@xterm/addon-unicode11": "0.9.0",
+    "@xterm/addon-web-links": "0.12.0",
     "@xterm/xterm": "^6.0.0",
     "esbuild": "^0.28.2",
     "eslint": "^9.39.5",
     "mantine-form-zod-resolver": "^1.3.0",
+    "playwright-core": "1.63.0",
     "prettier": "^3.9.10",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",

package/sandbox/csharp/MemGov.cs

@@ -35,6 +35,24 @@ static class MemGov
     private const uint IdleClass = 0x00000040;
     private const uint BelowNormalClass = 0x00004000;
     private const uint NormalClass = 0x00000020;
+    // The throttle job: compilers join it from the governor's step 2; its CPU cap follows the dial.
+    private const string ThrottleJobName = "Local\\AgentSandboxBuildThrottle";
+    private const uint ProcessTerminate = 0x0001;
+    private const uint ProcessSetQuota = 0x0100;
+    private const int JobObjectCpuRateControlInformation = 15;
+    private const uint CpuRateEnable = 0x1;
+    private const uint CpuRateHardCap = 0x4;
+    private const int ProcessMemoryPriorityClass = 0;
+    private const uint MemoryPriorityLow = 2;
+    private const uint MemoryPriorityNormal = 5;
+
+    // JOBOBJECT_CPU_RATE_CONTROL_INFORMATION (CpuRate in hundredths of a percent).
+    [StructLayout(LayoutKind.Sequential)]
+    private struct CpuRateControl
+    {
+        public uint ControlFlags;
+        public uint CpuRate;
+    }
 
     // MEMORYSTATUSEX.
     [StructLayout(LayoutKind.Sequential)]
@@ -51,6 +69,23 @@ static class MemGov
         public ulong AvailExtendedVirtual;
     }
 
+    // PROCESS_MEMORY_COUNTERS_EX (PrivateUsage is the private memory Process.PrivateMemorySize64 reported).
+    [StructLayout(LayoutKind.Sequential)]
+    private struct MemoryCounters
+    {
+        public uint Size;
+        public uint PageFaultCount;
+        public UIntPtr PeakWorkingSetSize;
+        public UIntPtr WorkingSetSize;
+        public UIntPtr QuotaPeakPagedPoolUsage;
+        public UIntPtr QuotaPagedPoolUsage;
+        public UIntPtr QuotaPeakNonPagedPoolUsage;
+        public UIntPtr QuotaNonPagedPoolUsage;
+        public UIntPtr PagefileUsage;
+        public UIntPtr PeakPagefileUsage;
+        public UIntPtr PrivateUsage;
+    }
+
     private static class NativeMethods
     {
         [DllImport("kernel32.dll", SetLastError = true)]
@@ -77,6 +112,27 @@ static class MemGov
         [DllImport("kernel32.dll", SetLastError = true)]
         public static extern bool CloseHandle(IntPtr handle);
 
+        [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+        public static extern IntPtr CreateJobObjectW(IntPtr attributes, string name);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        public static extern bool AssignProcessToJobObject(IntPtr job, IntPtr process);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        public static extern bool SetInformationJobObject(IntPtr job, int infoClass, ref CpuRateControl info, int length);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        public static extern bool SetProcessInformation(IntPtr process, int infoClass, ref uint info, int length);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        public static extern bool SetProcessWorkingSetSize(IntPtr process, IntPtr minimum, IntPtr maximum);
+
+        [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+        public static extern bool QueryFullProcessImageNameW(IntPtr process, uint flags, StringBuilder name, ref uint size);
+
+        [DllImport("kernel32.dll", EntryPoint = "K32GetProcessMemoryInfo", SetLastError = true)]
+        public static extern bool GetProcessMemoryInfo(IntPtr process, ref MemoryCounters counters, uint size);
+
         [DllImport("ntdll.dll")]
         public static extern int NtSuspendProcess(IntPtr process);
 
@@ -90,6 +146,7 @@ static class MemGov
     /// <summary>The paused process ids on disk, so a memgov that is killed mid-pause is undone by the next one.</summary>
     private static readonly string HeldFile = Path.Combine(Path.GetTempPath(), "agent-sandbox-memgov-held.txt");
     private static IntPtr job = IntPtr.Zero;
+    private static IntPtr throttleJob = IntPtr.Zero;
     private static volatile bool stop;
 
     static int Main(string[] args)
@@ -113,6 +170,8 @@ static class MemGov
         }
         // A memgov that ended without resuming (killed, crashed) left its pauses in the file: undo them first.
         RecoverHeld();
+        // A memgov that ended while compilers were capped left the cap: lift it before anything else.
+        SetCpuRate(100);
         Thread commands = new Thread(ReadCommands);
         commands.IsBackground = true;
         commands.Start();
@@ -136,15 +195,28 @@ static class MemGov
             }
         }
         ResumeAll();
+        SetCpuRate(100);
         return 0;
     }
 
+    /// <summary>The self-test's own job (MEMGOV_JOB_NAME, a name in the agents' job family), or null.</summary>
+    private static string TestJobName()
+    {
+        string name = Environment.GetEnvironmentVariable("MEMGOV_JOB_NAME");
+        return !string.IsNullOrEmpty(name) && name.StartsWith(AgentJobName + "Test", StringComparison.Ordinal) ? name : null;
+    }
+
+    private static string JobName()
+    {
+        return TestJobName() ?? AgentJobName;
+    }
+
     /// <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);
+            job = NativeMethods.OpenJobObjectW(JobObjectQuery, false, JobName());
         }
         return job;
     }
@@ -164,36 +236,70 @@ static class MemGov
         sb.Append(",\"commitAvailMb\":").Append(Mb(status.AvailPageFile));
         sb.Append(",\"procs\":[");
         bool first = true;
-        int self = Process.GetCurrentProcess().Id;
+        int self = SelfId;
         foreach (int pid in JobProcessIds())
         {
             if (pid == self)
             {
                 continue;
             }
-            try
+            // Read everything first: a process that ends half way must not leave half an entry behind.
+            string entry = Entry(pid);
+            if (entry == null)
             {
-                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("\"}");
-                }
+                continue;
             }
-            catch (Exception)
+            if (!first)
             {
-                // The process ended while it was read.
+                sb.Append(',');
             }
+            first = false;
+            sb.Append(entry);
         }
         return sb.Append("]}").ToString();
     }
 
+    private static readonly int SelfId = Process.GetCurrentProcess().Id;
+
+    /// <summary>
+    /// One process's line, read through one handle: its name, private memory and priority (null when it ended). Not
+    /// System.Diagnostics.Process, which reads the whole system's process list for every process it opens: with a
+    /// build's dozens of processes every two seconds that alone kept a CPU busy.
+    /// </summary>
+    private static string Entry(int pid)
+    {
+        IntPtr process = NativeMethods.OpenProcess(ProcessQueryLimited, false, pid);
+        if (process == IntPtr.Zero)
+        {
+            return null;
+        }
+        try
+        {
+            StringBuilder path = new StringBuilder(1024);
+            uint size = (uint)path.Capacity;
+            if (!NativeMethods.QueryFullProcessImageNameW(process, 0, path, ref size))
+            {
+                return null;
+            }
+            MemoryCounters counters = new MemoryCounters();
+            counters.Size = (uint)Marshal.SizeOf(typeof(MemoryCounters));
+            if (!NativeMethods.GetProcessMemoryInfo(process, ref counters, counters.Size))
+            {
+                return null;
+            }
+            uint c = NativeMethods.GetPriorityClass(process);
+            string priority = c == IdleClass ? "idle" : c == BelowNormalClass ? "below" : "normal";
+            return "{\"pid\":" + pid.ToString(CultureInfo.InvariantCulture)
+                + ",\"name\":" + Json(Path.GetFileNameWithoutExtension(path.ToString(0, (int)size)))
+                + ",\"mb\":" + Mb(counters.PrivateUsage.ToUInt64())
+                + ",\"prio\":\"" + priority + "\"}";
+        }
+        finally
+        {
+            NativeMethods.CloseHandle(process);
+        }
+    }
+
     private static List<int> JobProcessIds()
     {
         List<int> ids = new List<int>();
@@ -224,28 +330,10 @@ static class MemGov
         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);
+        return pid != SelfId && JobProcessIds().Contains(pid);
     }
 
     private static void ReadCommands()
@@ -277,12 +365,39 @@ static class MemGov
             stop = true;
             return;
         }
+        if (parts.Length == 2 && parts[0] == "cpurate")
+        {
+            int percent;
+            if (int.TryParse(parts[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out percent))
+            {
+                SetCpuRate(percent);
+            }
+            return;
+        }
         int pid;
-        if (parts.Length < 3 || !int.TryParse(parts[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out pid) || !Allowed(pid))
+        if (parts.Length < 2 || !int.TryParse(parts[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out pid) || !Allowed(pid))
+        {
+            return;
+        }
+        if (parts[0] == "throttle")
+        {
+            Throttle(pid);
+            return;
+        }
+        if (parts[0] == "trim")
+        {
+            Trim(pid);
+            return;
+        }
+        if (parts.Length < 3)
         {
             return;
         }
-        if (parts[0] == "priority")
+        if (parts[0] == "memprio")
+        {
+            SetMemoryPriority(pid, parts[2] == "low" ? MemoryPriorityLow : MemoryPriorityNormal);
+        }
+        else if (parts[0] == "priority")
         {
             uint cls = parts[2] == "idle" ? IdleClass : parts[2] == "below" ? BelowNormalClass : NormalClass;
             IntPtr process = NativeMethods.OpenProcess(ProcessSetInformation, false, pid);
@@ -303,6 +418,93 @@ static class MemGov
         }
     }
 
+    /// <summary>The throttle job, made once. A process already in the agents' job is nested in it (Windows 8+).</summary>
+    private static IntPtr ThrottleJob()
+    {
+        if (throttleJob == IntPtr.Zero)
+        {
+            string test = TestJobName();
+            throttleJob = NativeMethods.CreateJobObjectW(IntPtr.Zero, test != null ? test + "Throttle" : ThrottleJobName);
+        }
+        return throttleJob;
+    }
+
+    /// <summary>The CPU cap of the compilers in the throttle job, percent of the sandbox; 100 or more lifts it.</summary>
+    private static void SetCpuRate(int percent)
+    {
+        IntPtr throttle = ThrottleJob();
+        if (throttle == IntPtr.Zero)
+        {
+            return;
+        }
+        CpuRateControl info = new CpuRateControl();
+        if (percent < 100)
+        {
+            info.ControlFlags = CpuRateEnable | CpuRateHardCap;
+            info.CpuRate = (uint)(Math.Max(1, percent) * 100);
+        }
+        NativeMethods.SetInformationJobObject(throttle, JobObjectCpuRateControlInformation, ref info, Marshal.SizeOf(typeof(CpuRateControl)));
+    }
+
+    private static void Throttle(int pid)
+    {
+        IntPtr throttle = ThrottleJob();
+        if (throttle == IntPtr.Zero)
+        {
+            return;
+        }
+        IntPtr process = NativeMethods.OpenProcess(ProcessSetQuota | ProcessTerminate, false, pid);
+        if (process == IntPtr.Zero)
+        {
+            return;
+        }
+        try
+        {
+            NativeMethods.AssignProcessToJobObject(throttle, process);
+        }
+        finally
+        {
+            NativeMethods.CloseHandle(process);
+        }
+    }
+
+    /// <summary>Low memory priority: Windows trims this process's pages before others' (the agents keep theirs).</summary>
+    private static void SetMemoryPriority(int pid, uint priority)
+    {
+        IntPtr process = NativeMethods.OpenProcess(ProcessSetInformation, false, pid);
+        if (process == IntPtr.Zero)
+        {
+            return;
+        }
+        try
+        {
+            uint value = priority;
+            NativeMethods.SetProcessInformation(process, ProcessMemoryPriorityClass, ref value, sizeof(uint));
+        }
+        finally
+        {
+            NativeMethods.CloseHandle(process);
+        }
+    }
+
+    /// <summary>A waiting compiler's pages go to the paging file now, so the ones that run have the RAM.</summary>
+    private static void Trim(int pid)
+    {
+        IntPtr process = NativeMethods.OpenProcess(ProcessSetQuota, false, pid);
+        if (process == IntPtr.Zero)
+        {
+            return;
+        }
+        try
+        {
+            NativeMethods.SetProcessWorkingSetSize(process, new IntPtr(-1), new IntPtr(-1));
+        }
+        finally
+        {
+            NativeMethods.CloseHandle(process);
+        }
+    }
+
     private static void Suspend(int pid, int ms)
     {
         lock (Gate)