windows-development-sandbox 1.7.0 → 1.10.0

package/dist/selftest/engine.test.js

@@ -0,0 +1,127 @@
+// The engine layer and storage providers (phase 1): the Windows Sandbox engine writes exactly the .wsb and launch
+// folder the code before the layer did, the settings for later engines are refused clearly, and a project cannot set
+// them.
+import fs from 'node:fs';
+import path from 'node:path';
+import { DEFAULTS } from '../core/config/index.js';
+import { LocalOverridesSchema } from '../core/schema/index.js';
+import { xmlEscape } from '../core/util/index.js';
+import { engineFor, engineReports, WindowsSandboxEngine, } from '../host/engines/index.js';
+import { buildLaunchPlan, buildWsb } from '../host/launch/index.js';
+import { folderAttachment, FolderStorageProvider, providerFor } from '../host/storage/index.js';
+import { sandboxFolder } from '../shared/paths/index.js';
+import { NO_HCS_PC } from './support/hcs-probes.js';
+import { ENGINE_CASES } from './support/engine-cases.js';
+import { ENGINE_GOLDEN, LAUNCH_FILES_GOLDEN } from './support/engine-golden.js';
+/** The .wsb writer as it was before the engine layer (frozen copy), to compare real launches with. */
+function legacyWsb(config, memoryMb, mappings) {
+    const s = config.sandbox;
+    const element = (name, value) => '<' + name + '>' + value + '</' + name + '>';
+    const toggle = (value) => (value ? 'Enable' : 'Disable');
+    const devices = [
+        ['vGPU', s.vGpu],
+        ['Networking', s.networking],
+        ['ClipboardRedirection', s.clipboard],
+        ['AudioInput', s.audioInput],
+        ['VideoInput', s.videoInput],
+        ['PrinterRedirection', s.printerRedirection],
+        ['ProtectedClient', s.protectedClient],
+    ];
+    const folders = mappings
+        .map((m) => element('MappedFolder', element('HostFolder', xmlEscape(m.host)) +
+        element('SandboxFolder', xmlEscape(sandboxFolder(m.guest))) +
+        element('ReadOnly', String(m.readOnly))))
+        .join('');
+    return element('Configuration', element('MemoryInMB', String(memoryMb)) +
+        devices.map(([name, value]) => element(name, toggle(value))).join('') +
+        element('MappedFolders', folders) +
+        element('LogonCommand', element('Command', xmlEscape('C:\\AgentLaunch\\sandbox\\boot\\logon.cmd'))));
+}
+function filesUnder(dir, rel = '') {
+    return fs
+        .readdirSync(path.join(dir, rel), { withFileTypes: true })
+        .flatMap((e) => e.isDirectory() ? filesUnder(dir, rel ? rel + '/' + e.name : e.name) : [rel ? rel + '/' + e.name : e.name])
+        .sort();
+}
+export const engineSuite = {
+    name: 'engine',
+    title: 'engine layer, Windows Sandbox engine, storage providers, new settings',
+    run: async (t, f) => {
+        t.section('the .wsb through the engine is what it always was');
+        for (const c of ENGINE_CASES) {
+            const plan = buildLaunchPlan({
+                config: c.config,
+                memoryMb: c.memoryMb,
+                mappings: c.mappings,
+                launchPath: 'C:\\L\\launches\\1',
+                storage: [],
+            });
+            const viaEngine = new WindowsSandboxEngine(c.config.sandbox, () => false).plan(plan).files[0].text;
+            t.check(viaEngine === ENGINE_GOLDEN[c.name] &&
+                buildWsb(c.config, c.memoryMb, [...c.mappings]) === ENGINE_GOLDEN[c.name], 'byte-identical .wsb: ' + c.name, 'expected: ' + ENGINE_GOLDEN[c.name] + '\nactual:   ' + viaEngine);
+            t.equal(viaEngine, legacyWsb(c.config, c.memoryMb, c.mappings), 'same as the frozen old writer: ' + c.name);
+        }
+        t.section('a real launch');
+        const gen = await f.launch({}, { args: ['--version'], probe: { ...f.probe, gitDir: f.shared, nvmDir: f.workB } });
+        t.equal(fs.readFileSync(gen.wsbPath, 'utf8'), legacyWsb(f.baseConfig, gen.memoryMb, gen.mappings), 'the launch writes the .wsb the old writer would have (same settings, memory and mappings)');
+        t.equal(path.basename(gen.wsbPath), 'agent.wsb', 'the engine file is still agent.wsb in the launch folder');
+        t.equal(gen.enginePlan.entry, gen.wsbPath, 'the engine plan starts from that file');
+        t.equal(filesUnder(gen.launchPath), [...LAUNCH_FILES_GOLDEN], 'the launch folder has exactly the files it had before');
+        t.equal(gen.mappings.find((m) => m.guest === 'C:\\AgentData')?.host, f.baseConfig.storage.root + '\\data\\testdata', 'the data folder is still mapped at C:\\AgentData (through the folder provider)');
+        t.section('capabilities');
+        const caps = (over, cli) => new WindowsSandboxEngine({ ...DEFAULTS.sandbox, ...over }, () => cli).capabilities();
+        t.equal(caps({}, false), {
+            desktop: true,
+            gpu: false,
+            clipboard: true,
+            audio: false,
+            video: false,
+            printers: false,
+            liveFolderAdd: false,
+            attachedDisks: false,
+            multipleInstances: false,
+            hvsocket: false,
+        }, 'Windows Sandbox: desktop and clipboard by default, no live folders without the wsb CLI, no disks, one at a time');
+        t.equal([caps({ vGpu: true, audioInput: true, videoInput: true, printerRedirection: true, clipboard: false }, true)].map((c) => [c.gpu, c.audio, c.video, c.printers, c.clipboard, c.liveFolderAdd]), [[true, true, true, true, false, true]], 'capabilities follow the device settings and the wsb CLI');
+        const reports = await engineReports(f.baseConfig, NO_HCS_PC);
+        t.check(reports.length === 2 &&
+            reports[0].inUse &&
+            !reports[1].inUse &&
+            !reports[1].check.available &&
+            reports[1].check.reasons[0].includes('computecore.dll'), 'sandbox engine lists both engines; the HCS check says what this PC lacks');
+        t.section('settings that cannot work yet are refused');
+        const hcs = { ...structuredClone(f.baseConfig), sandbox: { ...f.baseConfig.sandbox, engine: 'hcs' } };
+        const vhdx = {
+            ...structuredClone(f.baseConfig),
+            storage: { ...f.baseConfig.storage, contained: 'vhdx' },
+        };
+        t.equal([DEFAULTS.sandbox.engine, DEFAULTS.storage.contained, DEFAULTS.storage.containedMaxGb], ['windows-sandbox', 'off', 64], 'defaults: Windows Sandbox, loose folders, 64 GB');
+        await t.throws(() => engineFor(hcs), 'The HCS engine has to be opened first', 'engine hcs is not handed out without its check');
+        await t.throws(() => providerFor(vhdx, {
+            availability: () => ({ available: false, reasons: ['No disks here.'], fixes: ['Use a PC.'] }),
+        }), 'Contained storage cannot be used: No disks here.', 'contained vhdx is refused where this PC cannot use it');
+        const launches = path.join(f.baseConfig.storage.root, 'launches');
+        const before = fs.readdirSync(launches).length;
+        await t.throws(() => f.launch({}, { config: hcs }), 'HCS engine has to be opened first', 'a launch with hcs stops');
+        await t.throws(() => f.launch({}, { config: vhdx }), 'Contained storage was not prepared for this launch', 'a launch with vhdx that was not mounted first stops');
+        t.equal(fs.readdirSync(launches).length, before, 'a refused launch writes no launch folder');
+        t.section('storage provider: folder');
+        const set = { dataPath: 'C:\\S\\data\\x', guest: 'C:\\AgentData' };
+        const prepared = await new FolderStorageProvider().prepare(set);
+        t.equal([prepared.attachments, prepared.mappings, (await new FolderStorageProvider().check()).available], [[folderAttachment(set)], [{ host: set.dataPath, guest: set.guest, readOnly: false }], true], 'the folder provider shares the data folder read/write, as before');
+        t.section('a project cannot choose the engine or the storage kind');
+        t.check(!LocalOverridesSchema.safeParse({ sandbox: { engine: 'hcs' } }).success &&
+            !LocalOverridesSchema.safeParse({ storage: { contained: 'vhdx' } }).success &&
+            !LocalOverridesSchema.safeParse({ storage: { containedMaxGb: 8 } }).success, "a project's .sandbox-config.json cannot set sandbox.engine, storage.contained or storage.containedMaxGb");
+        t.check(LocalOverridesSchema.safeParse({ sandbox: { vGpu: false } }).success, 'other sandbox settings are still allowed in a project file');
+        t.section('sandbox engine');
+        const run = await f.runBin('agent-sandbox', ['engine', '--json', '--config', t.writeJson(t.at('engine-config.json'), {})], {
+            cwd: f.workA,
+            env: { ...process.env, NO_COLOR: '1', AGENT_SANDBOX_HOME: t.dir('engine-home'), AGENT_SANDBOX_HOST_ONLY: '1' },
+        });
+        const parsed = JSON.parse(run.out.slice(run.out.indexOf('{')));
+        t.check(run.status === 0 &&
+            parsed.engine === 'windows-sandbox' &&
+            parsed.engines.map((e) => e.id).join() === 'windows-sandbox,hcs', 'sandbox engine --json names the engine in use and both engines', run.out);
+    },
+};

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

@@ -2,7 +2,10 @@
 // what it copies in, and what it refuses to.
 import fs from 'node:fs';
 import path from 'node:path';
-import { readJsonFile } from '../shared/io/index.js';
+import { spawnSync } from 'node:child_process';
+import { copyTreeTolerant, readJsonFile, robocopyErrors, robocopyFailed, robocopyMeaning } from '../shared/io/index.js';
+import { scriptArgs } from '../shared/scripts.js';
+import { SYSTEM } from '../shared/system.js';
 export const guestBootSuite = {
     name: 'guest-boot',
     title: 'guest boot in dry-run mode (provisioning, Claude state, git policy)',
@@ -92,5 +95,48 @@ export const guestBootSuite = {
         const genNoAgent = await f.launch({ noAgent: true });
         const noAgent = await f.runGuest(genNoAgent.launchPath, t.at('data5'), f.workA);
         t.check(noAgent.status === 0 && noAgent.out.includes('no agent requested'), '--no-agent provisions without an agent', noAgent.out);
+        t.section('robocopy results, vanished files, shortcuts');
+        t.check([0, 1, 2, 3, 7].every((c) => !robocopyFailed(c)) &&
+            [8, 9, 16].every((c) => robocopyFailed(c)) &&
+            robocopyFailed(null), 'robocopy: exit codes below 8 are success, 8 and up (9 = some copied, some failed) are failures');
+        t.includes(robocopyMeaning(9), 'some files were copied and some could not be', 'robocopy: exit 9 is explained');
+        t.equal(robocopyErrors('x\r\n2026/10/11 ERROR 32 (0x00000020) Copying File C:\\a\\b.dll\r\nThe process cannot access the file because it is being used by another process.\r\n', 5), [
+            '2026/10/11 ERROR 32 (0x00000020) Copying File C:\\a\\b.dll',
+            'The process cannot access the file because it is being used by another process.',
+        ], 'robocopy: the failing file and the reason are picked out of its output');
+        const spool = t.dir('copy-tree', 'live');
+        t.write(path.join(spool, 'a.json'), '1');
+        t.write(path.join(spool, 'b.json'), '2');
+        t.write(path.join(spool, 'db', 'chroma.sqlite3'), 'db');
+        t.write(path.join(spool, 'db', 'chroma.sqlite3-journal'), 'j');
+        t.write(path.join(spool, 'x.lock'), 'l');
+        const copied = copyTreeTolerant(spool, t.at('copy-tree', 'out'), (name) => /\.lock$|-journal$/.test(name));
+        t.check(copied.copied === 3 && !fs.existsSync(t.at('copy-tree', 'out', 'db', 'chroma.sqlite3-journal')), 'copy tree: files are copied, a -journal and a lock file are left out');
+        // The first file of the listing deletes the second before it is reached: the second has vanished, not failed.
+        const racing = t.dir('copy-tree', 'racing');
+        t.write(path.join(racing, 'a.json'), '1');
+        t.write(path.join(racing, 'b.json'), '2');
+        const result = copyTreeTolerant(racing, t.at('copy-tree', 'racing-out'), (name) => {
+            if (name === 'a.json')
+                fs.rmSync(path.join(racing, 'b.json'), { force: true });
+            return false;
+        });
+        t.check(result.copied === 1 && result.vanished === 1, 'copy tree: a file that vanishes during the copy is skipped, not an error');
+        t.equal(copyTreeTolerant(t.at('copy-tree', 'nothing'), t.at('copy-tree', 'nothing-out')).vanished, 1, 'copy tree: a missing folder is tolerated');
+        if (process.platform === 'win32') {
+            // Windows PowerShell 5.1 hands a JSON array over as one object: two or more shortcuts used to fail.
+            const out = t.dir('shortcuts');
+            const list = t.writeJson(path.join(out, 'in.json'), [
+                { link: path.join(out, 'one', 'A.lnk'), target: path.join(process.env.WINDIR ?? 'C:\\Windows', 'notepad.exe') },
+                { link: path.join(out, 'two', 'B.lnk'), target: path.join(process.env.WINDIR ?? 'C:\\Windows', 'notepad.exe') },
+            ]);
+            const made = spawnSync(SYSTEM.powershell(), scriptArgs('new-shortcuts.ps1', ['-ListFile', list]), {
+                encoding: 'utf8',
+                windowsHide: true,
+            });
+            t.check(made.status === 0 &&
+                fs.existsSync(path.join(out, 'one', 'A.lnk')) &&
+                fs.existsSync(path.join(out, 'two', 'B.lnk')), 'new-shortcuts.ps1 makes every shortcut of a list of two', String(made.stderr));
+        }
     },
 };

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

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