windows-development-sandbox 1.9.0 → 1.11.3

package/sandbox/csharp/PtyHost.cs

@@ -432,7 +432,17 @@ sealed class ClientHub
                 clients.Add(client);
             }
         }
-        TakeOwnership(client);
+        // Passed through, a size change makes the program redraw for everyone (a second copy of the screen in some),
+        // so a viewer that only looks leaves the size to the one in use; it takes over when it types or is resized.
+        bool owned;
+        lock (gate)
+        {
+            owned = sizeOwner != null;
+        }
+        if (!passthrough || !owned)
+        {
+            TakeOwnership(client);
+        }
         return true;
     }
 
@@ -781,9 +791,11 @@ sealed class ClientHub
             return;
         }
         PseudoConsole current;
+        bool same;
         lock (gate)
         {
             current = console;
+            same = cols == width && rows == height;
             cols = width;
             rows = height;
         }
@@ -791,7 +803,18 @@ sealed class ClientHub
         {
             return;
         }
-        // ConPTY repaints everything on a size change; resizing by one row first forces that even for the same size.
+        if (Native.ConsoleKind.StartsWith("conpty"))
+        {
+            // Passed through: nothing repaints, the program redraws itself on every resize. Programs like Claude Code
+            // leave a second copy of their screen behind when they do, so resize only when the size really changes.
+            if (!same)
+            {
+                current.Resize(width, height);
+            }
+            return;
+        }
+        // Windows' own ConPTY repaints everything on a size change; resizing by one row first forces that even for the
+        // same size.
         current.Resize(width, (short)(height - 1));
         current.Resize(width, height);
     }
@@ -1090,6 +1113,10 @@ static class Native
     private const string AgentJobName = "Local\\AgentSandboxAgentsJob";
     private const int JobObjectExtendedLimitInformation = 9;
     private const uint JobObjectLimitJobMemory = 0x00000200;
+    private const int ErrorAlreadyExists = 183;
+    /// <summary>The backstop's headroom for "auto": this much of the commit limit, at least MinHeadroomMb.</summary>
+    private const int HeadroomPercent = 3;
+    private const long MinHeadroomMb = 1536;
     private const long BytesPerMb = 1024L * 1024L;
     private const int UseStdHandles = 0x00000100;
     private static readonly IntPtr PseudoConsoleAttribute = (IntPtr)0x00020016;
@@ -1157,6 +1184,21 @@ static class Native
         public ulong OtherTransferCount;
     }
 
+    // MEMORYSTATUSEX: ullTotalPageFile is the commit limit (RAM plus paging files).
+    [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;
+    }
+
     [StructLayout(LayoutKind.Sequential)]
     private struct JobExtendedLimit
     {
@@ -1228,6 +1270,9 @@ static class Native
         [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 GlobalMemoryStatusEx(ref MemoryStatus status);
+
         [DllImport("kernel32.dll", SetLastError = true)]
         public static extern bool SetInformationJobObject(IntPtr job, int infoClass, ref JobExtendedLimit info, int length);
 
@@ -1300,10 +1345,12 @@ static class Native
     private static bool agentJobTried;
 
     /// <summary>
-    /// The shared job of everything the agents start, with a memory limit for all of it together (PTYHOST_JOB_MB, set
-    /// by the daemon from sandbox.agentMemoryHeadroomMb): a runaway build then gets out-of-memory errors in its own
-    /// session instead of using up the whole sandbox. Zero when no limit is asked for or the job cannot be made; ptyhost
-    /// itself is never in it. The handle stays open for ptyhost's whole life (the job lives while a handle is open).
+    /// The shared job of everything the agents start (the governor reads it to slow builds down). Its only limit is a
+    /// last-resort backstop: the sandbox's commit limit minus a small headroom (PTYHOST_BACKSTOP_MB: "auto", a number
+    /// of MB, or "none"). The job's committed memory is part of the whole sandbox's, so it can reach the backstop only
+    /// when Windows inside the sandbox is about to refuse memory to everyone; then a build is refused instead of
+    /// Windows' own processes. Only the ptyhost that creates the job sets it: one that joins it never changes it.
+    /// ptyhost itself is never in it; the handle stays open for ptyhost's whole life.
     /// </summary>
     private static IntPtr AgentJob(Log log)
     {
@@ -1312,31 +1359,73 @@ static class Native
             return agentJob;
         }
         agentJobTried = true;
-        long limitMb;
-        if (!long.TryParse(Environment.GetEnvironmentVariable("PTYHOST_JOB_MB"), out limitMb) || limitMb < 512)
+        string setting = Environment.GetEnvironmentVariable("PTYHOST_BACKSTOP_MB");
+        if (string.IsNullOrEmpty(setting))
         {
             return IntPtr.Zero;
         }
-        IntPtr job = NativeMethods.CreateJobObjectW(IntPtr.Zero, AgentJobName);
+        // The self-test uses a job of its own (a name in the same family), never the agents' real one.
+        string name = Environment.GetEnvironmentVariable("PTYHOST_JOB_NAME");
+        if (string.IsNullOrEmpty(name) || !name.StartsWith(AgentJobName + "Test", StringComparison.Ordinal))
+        {
+            name = AgentJobName;
+        }
+        IntPtr job = NativeMethods.CreateJobObjectW(IntPtr.Zero, name);
+        int error = Marshal.GetLastWin32Error();
         if (job == IntPtr.Zero)
         {
-            log.Write("agent job: CreateJobObject failed (" + Marshal.GetLastWin32Error() + "); no memory limit");
+            log.Write("agent job: CreateJobObject failed (" + error + "); agents run outside it");
             return IntPtr.Zero;
         }
+        agentJob = job;
+        if (error == ErrorAlreadyExists)
+        {
+            log.Write("agent job: joined the existing one (its backstop stays as it was set)");
+            return job;
+        }
+        if (setting == "none")
+        {
+            log.Write("agent job: no backstop (sandbox.agentMemoryHeadroomMb is none)");
+            return job;
+        }
+        long commitMb;
+        long limitMb = BackstopMb(setting, out commitMb);
+        if (limitMb <= 0)
+        {
+            log.Write("agent job: the commit limit cannot be read; no backstop");
+            return job;
+        }
         JobExtendedLimit info = new JobExtendedLimit();
         info.BasicLimitInformation.LimitFlags = JobObjectLimitJobMemory;
         info.JobMemoryLimit = new UIntPtr((ulong)(limitMb * BytesPerMb));
         if (!NativeMethods.SetInformationJobObject(job, JobObjectExtendedLimitInformation, ref info, Marshal.SizeOf(typeof(JobExtendedLimit))))
         {
-            log.Write("agent job: setting the limit failed (" + Marshal.GetLastWin32Error() + "); no memory limit");
-            NativeMethods.CloseHandle(job);
-            return IntPtr.Zero;
+            log.Write("agent job: setting the backstop failed (" + Marshal.GetLastWin32Error() + "); no backstop");
+            return job;
         }
-        log.Write("agent job: everything the agent starts may use " + limitMb + " MB together");
-        agentJob = job;
+        log.Write("agent job: last-resort backstop at " + limitMb + " MB committed (the sandbox's commit limit is " + commitMb + " MB)");
         return job;
     }
 
+    /// <summary>The commit limit minus the headroom ("auto" or MB), at least half of it; 0 when it cannot be read.</summary>
+    private static long BackstopMb(string setting, out long commitMb)
+    {
+        commitMb = 0;
+        MemoryStatus status = new MemoryStatus();
+        status.Length = (uint)Marshal.SizeOf(typeof(MemoryStatus));
+        if (!NativeMethods.GlobalMemoryStatusEx(ref status))
+        {
+            return 0;
+        }
+        commitMb = (long)(status.TotalPageFile / (ulong)BytesPerMb);
+        long headroom;
+        if (setting == "auto" || !long.TryParse(setting, out headroom) || headroom < 0)
+        {
+            headroom = Math.Max(MinHeadroomMb, commitMb * HeadroomPercent / 100);
+        }
+        return Math.Max(commitMb / 2, commitMb - headroom);
+    }
+
     /// <summary>Starts `commandLine` attached to the pseudo console. Null std handles: never leak our own stdio into the child.</summary>
     public static IntPtr Spawn(string commandLine, IntPtr pseudoConsole, Log log)
     {

package/sandbox/csharp/SandboxTools/CpuCap.cs

@@ -1,12 +1,18 @@
 // Caps a process and everything it starts at a share of the PC's CPU (SandboxTools cpu-cap). Windows Sandbox has no
-// CPU setting and gets every processor; a job object with a hard CPU-rate cap holds logon.cmd and all it starts. C# 5.
+// CPU setting and gets every processor; a job object with a hard CPU-rate cap holds logon.cmd and all it starts, and
+// limits them to as many processors as the cap allows, so programs that count processors (cargo, .NET, ninja, nproc)
+// plan for what they may use, as on a PC of that size. C# 5.
 using System;
 using System.ComponentModel;
 using System.Runtime.InteropServices;
 
 public static class SandboxCpuCap
 {
+    private const int JobObjectBasicLimitInformation = 2;
     private const int JobObjectCpuRateControlInformation = 15;
+    private const uint LimitAffinity = 0x00000010;
+    /// <summary>Affinity masks hold 64 processors; with more, only the rate cap applies.</summary>
+    private const int MaxMaskProcessors = 64;
     private const uint CpuRateEnable = 0x1;
     private const uint CpuRateHardCap = 0x4;
     // What AssignProcessToJobObject needs.
@@ -23,6 +29,21 @@ public static class SandboxCpuCap
         public uint Rate;
     }
 
+    // JOBOBJECT_BASIC_LIMIT_INFORMATION.
+    [StructLayout(LayoutKind.Sequential)]
+    private struct BasicLimit
+    {
+        public long PerProcessUserTimeLimit;
+        public long PerJobUserTimeLimit;
+        public uint LimitFlags;
+        public UIntPtr MinimumWorkingSetSize;
+        public UIntPtr MaximumWorkingSetSize;
+        public uint ActiveProcessLimit;
+        public UIntPtr Affinity;
+        public uint PriorityClass;
+        public uint SchedulingClass;
+    }
+
     private const uint SnapshotProcesses = 0x2;
     private static readonly IntPtr InvalidHandle = new IntPtr(-1);
 
@@ -60,6 +81,9 @@ public static class SandboxCpuCap
         [DllImport("kernel32.dll", SetLastError = true)]
         public static extern bool SetInformationJobObject(IntPtr job, int infoClass, ref CpuRate info, int length);
 
+        [DllImport("kernel32.dll", SetLastError = true, EntryPoint = "SetInformationJobObject")]
+        public static extern bool SetBasicLimit(IntPtr job, int infoClass, ref BasicLimit info, int length);
+
         [DllImport("kernel32.dll", SetLastError = true)]
         public static extern IntPtr OpenProcess(uint access, bool inherit, int pid);
 
@@ -98,6 +122,30 @@ public static class SandboxCpuCap
         throw new InvalidOperationException("the parent process was not found.");
     }
 
+    /// <summary>
+    /// How many processors a cap of percent % allows (at least 2), the same count the daemon gives NUMBER_OF_PROCESSORS.
+    /// </summary>
+    public static int UsableProcessors(int processors, int percent)
+    {
+        return Math.Max(2, Math.Min(processors, processors * percent / 100));
+    }
+
+    /// <summary>The job's processes run on the first UsableProcessors processors; nothing changes when that is all.</summary>
+    private static void LimitProcessors(IntPtr job, int percent)
+    {
+        int processors = Environment.ProcessorCount;
+        int usable = UsableProcessors(processors, percent);
+        if (processors > MaxMaskProcessors || usable >= processors)
+        {
+            return;
+        }
+        BasicLimit limit = new BasicLimit();
+        limit.LimitFlags = LimitAffinity;
+        limit.Affinity = new UIntPtr((1UL << usable) - 1);
+        // Best effort: without it the rate cap still holds, programs only count more processors than they get.
+        NativeMethods.SetBasicLimit(job, JobObjectBasicLimitInformation, ref limit, Marshal.SizeOf(typeof(BasicLimit)));
+    }
+
     /// <summary>Puts process pid in a new job with a hard cap of percent % of all processors. Throws on failure.</summary>
     public static void Apply(int pid, int percent)
     {
@@ -113,6 +161,7 @@ public static class SandboxCpuCap
         {
             throw new Win32Exception(Marshal.GetLastWin32Error());
         }
+        LimitProcessors(job, percent);
         IntPtr process = NativeMethods.OpenProcess(ProcessSetQuota | ProcessTerminate, false, pid);
         if (process == IntPtr.Zero)
         {

package/sandbox/csharp/SandboxTools/Program.cs

@@ -61,7 +61,7 @@ static class Program
                 pid = SandboxCpuCap.ParentProcessId();
             }
             SandboxCpuCap.Apply(pid, percent);
-            Log("CPU capped at " + percent + "% of the PC (sandbox.cpuLimit).");
+            Log("CPU capped at " + percent + "% of the PC (sandbox.cpuLimit): programs see " + SandboxCpuCap.UsableProcessors(Environment.ProcessorCount, percent) + " of " + Environment.ProcessorCount + " processors.");
         }
         catch (Exception e)
         {

package/sandbox/scripts/new-shortcuts.ps1

@@ -5,7 +5,9 @@ param([Parameter(Mandatory = $true)][string]$ListFile)
 $ErrorActionPreference = 'Stop'
 
 $shell = New-Object -ComObject WScript.Shell
-foreach ($entry in @(Get-Content -LiteralPath $ListFile -Raw -Encoding UTF8 | ConvertFrom-Json)) {
+# Windows PowerShell 5.1 hands a JSON array over as ONE object: pipe it through ForEach-Object to get its elements.
+$entries = @(ConvertFrom-Json -InputObject (Get-Content -LiteralPath $ListFile -Raw -Encoding UTF8) | ForEach-Object { $_ })
+foreach ($entry in $entries) {
     New-Item -ItemType Directory -Force -Path (Split-Path -Parent $entry.link) | Out-Null
     $shortcut = $shell.CreateShortcut($entry.link)
     $shortcut.TargetPath = $entry.target

package/sandbox/scripts/repair-wmi-services.ps1

@@ -0,0 +1,26 @@
+#Requires -Version 5.1
+# Windows Sandbox keeps the WMI class Win32_TerminalService but not the provider DLL behind it, so every query of
+# Win32_Service (which includes its subclasses) fails with "Provider load failure". Installers that check a service
+# that way (OpenVPN's MSI does) then fail with 1603. This removes that one class, and only when its provider is not
+# registered: the sandbox is thrown away when it closes, and nothing else is changed. Prints what it did.
+param()
+$ErrorActionPreference = 'Stop'
+
+$className = 'Win32_TerminalService'
+$providerName = 'Win32_WIN32_TERMINALSERVICE_Prov'
+
+$class = Get-WmiObject -Namespace 'root\cimv2' -List -Class $className -ErrorAction SilentlyContinue
+if (-not $class) {
+  Write-Output 'absent'
+  exit 0
+}
+$provider = Get-WmiObject -Namespace 'root\cimv2' -Class '__Win32Provider' -Filter ("Name='" + $providerName + "'") -ErrorAction SilentlyContinue
+if ($provider -and $provider.CLSID -match '^\{[0-9A-Fa-f-]{36}\}$') {
+  $registered = Test-Path -LiteralPath ('Registry::HKEY_CLASSES_ROOT\CLSID\' + $provider.CLSID + '\InprocServer32')
+  if ($registered) {
+    Write-Output 'kept'
+    exit 0
+  }
+}
+([wmiclass]('root\cimv2:' + $className)).Delete()
+Write-Output 'removed'

package/schemas/config.schema.json

@@ -140,7 +140,7 @@
               "maximum": 9007199254740991
             }
           ],
-          "description": "Sandbox RAM in MB (>= 2048), or \"auto\": free RAM minus reserveHostMb, capped at maxMemoryMb."
+          "description": "Sandbox RAM in MB (>= 2048), or \"auto\": free RAM minus reserveHostMb, capped at maxMemoryMb. Never more than this PC can keep in RAM for it (its RAM minus the larger of reserveHostMb and 25 %, 2 GB more with vGPU): a bigger value is lowered."
         },
         "maxMemoryMb": {
           "type": "integer",
@@ -196,11 +196,11 @@
               "maximum": 9007199254740991
             }
           ],
-          "description": "Memory kept out of the agents reach inside the sandbox, in MB: everything the agents start (their builds, tests, tools) together may use at most the sandbox memory minus this; a runaway parallel build then gets out-of-memory errors in its own session instead of freezing or crashing the whole sandbox. \"auto\" = the larger of 2048 MB and 10 % of the sandbox memory; \"none\" = no limit. Yours only: a project file cannot change it."
+          "description": "The last resort that keeps the sandbox up, in MB below its commit limit (RAM plus paging file): builds are slowed down long before (sandbox.pressureResponse); only if everything the agents start together would take the sandbox to the very edge of its memory, where Windows inside it would start failing, is a build refused memory instead of Windows. \"auto\" = the larger of 1536 MB and 3 % of the commit limit; \"none\" = no backstop. Yours only: a project file cannot change it."
         },
         "pressureResponse": {
           "type": "boolean",
-          "description": "When the sandbox (or this PC) runs low on memory, slow the heaviest build programs down (lower priority) and, if that is not enough, pause the biggest compiler for a few seconds at a time, so heavy parallel builds slow down instead of closing the sandbox. Never touches the agents themselves. Yours only: a project file cannot change it."
+          "description": "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": {
           "type": "boolean",
@@ -362,7 +362,7 @@
       "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)."
+          "description": "(Alpha: not yet tried on a real PC) 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",
@@ -397,6 +397,16 @@
       },
       "additionalProperties": false
     },
+    "github": {
+      "type": "object",
+      "properties": {
+        "shareToken": {
+          "type": "boolean",
+          "description": "Give each sandbox the GitHub token you saved with `sandbox github login` (best a fine-grained token limited to some repositories and permissions), so gh and https git work there without logging in. Only with provisioning.git.access \"full\". The agent in the sandbox can read the token and use it for whatever it allows. A project file (.sandbox-config.json) cannot turn this on."
+        }
+      },
+      "additionalProperties": false
+    },
     "provisioning": {
       "type": "object",
       "properties": {
@@ -625,7 +635,7 @@
                   "maximum": 32
                 }
               ],
-              "description": "GNU host: how many programs may link at the same time in the whole sandbox (other links wait). \"auto\" = one per 8 GB of sandbox memory, 2 to 4. Several agents linking big programs at once can take Windows down."
+              "description": "GNU host: how many programs may link at the same time in the whole sandbox (other links wait). \"auto\" = one per 3 GB of sandbox memory after 6 GB, 2 to 8 (the memory governor slows links down too when memory runs short)."
             }
           },
           "additionalProperties": false
@@ -901,7 +911,7 @@
                   "const": "auto"
                 }
               ],
-              "description": "GitHub CLI (gh). Only with provisioning.git.access \"full\": gh can push and merge through the GitHub API, past a read-only git. Your PC's gh login is never copied; `gh auth login` inside persists (GH_CONFIG_DIR). \"auto\" = when the project has a .github folder."
+              "description": "GitHub CLI (gh). Only with provisioning.git.access \"full\": gh can push and merge through the GitHub API, past a read-only git. Your PC's gh login is never copied; `gh auth login` inside persists (GH_CONFIG_DIR), unless a token you saved for sandboxes is handed over (github.shareToken). \"auto\" = when the project has a .github folder."
             },
             "zstd": {
               "anyOf": [
@@ -1227,6 +1237,10 @@
         "autoHide": {
           "type": "boolean",
           "description": "Hide the Windows Sandbox window whenever this terminal attaches; it keeps running (sandbox show brings it back)."
+        },
+        "confirmCtrlC": {
+          "type": "boolean",
+          "description": "In an attached terminal and the sandbox window, a single Ctrl+C is held back (the title says so) and only a second one within 1.5 seconds reaches the agent: a Ctrl+C meant as \"copy\" no longer stops it. Esc still stops an agent."
         }
       },
       "additionalProperties": false
@@ -1236,13 +1250,17 @@
       "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)."
+          "description": "(Beta) The web UI: your sandbox sessions in a browser on this PC (http://127.0.0.1:<port>, this PC only). On: every sandbox start also starts it in the background (it keeps running until sandbox web stop or a restart of the PC). Off: only sandbox web start runs it. Open it signed in with sandbox web open."
         },
         "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."
+        },
+        "openOnLaunch": {
+          "type": "boolean",
+          "description": "(Beta) With the web UI on: open it in your browser, already signed in, every time a sandbox starts."
         }
       },
       "additionalProperties": false

package/schemas/sandbox-config.schema.json

@@ -105,7 +105,7 @@
               "maximum": 9007199254740991
             }
           ],
-          "description": "Sandbox RAM in MB (>= 2048), or \"auto\": free RAM minus reserveHostMb, capped at maxMemoryMb."
+          "description": "Sandbox RAM in MB (>= 2048), or \"auto\": free RAM minus reserveHostMb, capped at maxMemoryMb. Never more than this PC can keep in RAM for it (its RAM minus the larger of reserveHostMb and 25 %, 2 GB more with vGPU): a bigger value is lowered."
         },
         "maxMemoryMb": {
           "type": "integer",
@@ -411,7 +411,7 @@
                   "maximum": 32
                 }
               ],
-              "description": "GNU host: how many programs may link at the same time in the whole sandbox (other links wait). \"auto\" = one per 8 GB of sandbox memory, 2 to 4. Several agents linking big programs at once can take Windows down."
+              "description": "GNU host: how many programs may link at the same time in the whole sandbox (other links wait). \"auto\" = one per 3 GB of sandbox memory after 6 GB, 2 to 8 (the memory governor slows links down too when memory runs short)."
             }
           },
           "additionalProperties": false
@@ -687,7 +687,7 @@
                   "const": "auto"
                 }
               ],
-              "description": "GitHub CLI (gh). Only with provisioning.git.access \"full\": gh can push and merge through the GitHub API, past a read-only git. Your PC's gh login is never copied; `gh auth login` inside persists (GH_CONFIG_DIR). \"auto\" = when the project has a .github folder."
+              "description": "GitHub CLI (gh). Only with provisioning.git.access \"full\": gh can push and merge through the GitHub API, past a read-only git. Your PC's gh login is never copied; `gh auth login` inside persists (GH_CONFIG_DIR), unless a token you saved for sandboxes is handed over (github.shareToken). \"auto\" = when the project has a .github folder."
             },
             "zstd": {
               "anyOf": [
@@ -1011,6 +1011,10 @@
         "autoHide": {
           "type": "boolean",
           "description": "Hide the Windows Sandbox window whenever this terminal attaches; it keeps running (sandbox show brings it back)."
+        },
+        "confirmCtrlC": {
+          "type": "boolean",
+          "description": "In an attached terminal and the sandbox window, a single Ctrl+C is held back (the title says so) and only a second one within 1.5 seconds reaches the agent: a Ctrl+C meant as \"copy\" no longer stops it. Esc still stops an agent."
         }
       },
       "additionalProperties": false

package/dist/cli/commands/accounts.d.ts

@@ -1,2 +0,0 @@
-import { type Context } from './context.js';
-export declare function account(ctx: Context): Promise<number>;

package/dist/cli/commands/accounts.js

@@ -1,96 +0,0 @@
-// `account list | save | use | default | rename | remove [--agent <name>]`
-import { askChoice, askName, askRequired } from '../../core/prompt.js';
-import { fail, safeText } from '../../core/util/index.js';
-import { nextStep, printJson, table } from '../output/index.js';
-import { AccountsService } from '../services/index.js';
-function label(a) {
-    return '"' + a.name + '"' + (a.email ? ' (' + a.email + ')' : '');
-}
-function list(ctx, accounts, agent) {
-    const rows = accounts.list(agent);
-    if (printJson(ctx, rows))
-        return 0;
-    if (rows.length === 0) {
-        console.log(agent === 'claude'
-            ? "No saved accounts. Sign in inside the sandbox, then: sandbox account save <name>   (or --from-host to save this PC's login)"
-            : 'No saved ' +
-                agent +
-                ' accounts. Sign in inside the sandbox, then: sandbox account save <name> --agent ' +
-                agent);
-        return 0;
-    }
-    table([
-        ['', 'NAME', 'EMAIL', 'SAVED'],
-        ...rows.map((a) => [
-            (a.isActive ? '*' : ' ') + (a.isDefault ? 'D' : ' '),
-            a.name,
-            a.email ?? '-',
-            a.savedAt.slice(0, 16).replace('T', ' '),
-        ]),
-    ]);
-    console.log('\n* = active in the sandbox   D = default for new launches');
-    return 0;
-}
-async function use(ctx, accounts, name, agent) {
-    const used = accounts.activate(name, agent);
-    console.log('Sandbox now uses ' + label(used) + '.');
-    if (used.note)
-        console.log(safeText(used.note));
-    if (accounts.hasRunningSessions(agent) && !ctx.options.noRestart)
-        console.log(safeText(await accounts.restart(agent)) + ' with --continue; the conversation carries on under the new account.');
-    return 0;
-}
-/** The account the command is about: the one typed, or one picked from the saved accounts. */
-async function accountName(accounts, action, agent, given) {
-    if (given)
-        return given;
-    const usage = 'Usage: sandbox account ' + action + ' <name>';
-    if (action === 'save')
-        return askName('Name for this login:', usage, (v) => v.length > 0 || 'Type a name.');
-    const rows = accounts.list(agent);
-    if (!rows.length)
-        fail('No saved accounts.', 'Sign in inside the sandbox, then run: sandbox account save <name>');
-    return askChoice('Which account?', rows.map((a) => ({ name: safeText(label(a)), value: a.name })), usage);
-}
-async function remove(ctx, accounts, name, agent) {
-    const sure = ctx.options.yes ||
-        (await askRequired('Remove the saved account "' + name + '"? Its login cannot be recovered; you would sign in again.', 'Add --yes to remove it without asking.'));
-    if (!sure) {
-        console.log('Nothing removed.');
-        return 1;
-    }
-    accounts.remove(name, agent);
-    console.log('Removed account ' + name + '.');
-    return 0;
-}
-export async function account(ctx) {
-    const [action = 'list', given] = ctx.options.positionals;
-    const agent = ctx.options.accountAgent ?? 'claude';
-    const accounts = new AccountsService(ctx);
-    if (action === 'list')
-        return list(ctx, accounts, agent);
-    const name = await accountName(accounts, action, agent, given);
-    switch (action) {
-        case 'save':
-            console.log('Saved account ' + label(accounts.save(name, Boolean(ctx.options.fromHost), agent)) + '.');
-            nextStep('sandbox account use ' + name + '   (the sandbox uses it)');
-            return 0;
-        case 'use':
-            return use(ctx, accounts, name, agent);
-        case 'default':
-            accounts.setDefault(name, agent);
-            console.log('Default account: ' + name);
-            return 0;
-        case 'rename': {
-            const to = ctx.options.accountTo ??
-                (await askName('New name for "' + name + '":', 'Usage: sandbox account rename <name> --to <new-name>', (v) => v.length > 0 || 'Type a name.'));
-            accounts.rename(name, to, agent);
-            console.log('Renamed account ' + name + ' to ' + to + '.');
-            return 0;
-        }
-        case 'remove':
-            return remove(ctx, accounts, name, agent);
-        default:
-            return fail('Unknown account action "' + action + '".', 'Use one of: sandbox account list | save <name> | use <name> | default <name> | rename <name> --to <new-name> | remove <name>');
-    }
-}

package/dist/cli/commands/data/clean.d.ts

@@ -1,3 +0,0 @@
-import { type Context } from '../context.js';
-export { resolveCleanTargets, type CleanTarget } from '../../services/index.js';
-export declare function dataClean(ctx: Context): Promise<number>;

package/dist/cli/commands/data/clean.js

@@ -1,60 +0,0 @@
-// `sandbox data clean`: asks, then removes the folders the targets name (DataService does the work).
-import { humanBytes } from '../../../core/disk.js';
-import { askChoices, askRequired, askTyped } from '../../../core/prompt.js';
-import { fail } from '../../../core/util/index.js';
-import { nextStep, table, working } from '../../output/index.js';
-import { DataService } from '../../services/index.js';
-import { cleanTargetOf } from './collect.js';
-export { resolveCleanTargets } from '../../services/index.js';
-/** No target typed: a list of what can be cleaned, with sizes, to tick from (a terminal is needed). */
-async function pickTargets(service) {
-    const fix = 'Name them: sandbox data clean logs tools/go   (what exists: sandbox data)';
-    if (!process.stdin.isTTY)
-        fail('Which data should be cleaned?', fix);
-    const rows = await working('Measuring the saved data (big folders take a moment)', () => service.entries());
-    const choices = rows.flatMap((e) => {
-        const target = cleanTargetOf(e);
-        return target ? [{ name: target.padEnd(28) + humanBytes(e.bytes), value: target }] : [];
-    });
-    if (!choices.length)
-        return [];
-    return askChoices('What do you want to delete? (space ticks, enter confirms)', choices, fix);
-}
-export async function dataClean(ctx) {
-    const service = new DataService(ctx);
-    const typed = ctx.options.positionals.slice(1);
-    const inputs = typed.length ? typed : await pickTargets(service);
-    if (!inputs.length) {
-        console.log('Nothing chosen, nothing removed.');
-        return 0;
-    }
-    const { targets, present: sized, totalBytes: total } = service.plan(inputs);
-    if (!sized.length) {
-        console.log('Nothing to remove: ' + targets.map((t) => t.target).join(', ') + ' do(es) not exist.');
-        return 0;
-    }
-    table(sized.map((t) => ['  ' + t.target, humanBytes(t.bytes), t.path]));
-    for (const t of sized)
-        if (t.warning)
-            console.log('Warning: ' + t.target + ' ' + t.warning + '.');
-    const yes = Boolean(ctx.options.yes);
-    if (!yes) {
-        const ok = sized.some((t) => t.target === 'all')
-            ? await askTyped('This cannot be undone; the next sandbox starts from scratch and reinstalls everything.', 'all')
-            : await askRequired('Delete ' + sized.map((t) => t.target).join(', ') + ' (' + humanBytes(total) + ')? This cannot be undone.', 'Add --yes to delete without asking.');
-        if (!ok) {
-            console.log('Nothing removed.');
-            return 1;
-        }
-    }
-    const outcome = service.clean({ targets, present: sized, totalBytes: total });
-    if (outcome.failed.length)
-        fail('Could not remove everything: ' + outcome.failed.join('; '), 'Close programs using those folders and run the same command again.');
-    console.log('Removed ' +
-        sized.map((t) => t.target).join(', ') +
-        ' and freed ' +
-        humanBytes(outcome.freedBytes) +
-        (outcome.touchedData ? '; the next sandbox reinstalls what it needs.' : '.'));
-    nextStep('sandbox data   (see what is left)');
-    return 0;
-}

package/dist/cli/commands/data/index.d.ts

@@ -1,4 +0,0 @@
-import { type Context } from '../context.js';
-export declare function dataInfo(ctx: Context): Promise<number>;
-/** `sandbox data [info|clean] [targets...]`. */
-export declare function data(ctx: Context): number | Promise<number>;