windows-development-sandbox 1.4.3 → 1.5.0

package/dist/selftest/data.test.js

@@ -16,17 +16,29 @@ export const dataSuite = {
         const dataPath = path.join(storage, 'data', 'default');
         const resolve = (...inputs) => resolveCleanTargets(inputs, dataPath, storage).map((r) => path.relative(storage, r.path));
         const inData = (...parts) => path.join('data', 'default', ...parts);
-        t.equal(resolve('tools/go'), [inData('tools', 'go')], 'tools/<name> resolves inside the data folder');
-        t.equal(resolve('tools\\go'), [inData('tools', 'go')], 'either slash works');
-        t.equal(resolve('Tools/agents/claude'), [inData('tools', 'agents', 'claude')], 'tools/agents/<name> resolves, whatever the case');
-        t.equal(resolve('databases/postgres-18'), [inData('databases', 'postgres-18')], 'databases/<name> resolves');
-        t.equal(resolve('logs'), [inData('logs')], 'logs resolves');
-        t.equal(resolve('launches'), ['launches'], "launches resolves to the storage folder's launches");
-        t.equal(resolve('state/claude'), [inData('state', 'claude')], 'state/<agent> resolves');
-        t.equal(resolve('tools', 'tools/go', 'tools/go'), [inData('tools')], 'nested and repeated targets collapse');
-        t.equal(resolve('all', 'logs'), [inData(), 'launches'], '`all` is the data folder plus launches');
-        t.check(Boolean(resolveCleanTargets(['state/claude'], dataPath, storage)[0].warning?.includes('login')), 'cleaning state warns about the login');
-        t.check(Boolean(resolveCleanTargets(['all'], dataPath, storage)[0].warning), 'cleaning everything carries a warning');
+        t.equal([
+            resolve('tools/go'),
+            resolve('tools\\go'),
+            resolve('Tools/agents/claude'),
+            resolve('databases/postgres-18'),
+            resolve('logs'),
+            resolve('launches'),
+            resolve('state/claude'),
+            resolve('tools', 'tools/go', 'tools/go'),
+            resolve('all', 'logs'),
+        ], [
+            [inData('tools', 'go')],
+            [inData('tools', 'go')],
+            [inData('tools', 'agents', 'claude')],
+            [inData('databases', 'postgres-18')],
+            [inData('logs')],
+            ['launches'],
+            [inData('state', 'claude')],
+            [inData('tools')],
+            [inData(), 'launches'],
+        ], 'targets resolve inside the data folder (either slash, any case); launches is the storage folder; nested and repeated collapse; `all` is data plus launches');
+        t.check(Boolean(resolveCleanTargets(['state/claude'], dataPath, storage)[0].warning?.includes('login')) &&
+            Boolean(resolveCleanTargets(['all'], dataPath, storage)[0].warning), 'cleaning state warns about the login; cleaning everything carries a warning');
         const badTargets = [
             '',
             '..',
@@ -73,13 +85,11 @@ export const dataSuite = {
         catch {
             /* no junctions here */
         }
-        t.equal(sizeOf(sized), 1024, 'sizes count real files only' + (linked ? ' (a junction counts 0)' : ''));
-        t.equal([humanBytes(1536), humanBytes(0), humanBytes(3 * 1024 ** 3)], ['1.5 KB', '0 B', '3.0 GB'], 'sizes are shown in readable units');
+        t.check(sizeOf(sized) === 1024 && humanBytes(1536) === '1.5 KB' && humanBytes(3 * 1024 ** 3) === '3.0 GB', 'sizes count real files only' + (linked ? ' (a junction counts 0)' : '') + ', in readable units');
         if (linked)
             t.equal(findLinks(sized).length, 1, 'repair finds a junction planted in the data folder');
         removeTree(sized, t.temp);
-        t.check(!fs.existsSync(sized), 'a folder is removed');
-        t.check(fs.existsSync(path.join(outside, 'keep.txt')), 'removing a folder never deletes what a link inside points to');
+        t.check(!fs.existsSync(sized) && fs.existsSync(path.join(outside, 'keep.txt')), 'a folder is removed, but never what a link inside points to');
         t.section('storage cleanup');
         const store = t.at('prune');
         const aged = (p, days) => {
@@ -101,9 +111,17 @@ export const dataSuite = {
         t.dir('prune', 'data', 'd', 'tools', 'node');
         const pruned = pruneStorage(store, { keep: ['kept'] });
         const left = (p) => fs.existsSync(path.join(store, p));
-        t.equal(pruned.launches, 1, 'cleanup removes one launch folder');
-        t.equal({ old: left('launches/old'), kept: left('launches/kept'), new: left('launches/new') }, { old: false, kept: true, new: true }, 'cleanup: launch folders older than 7 days go; the running launch and recent ones stay');
-        t.equal({ oldLog: left('data/d/logs/guest-old.log'), newLog: left('data/d/logs/guest-new.log') }, { oldLog: false, newLog: true }, 'cleanup: logs older than 14 days go');
-        t.equal({ interrupted: left('data/d/tools/git.staging-ab12'), realTool: left('data/d/tools/node') }, { interrupted: false, realTool: true }, 'cleanup: interrupted downloads go; real tools stay');
+        t.equal({
+            removed: pruned.launches,
+            old: left('launches/old'),
+            kept: left('launches/kept'),
+            new: left('launches/new'),
+        }, { removed: 1, old: false, kept: true, new: true }, 'cleanup: launch folders older than 7 days go; the running launch and recent ones stay');
+        t.equal({
+            oldLog: left('data/d/logs/guest-old.log'),
+            newLog: left('data/d/logs/guest-new.log'),
+            interrupted: left('data/d/tools/git.staging-ab12'),
+            realTool: left('data/d/tools/node'),
+        }, { oldLog: false, newLog: true, interrupted: false, realTool: true }, 'cleanup: logs older than 14 days and interrupted downloads go; new logs and real tools stay');
     },
 };

package/dist/selftest/detect.test.js

@@ -11,25 +11,31 @@ export const detectSuite = {
     run: (t) => {
         t.section('databases from project files');
         const compose = file('docker-compose.yml', 'services:\n  db:\n    image: postgres:16-alpine\n  cache:\n    image: "redis:7"\n  dynamo:\n    image: amazon/dynamodb-local:latest\n');
-        t.equal(found([compose]), ['postgres', 'redis', 'dynamodb'], 'compose services: postgres, redis and DynamoDB Local images');
-        t.equal(found([file('package.json', '{"dependencies":{"pg":"^8.11.0","ioredis":"5","@aws-sdk/client-dynamodb":"3"}}')]), ['postgres', 'redis', 'dynamodb'], 'package.json: pg, ioredis, @aws-sdk/client-dynamodb');
-        t.equal(found([file('package.json', '{"dependencies":{"pgadmin-ui":"1","mysql-logger":"2","express":"4"}}')]), [], 'package.json: names that only contain a driver name do not count');
-        t.equal(found([file('prisma/schema.prisma', 'datasource db {\n  provider = "mysql"\n  url = env("DATABASE_URL")\n}')]), ['mysql'], 'Prisma: the datasource provider decides');
-        t.equal(found([file('requirements.txt', 'django==5.0\npsycopg2-binary==2.9\npymongo>=4\n')]), ['postgres', 'mongodb'], 'Python requirements: psycopg2 and pymongo');
-        t.equal(found([
-            file('Api/Api.csproj', '<PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="8.0.0" />'),
-        ]), ['sqlserver'], '.NET: EF Core SQL Server provider');
-        t.equal(found([
-            file('.env.example', 'DATABASE_URL=postgresql://user:pass@localhost:5432/app\nMONGO_URL=mongodb+srv://cluster/x\n'),
-        ]), ['postgres', 'mongodb'], '.env templates: connection-string schemes');
-        t.equal(found([file('template.yaml', 'Resources:\n  Table:\n    Type: AWS::DynamoDB::Table\n')]), ['dynamodb'], 'SAM/CloudFormation: a DynamoDB table resource');
-        t.equal(found([
-            file('go.mod', 'require (\n\tgithub.com/jackc/pgx/v5 v5.5.0\n\tgithub.com/aws/aws-sdk-go-v2/service/dynamodb v1.0.0\n)'),
-        ]), ['postgres', 'dynamodb'], 'go.mod: pgx and the DynamoDB SDK');
+        t.equal([
+            found([compose]),
+            found([file('package.json', '{"dependencies":{"pg":"^8.11.0","ioredis":"5","@aws-sdk/client-dynamodb":"3"}}')]),
+            found([file('package.json', '{"dependencies":{"pgadmin-ui":"1","mysql-logger":"2","express":"4"}}')]),
+            found([file('prisma/schema.prisma', 'datasource db {\n  provider = "mysql"\n  url = env("X")\n}')]),
+            found([file('requirements.txt', 'django==5.0\npsycopg2-binary==2.9\npymongo>=4\n')]),
+            found([file('Api/Api.csproj', '<PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" />')]),
+            found([file('.env.example', 'DATABASE_URL=postgresql://user:pass@localhost:5432/app\nM=mongodb+srv://c/x\n')]),
+            found([file('template.yaml', 'Resources:\n  Table:\n    Type: AWS::DynamoDB::Table\n')]),
+        ], [
+            ['postgres', 'redis', 'dynamodb'],
+            ['postgres', 'redis', 'dynamodb'],
+            [],
+            ['mysql'],
+            ['postgres', 'mongodb'],
+            ['sqlserver'],
+            ['postgres', 'mongodb'],
+            ['dynamodb'],
+        ], 'databases come from compose images, package.json, Prisma, requirements, .NET, .env templates and SAM; names that only contain a driver name do not count');
         const knex = [file('package.json', '{"dependencies":{"knex":"3"}}')];
-        t.equal(found(knex), [], 'an ORM that names no database uses nothing when this PC has none');
-        t.equal(found(knex, ['mysql']), ['mysql'], 'an ORM that names no database uses the one installed on this PC');
-        t.equal(databasesFromServices(['postgresql-x64-16', 'MySQL80', 'MSSQL$SQLEXPRESS', 'Spooler', 'Redis']), ['postgres', 'mysql', 'sqlserver', 'redis'], 'database services on this PC are recognised by name');
+        t.equal([
+            found(knex),
+            found(knex, ['mysql']),
+            databasesFromServices(['postgresql-x64-16', 'MySQL80', 'MSSQL$SQLEXPRESS', 'Spooler', 'Redis']),
+        ], [[], ['mysql'], ['postgres', 'mysql', 'sqlserver', 'redis']], 'an ORM that names no database uses the one installed on this PC (or none); database services are recognised by name');
         // Hostile workspace files (a cloned repository is untrusted): detection must stay linear.
         const hostile = [
             file('.env', 'Server=a;Database=a;'.repeat(12000)),
@@ -47,25 +53,34 @@ export const detectSuite = {
             redis: { ...DEFAULTS.databases.redis, enabled: false },
         }, 'unused', { files: [compose], host: [] });
         t.equal(plan.map((p) => p.database + '@' + p.version + ':' + p.port), ['postgres@16:5432', 'mongodb@latest:27017', 'dynamodb@latest:8000'], 'plan: "auto" from the project (compose pins Postgres 16), true always, false never');
-        t.equal(plan.find((p) => p.database === 'dynamodb')?.adminPort, 8001, 'plan: DynamoDB gets its admin UI port');
         const catalog = databaseCatalog({
             ...DEFAULTS.databases,
             postgres: { ...DEFAULTS.databases.postgres, enabled: false, port: 6543 },
         });
-        t.equal(catalog.map((p) => p.database), ['postgres', 'mysql', 'mongodb', 'redis', 'dynamodb'], 'sbx-db catalog: every database that can run (not SQL Server), even ones off at boot');
-        t.equal(catalog[0].port, 6543, 'sbx-db catalog: configured ports are used');
+        t.check(catalog.map((p) => p.database).join() === 'postgres,mysql,mongodb,redis,dynamodb' && catalog[0].port === 6543, 'sbx-db catalog: every database that can run (not SQL Server), even ones off at boot, with configured ports');
         t.section('toolchains from project files');
         const tc = DEFAULTS.toolchains;
         const goProject = decideToolchains(tc, ['README.md', 'go.mod', 'api/main.go'], ['python', 'rust']);
-        t.equal({ go: goProject.go.on, reason: goProject.go.reason }, { go: true, reason: 'go.mod' }, 'toolchains: a Go project gets Go (and says why)');
-        t.equal({ python: goProject.python.on, rust: goProject.rust.on, dotnet: goProject.dotnet.on, java: goProject.java.on }, { python: false, rust: false, dotnet: false, java: false }, 'toolchains: a Go project gets nothing it does not use, whatever this PC has');
+        t.equal([goProject.go, [goProject.python.on, goProject.rust.on, goProject.dotnet.on, goProject.java.on]], [{ on: true, reason: 'go.mod' }, [false, false, false, false]], 'a Go project gets Go (and says why) and nothing it does not use, whatever this PC has');
         const fresh = decideToolchains(tc, ['notes.txt'], ['python', 'dotnet']);
-        t.equal({ python: fresh.python.on, dotnet: fresh.dotnet.on, go: fresh.go.on }, { python: true, dotnet: true, go: false }, 'toolchains: a folder that is no project yet gets the languages this PC has');
-        t.includes(fresh.python.reason, 'this PC', 'toolchains: the reason names this PC');
+        t.check(fresh.python.on && fresh.dotnet.on && !fresh.go.on && fresh.python.reason.includes('this PC'), 'a folder that is no project yet gets the languages this PC has, and the reason names this PC');
         const rusty = decideToolchains({ ...tc, python: { ...tc.python, enabled: true } }, ['Cargo.toml'], []);
-        t.equal({ rust: rusty.rust.on, cpp: rusty.cpp.on }, { rust: true, cpp: true }, 'toolchains: Rust brings its C/C++ linker');
-        t.equal({ python: rusty.python.on, reason: rusty.python.reason }, { python: true, reason: 'enabled in config' }, 'toolchains: true in config always wins');
+        t.check(rusty.rust.on && rusty.cpp.on && rusty.python.on && rusty.python.reason === 'enabled in config', 'Rust brings its C/C++ linker; true in config always wins');
         const resolved = resolveToolchains(tc, goProject);
-        t.equal({ go: resolved.go.enabled, python: resolved.python.enabled }, { go: true, python: false }, 'the sandbox gets plain decisions instead of "auto"');
+        t.check(resolved.go.enabled === true && resolved.python.enabled === false, 'the sandbox gets plain decisions instead of "auto"');
+        t.section('optional tools: Bun, uv, VS Code');
+        const uvTools = decideToolchains({ ...tc, python: { ...tc.python, tools: ['ruff'] } }, ['main.py'], []);
+        const memHints = decideToolchains(tc, ['README.md'], [], { bun: 'claude-mem needs it', uv: 'claude-mem needs it' });
+        t.check(decideToolchains(tc, ['bun.lock', 'package.json'], []).bun.on &&
+            !decideToolchains(tc, ['package.json'], []).bun.on &&
+            decideToolchains(tc, ['uv.lock'], []).uv.on &&
+            !decideToolchains(tc, ['README.md'], []).uv.on &&
+            decideToolchains(tc, ['README.md'], ['vscode']).vscode.on &&
+            !decideToolchains(tc, ['README.md'], []).vscode.on, 'bun, uv and VS Code: "auto" follows bun.lock, uv.lock and whether this PC has VS Code');
+        t.equal([uvTools.uv, memHints.bun, memHints.uv], [
+            { on: true, reason: 'needed for toolchains.python.tools' },
+            { on: true, reason: 'claude-mem needs it' },
+            { on: true, reason: 'claude-mem needs it' },
+        ], 'uv is on for Python tools and Bun/uv for claude-mem, and they say why');
     },
 };

package/dist/selftest/generate.test.js

@@ -11,13 +11,13 @@ export const generateSuite = {
         t.section('the .wsb file');
         const gen = await f.launch({}, { args: ['--version'], probe: { ...f.probe, gitDir: f.shared, nvmDir: f.workB } });
         const wsb = fs.readFileSync(gen.wsbPath, 'utf8');
-        t.includes(wsb, '<MemoryInMB>8192</MemoryInMB>', 'wsb: the configured memory');
-        t.includes(wsb, '<SandboxFolder>C:\\Workspace\\work-a</SandboxFolder>', 'wsb: the workspace is mapped to its guest folder');
-        t.includes(wsb, 'C:\\HostTools\\git', "wsb: this PC's git is mapped");
-        t.includes(wsb, 'C:\\HostTools\\nvm', "wsb: this PC's nvm is mapped");
-        t.excludes(wsb, 'Missing', 'wsb: an optional mapping whose folder is missing is skipped');
-        t.includes(wsb, 'logon.cmd</Command>', 'wsb: the logon command');
-        t.includes(wsb, '<vGPU>Disable</vGPU>', 'wsb: vGPU is off');
+        t.check(wsb.includes('<MemoryInMB>8192</MemoryInMB>') &&
+            wsb.includes('<SandboxFolder>C:\\Workspace\\work-a</SandboxFolder>') &&
+            wsb.includes('C:\\HostTools\\git') &&
+            wsb.includes('C:\\HostTools\\nvm') &&
+            !wsb.includes('Missing') &&
+            wsb.includes('logon.cmd</Command>') &&
+            wsb.includes('<vGPU>Disable</vGPU>'), "wsb: the configured memory, the workspace at its guest folder, this PC's git and nvm, the logon command, vGPU off; a missing optional folder is skipped", wsb);
         t.includes(buildWsb(f.baseConfig, 4096, [{ host: 'C:\\a&b', guest: 'C:\\X', readOnly: true }]), 'C:\\a&amp;b', 'wsb values are XML-escaped');
         t.section('the launch folder');
         const expectedFiles = [
@@ -26,27 +26,26 @@ export const generateSuite = {
             'runtime/daemon.js',
             'runtime/view.js',
             'runtime/gitguard.js',
-            'sandbox/bootstrap.ps1',
-            'sandbox/logon.cmd',
-            'sandbox/trust.cmd',
-            'sandbox/ptyhost.cs',
-            'sandbox/gitshim.cs',
-            'sandbox/cpucap.ps1',
-            'sandbox/cpucap.cs',
-            'sandbox/pagefile.ps1',
-            'sandbox/pagefile.cs',
-            'sandbox/memlog.ps1',
-            'sandbox/linkgate.cs',
+            'sandbox/boot/bootstrap.ps1',
+            'sandbox/boot/logon.cmd',
+            'sandbox/boot/trust.cmd',
+            'sandbox/csharp/PtyHost.cs',
+            'sandbox/csharp/GitShim.cs',
+            'sandbox/csharp/SandboxTools/Program.cs',
+            'sandbox/csharp/SandboxTools/CpuCap.cs',
+            'sandbox/csharp/SandboxTools/PageFile.cs',
+            'sandbox/csharp/SandboxTools/MemoryLog.cs',
+            'sandbox/csharp/LinkGate.cs',
         ];
         const missing = expectedFiles.filter((file) => !fs.existsSync(path.join(gen.launchPath, file)));
-        t.equal(missing, [], 'the launch folder has the runtime, the C# sources and the boot scripts');
-        t.equal(fs.readdirSync(path.join(gen.launchPath, 'runtime')).length, 6, 'the runtime is 6 self-contained files');
-        const logon = fs.readFileSync(path.join(gen.launchPath, 'sandbox', 'logon.cmd'), 'utf8');
-        t.check(logon.indexOf('trust.cmd') < logon.indexOf('wt.exe'), 'logon.cmd applies the sandbox trust settings before opening Windows Terminal');
-        t.includes(logon, 'tools\\terminal\\wt.exe', 'logon.cmd opens Windows Terminal from the tools folder');
-        t.includes(logon, '-NoExit', 'logon.cmd falls back to a PowerShell window');
-        t.check(logon.indexOf('env.cmd') > 0 && logon.indexOf('env.cmd') < logon.indexOf('wt.exe'), 'logon.cmd sets AGENT_WORKSPACE (env.cmd) before Windows Terminal starts, so new tabs can open in it');
-        t.includes(fs.readFileSync(path.join(gen.launchPath, 'env.cmd'), 'utf8'), 'AGENT_WORKSPACE=', 'env.cmd names the workspace');
+        t.check(missing.length === 0 && fs.readdirSync(path.join(gen.launchPath, 'runtime')).length === 6, 'the launch folder has the runtime (6 self-contained files), the C# sources and the boot scripts', missing.join(', '));
+        const logon = fs.readFileSync(path.join(gen.launchPath, 'sandbox', 'boot', 'logon.cmd'), 'utf8');
+        t.check(logon.indexOf('trust.cmd') < logon.indexOf('wt.exe') &&
+            logon.includes('tools\\terminal\\wt.exe') &&
+            logon.includes('-NoExit') &&
+            logon.indexOf('env.cmd') > 0 &&
+            logon.indexOf('env.cmd') < logon.indexOf('wt.exe') &&
+            fs.readFileSync(path.join(gen.launchPath, 'env.cmd'), 'utf8').includes('AGENT_WORKSPACE='), 'logon.cmd applies the trust settings and sets AGENT_WORKSPACE (env.cmd) before Windows Terminal, falling back to a PowerShell window');
         t.equal(logonEnv('C:\\Workspace\\100%\\x'), '@set "AGENT_WORKSPACE=C:\\Workspace\\100%%\\x"\r\n', 'a % in the workspace path is escaped for cmd');
         t.section('session.json');
         const session = f.readJson(gen.sessionPath);
@@ -59,6 +58,9 @@ export const generateSuite = {
             nvmFromHost: Boolean(session.hostTools.nvm),
             nodeSpec: session.versions.node.spec,
             gitAccess: session.provisioning.git.access,
+            plainNodeVersion: /^\d+\.\d+\.\d+$/.test(session.hostTools.nodeVersion ?? ''),
+            cpuLimitPercent: session.cpuLimitPercent,
+            pageFileMb: session.pageFileMb,
         }, {
             launchId: true,
             workspace: 'C:\\Workspace\\work-a',
@@ -68,25 +70,25 @@ export const generateSuite = {
             nvmFromHost: true,
             nodeSpec: '22.3.0',
             gitAccess: 'full',
-        }, 'session.json carries the id, paths, agent arguments, host tools, versions and git access');
-        t.matches(session.hostTools.nodeVersion ?? '', /^\d+\.\d+\.\d+$/, 'session.json: the host Node version is a plain version');
-        t.equal(session.cpuLimitPercent, 80, 'session.json carries the CPU cap for cpucap.ps1 (default 80 %)');
-        t.equal(session.pageFileMb, 16384, 'session.json carries the paging file limit for pagefile.ps1 (default 16 GB)');
+            plainNodeVersion: true,
+            cpuLimitPercent: 80,
+            pageFileMb: 16384,
+        }, 'session.json carries the id, paths, agent arguments, host tools, versions, git access and the CPU (80 %) and paging file (16 GB) limits');
         t.check(!LocalOverridesSchema.safeParse({ sandbox: { cpuLimit: 'none' } }).success, "a project's .sandbox-config.json cannot lift your CPU cap (sandbox.cpuLimit is yours only)");
         t.section('what is copied from this PC');
         const staged = path.join(gen.launchPath, 'claude-profile');
         const stagedMissing = ['settings.json', 'CLAUDE.md', '.claude.json', 'plugins'].filter((name) => !fs.existsSync(path.join(staged, name)));
-        t.equal(stagedMissing, [], 'Claude settings, instructions, global state and plugins are staged');
-        t.check(!fs.existsSync(path.join(staged, '.credentials.json')), 'the Claude login is not staged');
+        t.check(stagedMissing.length === 0 && !fs.existsSync(path.join(staged, '.credentials.json')), 'Claude settings, instructions, global state and plugins are staged; the Claude login is not', stagedMissing.join(', '));
         const gitconfig = '[user]\n\tname = Josh\n\temail = "j@x.io"\n[credential]\n\thelper = store\n[url "https://TOKEN@github.com/"]\n\tinsteadOf = https://github.com/\n';
-        t.equal(gitIdentity(gitconfig), '[user]\n\tname = Josh\n\temail = j@x.io\n', 'only name/email from ~/.gitconfig reach the sandbox (no credential helpers or token URLs)');
-        t.equal(gitIdentity('[core]\n\tname = x\n'), '', 'a name outside [user] is not an identity');
+        t.equal([gitIdentity(gitconfig), gitIdentity('[core]\n\tname = x\n')], ['[user]\n\tname = Josh\n\temail = j@x.io\n', ''], 'only name/email from ~/.gitconfig reach the sandbox (no credential helpers or token URLs; a name outside [user] is not an identity)');
         const auto = { ...f.baseConfig.sandbox, memoryMb: 'auto' };
         const MB = 1048576;
         const pcRam = 64 * 1024 * MB;
-        t.equal(resolveMemoryMb(auto, 40000 * MB, pcRam), 31744, "memory 'auto' follows free RAM minus the reserve");
+        t.equal([
+            resolveMemoryMb(auto, 40000 * MB, pcRam),
+            resolveMemoryMb({ ...auto, maxMemoryPercent: 80 }, 30000 * MB, 32 * 1024 * MB),
+            resolveMemoryMb({ ...auto, maxMemoryPercent: 50 }, 60000 * MB, pcRam),
+        ], [31744, 21504, 32768], "memory 'auto' follows free RAM minus the reserve and never takes more than maxMemoryPercent of the PC's RAM");
         await t.throws(() => resolveMemoryMb(auto, 9000 * MB, pcRam), 'Not enough free RAM', "memory 'auto' refuses when too little RAM is free");
-        t.equal(resolveMemoryMb({ ...auto, maxMemoryPercent: 80 }, 30000 * MB, 32 * 1024 * MB), 21504, "memory 'auto' never takes more than maxMemoryPercent of the PC's RAM");
-        t.equal(resolveMemoryMb({ ...auto, maxMemoryPercent: 50 }, 60000 * MB, pcRam), 32768, "memory 'auto' is capped at half the PC's RAM with maxMemoryPercent 50 (free RAM and maxMemoryMb still apply)");
     },
 };

package/dist/selftest/git-access.test.js

@@ -1,4 +1,5 @@
-// Git access modes ("full", "readonly", "none"): which git commands the guard allows and the matching Claude deny rules.
+// Git access modes ("full", "readonly", "none"): which git commands the guard allows and the matching Claude deny
+// rules.
 import { gitDecision } from '../guest/git/decision.js';
 import { gitDenyRules } from '../guest/setup/git-rules.js';
 export const gitAccessSuite = {

package/dist/selftest/guest-boot.test.js

@@ -7,15 +7,19 @@ export const guestBootSuite = {
     name: 'guest-boot',
     title: 'guest boot in dry-run mode (provisioning, Claude state, git policy)',
     run: async (t, f) => {
-        const gen = await f.launch({}, { args: ['--version'], probe: { ...f.probe, gitDir: f.shared, nvmDir: f.workB } });
+        // Bun and uv are "auto" by default; pinned on here so their steps are exercised.
+        const pinned = f.makeConfig();
+        pinned.toolchains.bun.enabled = true;
+        pinned.toolchains.uv.enabled = true;
+        const gen = await f.launch({}, { config: pinned, args: ['--version'], probe: { ...f.probe, gitDir: f.shared, nvmDir: f.workB } });
         t.section('first boot');
         const data1 = t.at('data1');
         const boot = await f.runGuest(gen.launchPath, data1, f.workA, { AGENT_TEST_EXEMPT: '172.28.0.1' });
-        t.check(boot.status === 0, 'the guest boots and exits cleanly', 'exit code ' + boot.status + '\n' + boot.out);
-        t.includes(boot.out, 'would run:', 'the guest starts the agent...');
-        t.includes(boot.out, '--version', '... with its arguments...');
-        t.includes(boot.out, 'cwd=' + f.workA, '... in the workspace');
-        for (const step of [
+        t.check(boot.status === 0 &&
+            boot.out.includes('would run:') &&
+            boot.out.includes('--version') &&
+            boot.out.includes('cwd=' + f.workA), 'the guest boots, exits cleanly and starts the agent with its arguments in the workspace', 'exit code ' + boot.status + '\n' + boot.out);
+        const steps = [
             'would provision nvm and Node 22.3.0 (from this PC)',
             'would provision Python 3',
             'would provision MinGW-w64 GCC',
@@ -24,28 +28,27 @@ export const guestBootSuite = {
             'would provision bun',
             'would provision uv',
             'would provision Git for Windows from this PC',
-        ]) {
-            t.includes(boot.out, step, 'the guest provisions: ' + step);
-        }
-        t.includes(boot.out, 'AgentSandbox-Block-Private', 'the firewall plan blocks the LAN...');
-        t.includes(boot.out, 'remoteport=1-52,54-65535', '... but keeps DNS to the gateway');
-        t.equal(readJsonFile(path.join(data1, 'run', 'sandbox.json'))?.phase, 'ready', 'the guest reports "ready" in run/sandbox.json');
+        ];
+        t.equal(steps.filter((s) => !boot.out.includes(s)), [], 'the guest provisions every enabled toolchain');
+        t.check(boot.out.includes('AgentSandbox-Block-Private') &&
+            boot.out.includes('remoteport=1-52,54-65535') &&
+            readJsonFile(path.join(data1, 'run', 'sandbox.json'))?.phase === 'ready', 'the firewall plan blocks the LAN but keeps DNS to the gateway; the guest reports "ready"');
         t.section('Claude state copied in');
         const claudeState = path.join(data1, 'state', 'claude');
-        t.includes(fs.readFileSync(path.join(claudeState, 'settings.json'), 'utf8'), 'dark', "the guest applied this PC's Claude settings");
-        t.check(fs.existsSync(path.join(claudeState, 'commands', 'review.md')), 'custom commands are copied');
-        t.check(!fs.existsSync(path.join(claudeState, '.credentials.json')), 'the login is not copied');
         const plugins = fs.readFileSync(path.join(claudeState, 'plugins', 'installed_plugins.json'), 'utf8');
-        t.includes(plugins, JSON.stringify(claudeState).slice(1, -1), 'plugin manifests are re-pointed at the sandbox Claude folder');
+        t.check(fs.readFileSync(path.join(claudeState, 'settings.json'), 'utf8').includes('dark') &&
+            fs.existsSync(path.join(claudeState, 'commands', 'review.md')) &&
+            !fs.existsSync(path.join(claudeState, '.credentials.json')) &&
+            plugins.includes(JSON.stringify(claudeState).slice(1, -1)), "this PC's Claude settings and commands are copied (not the login); plugin manifests point at the sandbox folder");
         const guestState = f.readJson(path.join(claudeState, '.claude.json'));
-        t.equal(guestState.mcpServers?.github?.command, 'npx', 'MCP servers from this PC are in the sandbox');
         const manifest = fs.readFileSync(f.at('managed', 'CLAUDE.md'), 'utf8');
-        t.includes(manifest, 'DISPOSABLE Windows Sandbox', 'the agent manifest goes to the managed CLAUDE.md...');
-        t.includes(manifest, f.workA, '... naming the workspace');
-        t.check(manifest.split('\n').length < 16, 'the managed manifest stays tiny', manifest.split('\n').length + ' lines');
-        t.equal(fs.readFileSync(path.join(claudeState, 'CLAUDE.md'), 'utf8'), 'my rules', "the user's own CLAUDE.md is untouched");
-        t.check(fs.existsSync(path.join(data1, 'SANDBOX.md')), 'SANDBOX.md is written to the data folder');
-        t.check(!fs.existsSync(f.at('managed', 'managed-settings.json')), 'git access full: no managed deny rules');
+        t.check(guestState.mcpServers?.github?.command === 'npx' &&
+            manifest.includes('DISPOSABLE Windows Sandbox') &&
+            manifest.includes(f.workA) &&
+            manifest.split('\n').length < 16 &&
+            fs.readFileSync(path.join(claudeState, 'CLAUDE.md'), 'utf8') === 'my rules' &&
+            fs.existsSync(path.join(data1, 'SANDBOX.md')) &&
+            !fs.existsSync(f.at('managed', 'managed-settings.json')), "MCP servers come along; the short managed manifest names the workspace; the user's own CLAUDE.md is untouched; git access full has no deny rules");
         t.section('second boot');
         // The host changed its MCP servers: the sandbox keeps its own login and .claude.json but gets the new servers.
         fs.writeFileSync(path.join(claudeState, '.claude.json'), JSON.stringify({
@@ -59,36 +62,35 @@ export const guestBootSuite = {
         });
         await f.runGuest(gen.launchPath, data1, f.workA);
         const merged = f.readJson(path.join(claudeState, '.claude.json'));
-        t.equal(merged.oauthAccount.emailAddress, 'sandbox@x', 'MCP re-sync leaves the sandbox login alone');
-        t.equal(merged.mcpServers.github.command, 'npx2', 'MCP re-sync updates a server changed on this PC');
-        t.equal(merged.mcpServers.local.command, 'x', 'MCP re-sync keeps a server added in the sandbox');
         const projectServers = Object.values(merged.projects);
-        t.check(projectServers.some((p) => p.mcpServers?.db), 'MCP re-sync brings in project-scope servers', JSON.stringify(merged.projects));
+        t.check(merged.oauthAccount.emailAddress === 'sandbox@x' &&
+            merged.mcpServers.github.command === 'npx2' &&
+            merged.mcpServers.local.command === 'x' &&
+            projectServers.some((p) => p.mcpServers?.db), 'MCP re-sync leaves the sandbox login alone, updates changed servers, keeps ones added in the sandbox and brings in project servers', JSON.stringify(merged));
         t.section('other modes');
         const readonlyConfig = f.makeConfig();
         readonlyConfig.provisioning.git.access = 'readonly';
         const genRo = await f.launch({}, { config: readonlyConfig });
         await f.runGuest(genRo.launchPath, t.at('data-ro'), f.workA, { AGENT_MANAGED_DIR: t.at('managed-ro') });
         const deny = f.readJson(t.at('managed-ro', 'managed-settings.json')).permissions.deny;
-        t.check(deny.includes('Bash(git commit:*)') && deny.includes('PowerShell(git push:*)'), 'git readonly: Claude managed settings deny writing git commands', JSON.stringify(deny));
-        t.check(deny.includes('Edit(**/.git/**)'), 'git readonly: .git edits are denied');
-        t.check(!deny.includes('Bash(git status:*)'), 'git readonly: reading git commands stay allowed');
+        t.check(deny.includes('Bash(git commit:*)') &&
+            deny.includes('PowerShell(git push:*)') &&
+            deny.includes('Edit(**/.git/**)') &&
+            !deny.includes('Bash(git status:*)'), 'git readonly: Claude managed settings deny writing git commands and .git edits, reading stays allowed', JSON.stringify(deny));
         f.writeLocal(f.workB, { scripts: ['./setup.mjs'] });
         const genHook = await f.launch({ cwd: f.workB, harness: 'claude', trustConfig: true });
         const hook = await f.runGuest(genHook.launchPath, t.at('data-hook'), f.workB);
-        t.check(hook.status === 0, 'a project with "scripts" boots', hook.out);
-        t.equal(fs.readFileSync(t.at('data-hook', 'hook-ran.txt'), 'utf8'), f.workB, 'local "scripts" run inside the sandbox with the workspace set');
+        t.check(hook.status === 0 && fs.readFileSync(t.at('data-hook', 'hook-ran.txt'), 'utf8') === f.workB, 'local "scripts" run inside the sandbox with the workspace set', hook.out);
         const genInstall = await f.launch({}, { config: f.makeConfig(false), probe: { ...f.probe, nodeDir: null, harnessExe: null } });
         const install = await f.runGuest(genInstall.launchPath, t.at('data3'), f.workA, {
             AGENT_HOST_TOOLS_DIR: t.at('empty'),
         });
-        t.check(install.status === 0, 'install mode boots', install.out);
-        t.includes(install.out, 'npm-cli.js', 'install mode: npm is used...');
-        t.includes(install.out, '@anthropic-ai/claude-code', '... to install the agent');
-        t.excludes(fs.readFileSync(genInstall.wsbPath, 'utf8'), 'HostTools', 'install mode: nothing is mapped from this PC');
+        t.check(install.status === 0 &&
+            install.out.includes('npm-cli.js') &&
+            install.out.includes('@anthropic-ai/claude-code') &&
+            !fs.readFileSync(genInstall.wsbPath, 'utf8').includes('HostTools'), 'install mode: npm installs the agent and nothing is mapped from this PC', install.out);
         const genNoAgent = await f.launch({ noAgent: true });
         const noAgent = await f.runGuest(genNoAgent.launchPath, t.at('data5'), f.workA);
-        t.check(noAgent.status === 0, '--no-agent boots', noAgent.out);
-        t.includes(noAgent.out, 'no agent requested', '--no-agent provisions without an agent');
+        t.check(noAgent.status === 0 && noAgent.out.includes('no agent requested'), '--no-agent provisions without an agent', noAgent.out);
     },
 };

package/dist/selftest/host-sim.test.js

@@ -11,6 +11,9 @@ const SANDBOX_ONLY_VARS = [
     'CLAUDE_CONFIG_DIR',
     'CODEX_HOME',
     'GEMINI_CLI_HOME',
+    'COPILOT_HOME',
+    'CRUSH_GLOBAL_CONFIG',
+    'CRUSH_GLOBAL_DATA',
     'AGENT_WORKSPACE',
     'AGENT_DATA',
     'AGENT_TOOLS',

package/dist/selftest/hostile-input.test.js

@@ -35,6 +35,8 @@ export const hostileInputSuite = {
         t.check(removeRefusal('\\\\?\\C:\\Users\\someone\\x', '\\\\?\\C:\\Users\\someone') !== null, 'a delete is refused for \\\\?\\ paths');
         t.check(removeRefusal('C:\\Windows\\Temp\\x', 'C:\\Windows\\Temp') !== null, 'a delete is refused inside Windows');
         t.check(removeRefusal('C:\\Program Files\\x\\y', 'C:\\Program Files\\x') !== null, 'a delete is refused inside Program Files');
+        t.check(removeRefusal('C:\\Program Files\\App\\versions\\1.0.0', 'C:\\Program Files\\App\\versions') === null &&
+            removeRefusal('C:\\Program Files\\App\\versions', 'C:\\Program Files\\App') !== null, "an all-users install may delete inside its own folders, never a whole program's");
         const allowedTarget = path.join(root, 'tools', 'go');
         t.write(path.join(allowedTarget, 'go.exe'), 'x');
         safeRemove(allowedTarget, root);

package/dist/selftest/index.d.ts

@@ -2,7 +2,7 @@ import type { Suite } from './support/suite.js';
 /** Every suite, in the order they run. The live ones come last: they are the slowest and need Windows. */
 export declare const SUITES: Suite[];
 /** Windows Sandbox (its user is always WDAGUtilityAccount) or a GitHub Actions runner: never someone's PC. */
-export declare const onThrowawayMachine: () => boolean;
+export declare function onThrowawayMachine(): boolean;
 /** Resolves "a,b" / ["a", "b"] to suites; throws with the list of valid names for an unknown one. */
-export declare const pickSuites: (names: string[]) => Suite[];
-export declare const selfTest: (packageRoot: string, suiteNames?: string[]) => Promise<number>;
+export declare function pickSuites(names: string[]): Suite[];
+export declare function selfTest(packageRoot: string, suiteNames?: string[]): Promise<number>;

package/dist/selftest/index.js

@@ -1,6 +1,6 @@
-// `agent-sandbox self-test [suite...]`: offline logic and security tests, plus live tests of the session daemon, ptyhost
-// and the git guard when running on Windows (they need csc.exe and ConPTY, both part of Windows 10/11).
-// They start real processes (the guest runtime, the daemon, csc, git), so they only run on a throwaway machine.
+// `agent-sandbox self-test [suite...]`: offline logic and security tests, plus live tests of the session daemon,
+// ptyhost and the git guard when running on Windows (they need csc.exe and ConPTY, both part of Windows 10/11). They
+// start real processes (the guest runtime, the daemon, csc, git), so they only run on a throwaway machine.
 //
 // Each area is one suite in its own *.test.ts file; the list below is the order they run in. Give suite names (or a
 // comma-separated list) to run only those: `sandbox self-test config`, `npm test -- live-daemon`.
@@ -16,6 +16,12 @@ import { channelSuite } from './channel.test.js';
 import { cliSuite } from './cli.test.js';
 import { cmdlineSuite } from './cmdline.test.js';
 import { configSuite } from './config.test.js';
+import { migrateSuite } from './migrate.test.js';
+import { updateSuite } from './update.test.js';
+import { installSuite } from './install.test.js';
+import { sharedUseSuite } from './shared-use.test.js';
+import { updateServiceSuite } from './update-service.test.js';
+import { sharingSuite } from './sharing.test.js';
 import { dataSuite } from './data.test.js';
 import { detectSuite } from './detect.test.js';
 import { generateSuite } from './generate.test.js';
@@ -45,10 +51,18 @@ import { liveNetworkSuite } from './live-network.test.js';
 import { liveTerminalSuite } from './live-terminal.test.js';
 import { auditSuite } from './audit.test.js';
 import { layoutSuite } from './layout.test.js';
+import { menuSuite } from './menu.test.js';
+import { resumeSuite } from './resume.test.js';
 /** Every suite, in the order they run. The live ones come last: they are the slowest and need Windows. */
 export const SUITES = [
     // settings and project files
     configSuite,
+    migrateSuite,
+    updateSuite,
+    updateServiceSuite,
+    installSuite,
+    sharingSuite,
+    sharedUseSuite,
     workspaceSuite,
     localConfigSuite,
     // the generated sandbox and the guest that boots it
@@ -56,6 +70,7 @@ export const SUITES = [
     guestBootSuite,
     mirrorSuite,
     projectsSuite,
+    resumeSuite,
     // syncing with this PC
     syncSuite,
     accountsSuite,
@@ -80,6 +95,7 @@ export const SUITES = [
     dataSuite,
     repairSuite,
     cliSuite,
+    menuSuite,
     agentCommandsSuite,
     // every command as its own process
     hostSimSuite,
@@ -91,7 +107,9 @@ export const SUITES = [
     liveTerminalSuite,
 ];
 /** Windows Sandbox (its user is always WDAGUtilityAccount) or a GitHub Actions runner: never someone's PC. */
-export const onThrowawayMachine = () => os.userInfo().username.toLowerCase() === 'wdagutilityaccount' || process.env.GITHUB_ACTIONS === 'true';
+export function onThrowawayMachine() {
+    return os.userInfo().username.toLowerCase() === 'wdagutilityaccount' || process.env.GITHUB_ACTIONS === 'true';
+}
 const withDeadline = async (work, ms, what) => {
     let timer;
     const deadline = new Promise((_, reject) => {
@@ -157,7 +175,7 @@ const printSummary = (results) => {
         ' s');
 };
 /** Resolves "a,b" / ["a", "b"] to suites; throws with the list of valid names for an unknown one. */
-export const pickSuites = (names) => {
+export function pickSuites(names) {
     const wanted = names
         .flatMap((n) => n.split(','))
         .map((n) => n.trim())
@@ -168,8 +186,8 @@ export const pickSuites = (names) => {
     if (unknown.length)
         throw new Error('No test suite called ' + unknown.join(', ') + '. Suites: ' + SUITES.map((s) => s.name).join(', '));
     return SUITES.filter((s) => wanted.includes(s.name));
-};
-export const selfTest = async (packageRoot, suiteNames = []) => {
+}
+export async function selfTest(packageRoot, suiteNames = []) {
     if (!onThrowawayMachine()) {
         console.error("The self-test only runs inside a Windows Sandbox, so it can never change this PC.\nRun it there: `sandbox start` in this folder, then `npm test` in the sandbox's terminal.");
         return 1;
@@ -185,8 +203,14 @@ export const selfTest = async (packageRoot, suiteNames = []) => {
     // Defence in depth (shared/test-guard.ts): with this set, host code refuses outward actions and writes outside temp.
     process.env.AGENT_SANDBOX_SELFTEST = '1';
     const t = createHarness(packageRoot);
-    const saved = { home: process.env.AGENT_SANDBOX_HOME, windir: process.env.WINDIR };
+    // The machine folder too: a real machine config (an all-users install) must never change what the tests load.
+    const saved = {
+        home: process.env.AGENT_SANDBOX_HOME,
+        machine: process.env.AGENT_SANDBOX_MACHINE_HOME,
+        windir: process.env.WINDIR,
+    };
     process.env.AGENT_SANDBOX_HOME = path.join(t.temp, 'user-home');
+    process.env.AGENT_SANDBOX_MACHINE_HOME = path.join(t.temp, 'machine-home');
     const results = [];
     try {
         const f = createFixtures(t);
@@ -201,6 +225,10 @@ export const selfTest = async (packageRoot, suiteNames = []) => {
             delete process.env.AGENT_SANDBOX_HOME;
         else
             process.env.AGENT_SANDBOX_HOME = saved.home;
+        if (saved.machine === undefined)
+            delete process.env.AGENT_SANDBOX_MACHINE_HOME;
+        else
+            process.env.AGENT_SANDBOX_MACHINE_HOME = saved.machine;
         if (saved.windir === undefined)
             delete process.env.WINDIR;
         else
@@ -212,4 +240,4 @@ export const selfTest = async (packageRoot, suiteNames = []) => {
     const failures = t.failures();
     console.log(failures === 0 ? '\nALL TESTS PASSED' : '\n' + failures + ' TEST(S) FAILED');
     return failures === 0 ? 0 : 1;
-};
+}

package/dist/selftest/install.test.d.ts

@@ -0,0 +1,2 @@
+import type { Suite } from './support/suite.js';
+export declare const installSuite: Suite;