windows-development-sandbox 1.4.1 → 1.4.3

package/dist/selftest/local-config.test.d.ts

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

package/dist/selftest/local-config.test.js

@@ -3,8 +3,8 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { download, setChecksumRequired } from '../shared/download.js';
-import { allowedAnswer, allowStorePath, saveAllowed } from '../core/local-config.js';
+import { Downloader } from '../shared/download/index.js';
+import { allowedAnswer, allowStorePath, saveAllowed } from '../core/local-config/index.js';
 export const localConfigSuite = {
     name: 'local-config',
     title: '.sandbox-config.json: approval, tighten-only rules, validation',
@@ -14,7 +14,10 @@ export const localConfigSuite = {
             harness: 'codex',
             sandbox: { memoryMb: 4096, networking: false, headless: true },
             toolchains: { node: { version: '18' }, rust: { enabled: false } },
-            mappings: [{ host: './assets', guest: 'C:\\Assets', readOnly: true }, { host: './data', guest: 'C:\\Data', readOnly: false }],
+            mappings: [
+                { host: './assets', guest: 'C:\\Assets', readOnly: true },
+                { host: './data', guest: 'C:\\Data', readOnly: false },
+            ],
             scripts: ['./setup.mjs'],
         };
         f.writeLocal(f.workB, localB);
@@ -30,7 +33,14 @@ export const localConfigSuite = {
             rustEnabled: approved.config.toolchains.rust.enabled,
             pythonStillOn: Boolean(approved.config.toolchains.python.enabled),
             nodeSource: approved.versions.node.source,
-        }, { harness: 'codex', memoryMb: 4096, headless: true, rustEnabled: false, pythonStillOn: true, nodeSource: '.sandbox-config.json' }, 'approved local settings apply over the defaults (including toolchains and headless)');
+        }, {
+            harness: 'codex',
+            memoryMb: 4096,
+            headless: true,
+            rustEnabled: false,
+            pythonStillOn: true,
+            nodeSource: '.sandbox-config.json',
+        }, 'approved local settings apply over the defaults (including toolchains and headless)');
         t.check(approved.config.mappings.some((m) => m.host === path.join(f.workB, 'data') && !m.readOnly), 'relative mapping paths resolve against the folder of .sandbox-config.json', 'mappings: ' + JSON.stringify(approved.config.mappings));
         t.check(approved.scripts.includes(path.join(f.workB, 'setup.mjs')), 'relative script paths resolve against the folder of .sandbox-config.json', 'scripts: ' + JSON.stringify(approved.scripts));
         t.equal((await f.run({ cwd: f.workB })).harnessName, 'codex', 'an approval is remembered');
@@ -57,13 +67,19 @@ export const localConfigSuite = {
         t.equal((await f.run({ cwd: dirC, trustConfig: true })).config.readOnly, true, '.sandbox-config.json may contain comments and trailing commas');
         t.section('folders outside the project (projects.allowOutsideMappings)');
         const dirD = t.dir('work-d');
-        const withOutside = (setting) => ({ ...f.baseConfig, projects: { ...f.baseConfig.projects, allowOutsideMappings: setting } });
+        const withOutside = (setting) => ({
+            ...f.baseConfig,
+            projects: { ...f.baseConfig.projects, allowOutsideMappings: setting },
+        });
         const outsideFile = { mappings: [{ host: '../shared', readOnly: true }] };
         f.writeLocal(dirD, outsideFile);
         const notAllowed = await t.thrownMessage(() => f.run({ cwd: dirD, trustConfig: true }, withOutside(false)));
-        t.check(notAllowed.includes('outside the project') && notAllowed.includes(f.shared) && notAllowed.includes('projects.allowOutsideMappings'), 'false: refused, naming the folder and the setting that allows it', notAllowed);
+        t.check(notAllowed.includes('outside the project') &&
+            notAllowed.includes(f.shared) &&
+            notAllowed.includes('projects.allowOutsideMappings'), 'false: refused, naming the folder and the setting that allows it', notAllowed);
         const allowedOutside = await f.run({ cwd: dirD, trustConfig: true }, withOutside(true));
-        t.check(allowedOutside.config.mappings.some((m) => m.host === f.shared) && (allowedOutside.outsideMappings ?? []).includes(f.shared), 'true: allowed, and marked as outside the project');
+        t.check(allowedOutside.config.mappings.some((m) => m.host === f.shared) &&
+            (allowedOutside.outsideMappings ?? []).includes(f.shared), 'true: allowed, and marked as outside the project');
         f.writeLocal(dirD, { ...outsideFile, readOnly: true });
         t.includes(await t.thrownMessage(() => f.run({ cwd: dirD }, withOutside(true))), '(outside the project)', 'true: still listed, flagged, when you approve the file');
         const asking = await t.thrownMessage(() => f.run({ cwd: dirD, trustConfig: true, ask: async () => true, interactive: false }));
@@ -71,7 +87,15 @@ export const localConfigSuite = {
         t.includes(await t.thrownMessage(() => f.run({ cwd: dirD, trustConfig: true, ask: async () => false, interactive: true })), 'You did not allow', '"ask": answering no stops the launch');
         const questions = [];
         f.writeLocal(dirD, { ...outsideFile, sandbox: { vGpu: true } });
-        const asked = await f.run({ cwd: dirD, trustConfig: true, interactive: true, ask: async (q) => { questions.push(q); return true; } });
+        const asked = await f.run({
+            cwd: dirD,
+            trustConfig: true,
+            interactive: true,
+            ask: async (q) => {
+                questions.push(q);
+                return true;
+            },
+        });
         t.check(questions.length === 1 && asked.config.sandbox.vGpu && asked.config.mappings.some((m) => m.host === f.shared), '"ask": the folder and a looser setting (vGPU) are asked together, once', JSON.stringify(questions));
         t.check((await f.run({ cwd: dirD, trustConfig: true, interactive: false })).config.mappings.some((m) => m.host === f.shared), '"ask": the answer is remembered for this project file');
         // What counts as outside is where the folder really is: environment variables are expanded and links followed.
@@ -112,18 +136,42 @@ export const localConfigSuite = {
             networking: kept.sandbox.networking,
             protectedClient: kept.sandbox.protectedClient,
             copyCredentials: kept.claudeProfile.copyCredentials,
-        }, { readOnly: true, blockPrivateRanges: true, gitAccess: 'readonly', vGpu: false, clipboard: false, networking: false, protectedClient: true, copyCredentials: false }, 'a project file can never loosen network, git, read-only, GPU, clipboard or login settings');
+        }, {
+            readOnly: true,
+            blockPrivateRanges: true,
+            gitAccess: 'readonly',
+            vGpu: false,
+            clipboard: false,
+            networking: false,
+            protectedClient: true,
+            copyCredentials: false,
+        }, 'a project file can never loosen network, git, read-only, GPU, clipboard or login settings');
         // You allowed one request for this project (asked once at an interactive launch): only that one is let through.
         const store = allowStorePath(strictUser.storage.root);
         saveAllowed(store, path.join(dirC, '.sandbox-config.json'), 'sandbox.vGpu', true, true);
         saveAllowed(store, path.join(dirC, '.sandbox-config.json'), 'sandbox.clipboard', true, false);
         const allowedRun = await f.run({ cwd: dirC, trustConfig: true }, strictUser);
-        t.equal({ vGpu: allowedRun.config.sandbox.vGpu, clipboard: allowedRun.config.sandbox.clipboard, networking: allowedRun.config.sandbox.networking }, { vGpu: true, clipboard: false, networking: false }, 'a request you allowed for this project is used; one you declined and the others are not');
-        t.check(allowedRun.notes.some((n) => n.includes('Allowed for this project: sandbox.vGpu')) && allowedRun.notes.some((n) => n.includes('sandbox.clipboard') && n.includes('You said no')), 'launch says what was allowed and what you declined', allowedRun.notes.join('\n'));
+        t.equal({
+            vGpu: allowedRun.config.sandbox.vGpu,
+            clipboard: allowedRun.config.sandbox.clipboard,
+            networking: allowedRun.config.sandbox.networking,
+        }, { vGpu: true, clipboard: false, networking: false }, 'a request you allowed for this project is used; one you declined and the others are not');
+        t.check(allowedRun.notes.some((n) => n.includes('Allowed for this project: sandbox.vGpu')) &&
+            allowedRun.notes.some((n) => n.includes('sandbox.clipboard') && n.includes('You said no')), 'launch says what was allowed and what you declined', allowedRun.notes.join('\n'));
         t.equal(allowedAnswer(store, path.join(f.workB, '.sandbox-config.json'), 'sandbox.vGpu', true), null, 'an answer is kept per project file');
-        f.writeLocal(dirC, { readOnly: true, network: { blockPrivateRanges: true }, provisioning: { git: { access: 'none' } }, sandbox: { networking: false, clipboard: false } });
+        f.writeLocal(dirC, {
+            readOnly: true,
+            network: { blockPrivateRanges: true },
+            provisioning: { git: { access: 'none' } },
+            sandbox: { networking: false, clipboard: false },
+        });
         const tightened = (await f.run({ cwd: dirC, trustConfig: true })).config;
-        t.equal({ readOnly: tightened.readOnly, gitAccess: tightened.provisioning.git.access, networking: tightened.sandbox.networking, clipboard: tightened.sandbox.clipboard }, { readOnly: true, gitAccess: 'none', networking: false, clipboard: false }, 'a project file can still make things stricter');
+        t.equal({
+            readOnly: tightened.readOnly,
+            gitAccess: tightened.provisioning.git.access,
+            networking: tightened.sandbox.networking,
+            clipboard: tightened.sandbox.clipboard,
+        }, { readOnly: true, gitAccess: 'none', networking: false, clipboard: false }, 'a project file can still make things stricter');
         t.section('downloads.requireChecksum');
         f.writeLocal(dirC, { downloads: { requireChecksum: false } });
         const keptOn = (await f.run({ cwd: dirC, trustConfig: true }, { ...f.baseConfig, downloads: { requireChecksum: true } })).config;
@@ -133,10 +181,10 @@ export const localConfigSuite = {
         t.equal(turnedOn.downloads.requireChecksum, true, 'a project file can switch the checksum requirement on');
         t.equal(f.baseConfig.downloads.requireChecksum, false, '(the requirement is off in the defaults)');
         // With the requirement on, a download without a hash is refused before anything is fetched.
-        setChecksumRequired(true);
+        const strict = new Downloader();
+        strict.requireChecksum = true;
         const target = path.join(os.tmpdir(), 'agent-sandbox-no-such-download.bin');
-        const refused = await download('http://127.0.0.1:9/tool.zip', target).then(() => '', (e) => e.message);
-        setChecksumRequired(false);
+        const refused = await strict.file('http://127.0.0.1:9/tool.zip', target).then(() => '', (e) => e.message);
         t.includes(refused, 'requireChecksum', 'a download with no hash is refused when checksums are required');
         t.includes(refused, 'tool.zip', 'the refusal names the download');
         t.check(!fs.existsSync(target) && !fs.existsSync(target + '.part'), 'a refused download leaves nothing behind');

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

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

package/dist/selftest/mirror.test.js

@@ -1,34 +1,70 @@
 // Guest paths on other drive letters (C:\Mirror\<letter> + subst) and guestWorkspace "mirror".
 import fs from 'node:fs';
 import path from 'node:path';
-import { Config, Mapping } from '../core/schema.js';
+import { ConfigSchema, MappingSchema } from '../core/schema/index.js';
 import { guestPathFor } from '../cli/commands/context.js';
-import { buildWsb } from '../host/launch/wsb.js';
-import { deriveGuest, guestDrive, isValidGuestPath, planMirrorWorkspace, sandboxFolder, substDrives } from '../shared/guest-paths.js';
-import { guestWorkspaceAliases, projectFolderName } from '../shared/paths.js';
-import { syncHistoryIn, syncHistoryOut } from '../sync/history.js';
+import { buildWsb } from '../host/launch/index.js';
+import { deriveGuest, guestDrive, isValidGuestPath, planMirrorWorkspace, sandboxFolder, substDrives, } from '../shared/paths/index.js';
+import { guestWorkspaceAliases, projectFolderName } from '../shared/paths/index.js';
+import { syncHistoryIn, syncHistoryOut } from '../sync/index.js';
 export const mirrorSuite = {
     name: 'mirror',
     title: 'guest paths on other drive letters, guestWorkspace "mirror"',
     run: async (t, f) => {
         t.section('which guest paths are valid');
-        const valid = ['C:\\Assets', 'C:\\Workspace\\x', 'F:\\SteamLibrary\\steamapps\\common\\Game', 'f:\\x', 'Z:\\a b\\c (1)'];
+        const valid = [
+            'C:\\Assets',
+            'C:\\Workspace\\x',
+            'F:\\SteamLibrary\\steamapps\\common\\Game',
+            'f:\\x',
+            'Z:\\a b\\c (1)',
+        ];
         t.equal(valid.filter((p) => !isValidGuestPath(p)), [], 'guest paths under C:\\ or on D: to Z: are accepted');
-        const invalid = ['C:\\', 'F:\\', 'F:', 'C:\\Windows\\x', 'C:\\Users\\me', 'c:\\program files\\x', 'C:\\AgentData\\x', 'C:\\Mirror', 'C:\\Mirror\\F\\x', 'A:\\x', 'B:\\x', 'C:\\a\\..\\Windows', 'F:\\a\\..\\b', 'F:\\a:b', 'F:\\a/b', 'F:\\a\\\\b', 'F:\\a.\\b', 'F:\\a|b', 'F:\\a\nb', '\\\\server\\share\\x', 'relative\\x', 'F:x'];
+        const invalid = [
+            'C:\\',
+            'F:\\',
+            'F:',
+            'C:\\Windows\\x',
+            'C:\\Users\\me',
+            'c:\\program files\\x',
+            'C:\\AgentData\\x',
+            'C:\\Mirror',
+            'C:\\Mirror\\F\\x',
+            'A:\\x',
+            'B:\\x',
+            'C:\\a\\..\\Windows',
+            'F:\\a\\..\\b',
+            'F:\\a:b',
+            'F:\\a/b',
+            'F:\\a\\\\b',
+            'F:\\a.\\b',
+            'F:\\a|b',
+            'F:\\a\nb',
+            '\\\\server\\share\\x',
+            'relative\\x',
+            'F:x',
+        ];
         t.equal(invalid.filter(isValidGuestPath), [], 'drive roots, reserved folders, C:\\Mirror, A:/B:, .., streams, odd characters and UNC paths are refused');
-        const mappingAccepts = (guest) => Mapping.safeParse({ host: 'E:\\Games', guest, readOnly: true }).success;
+        const mappingAccepts = (guest) => MappingSchema.safeParse({ host: 'E:\\Games', guest, readOnly: true }).success;
         t.check(mappingAccepts('F:\\SteamLibrary\\Game') && mappingAccepts('C:\\Windows\\x') && mappingAccepts(undefined), 'schema: any mappings[].guest is accepted, or none (the launch places it; it never fails the config)');
-        const workspaceAccepts = (guestWorkspace) => Config.safeParse({ ...f.makeConfig(), guestWorkspace }).success;
+        const workspaceAccepts = (guestWorkspace) => ConfigSchema.safeParse({ ...f.makeConfig(), guestWorkspace }).success;
         t.check(workspaceAccepts('mirror') && workspaceAccepts('F:\\AgentProjects\\x'), 'schema: guestWorkspace accepts "mirror" and D:-Z: paths');
         t.check(!workspaceAccepts('C:\\Users\\x'), 'schema: guestWorkspace refuses reserved paths');
         t.equal([guestDrive('f:\\x'), guestDrive('\\\\s\\x')], ['F', null], 'drive letter of a guest path');
         t.section('where a drive-letter path really lives');
         t.equal([sandboxFolder('F:\\SteamLibrary\\Game'), sandboxFolder('f:\\x'), sandboxFolder('C:\\Assets')], ['C:\\Mirror\\F\\SteamLibrary\\Game', 'C:\\Mirror\\F\\x', 'C:\\Assets'], 'F:\\x really lives at C:\\Mirror\\F\\x; C: paths stay as they are');
-        t.equal(substDrives(['C:\\a', 'G:\\z', 'F:\\x', 'f:\\y']), [{ letter: 'F', target: 'C:\\Mirror\\F' }, { letter: 'G', target: 'C:\\Mirror\\G' }], 'one subst drive per used letter (never C:), sorted');
+        t.equal(substDrives(['C:\\a', 'G:\\z', 'F:\\x', 'f:\\y']), [
+            { letter: 'F', target: 'C:\\Mirror\\F' },
+            { letter: 'G', target: 'C:\\Mirror\\G' },
+        ], 'one subst drive per used letter (never C:), sorted');
         t.equal(guestWorkspaceAliases('F:\\AgentProjects\\mw2'), ['C:\\Mirror\\F\\AgentProjects\\mw2', 'F:\\AgentProjects\\mw2'], 'a mirrored workspace is also known by its real C:\\Mirror path');
         t.equal(guestWorkspaceAliases('C:\\Workspace\\x').length, 1, 'a C: workspace has no alias');
         const wsb = buildWsb(f.baseConfig, 4096, [
-            { host: 'E:\\SteamLibrary\\steamapps\\common\\Game', guest: 'F:\\SteamLibrary\\steamapps\\common\\Game', readOnly: true },
+            {
+                host: 'E:\\SteamLibrary\\steamapps\\common\\Game',
+                guest: 'F:\\SteamLibrary\\steamapps\\common\\Game',
+                readOnly: true,
+            },
             { host: 'D:\\Assets', guest: 'C:\\Assets', readOnly: false },
         ]);
         t.includes(wsb, '<SandboxFolder>C:\\Mirror\\F\\SteamLibrary\\steamapps\\common\\Game</SandboxFolder>', 'the .wsb maps F:\\ guests under C:\\Mirror\\F');
@@ -54,12 +90,22 @@ export const mirrorSuite = {
         t.section('generating a sandbox with drive-letter folders');
         const game = t.dir('steam', 'Game');
         const base = await f.run();
-        const run = { ...base, config: { ...base.config, guestWorkspace: 'G:\\Projects\\work-a', mappings: [{ host: game, guest: 'F:\\SteamLibrary\\steamapps\\common\\Game', readOnly: true }] } };
+        const run = {
+            ...base,
+            config: {
+                ...base.config,
+                guestWorkspace: 'G:\\Projects\\work-a',
+                mappings: [{ host: game, guest: 'F:\\SteamLibrary\\steamapps\\common\\Game', readOnly: true }],
+            },
+        };
         const generated = f.generate(run);
         const session = f.readJson(generated.sessionPath);
         const text = fs.readFileSync(generated.wsbPath, 'utf8');
         t.equal(session.workspace, 'G:\\Projects\\work-a', 'session.json: the workspace is at its drive-letter path');
-        t.equal(session.substDrives, [{ letter: 'F', target: 'C:\\Mirror\\F' }, { letter: 'G', target: 'C:\\Mirror\\G' }], 'session.json: subst drives are listed for bootstrap.ps1');
+        t.equal(session.substDrives, [
+            { letter: 'F', target: 'C:\\Mirror\\F' },
+            { letter: 'G', target: 'C:\\Mirror\\G' },
+        ], 'session.json: subst drives are listed for bootstrap.ps1');
         t.includes(text, '<SandboxFolder>C:\\Mirror\\G\\Projects\\work-a</SandboxFolder>', '.wsb: the workspace is under C:\\Mirror');
         t.includes(text, '<SandboxFolder>C:\\Mirror\\F\\SteamLibrary\\steamapps\\common\\Game</SandboxFolder>', '.wsb: the mapping is under C:\\Mirror');
         t.equal(f.readJson(f.generate(base).sessionPath).substDrives, [], 'no other drive letters: no subst drives');
@@ -72,31 +118,55 @@ export const mirrorSuite = {
         const other = t.dir('steam', 'Other');
         const placed = (mappings) => {
             const g = f.generate({ ...run, config: { ...run.config, mappings } });
-            return { guests: g.mappings.filter((m) => m.host === game || m.host === other).map((m) => m.guest), notes: g.mappingNotes, wsb: fs.readFileSync(g.wsbPath, 'utf8') };
+            return {
+                guests: g.mappings.filter((m) => m.host === game || m.host === other).map((m) => m.guest),
+                notes: g.mappingNotes,
+                wsb: fs.readFileSync(g.wsbPath, 'utf8'),
+            };
         };
-        const awkward = placed([
-            { host: game, guest: 'C:\\Windows\\foo', readOnly: true },
-            { host: game, guest: 'C:\\Users\\x', readOnly: true },
-            { host: game, guest: 'C:\\AgentData\\y', readOnly: true },
-            { host: game, guest: 'C:\\Mirror\\F\\x', readOnly: true },
+        const usable = placed([
             { host: game, guest: 'D:\\Games', readOnly: true },
-            { host: game, guest: 'G:\\Projects\\work-a', readOnly: true },
             { host: game, guest: 'c:/assets/', readOnly: true },
-            { host: other, guest: 'C:\\Assets', readOnly: true },
-            { host: game, guest: 'C:\\Assets', readOnly: true },
+            { host: game, guest: 'C:\\assets', readOnly: true },
         ]);
-        t.equal(awkward.guests, ['C:\\Mapped\\C\\Windows\\foo', 'C:\\Mapped\\C\\Users\\x', 'C:\\Mapped\\C\\AgentData\\y', 'C:\\Mapped\\C\\Mirror\\F\\x', 'D:\\Games', 'C:\\Mapped\\G\\Projects\\work-a', 'C:\\assets', 'C:\\Mapped\\C\\Assets'], 'reserved paths, C:\\Mirror and the workspace itself go to C:\\Mapped\\<drive>\\<path>; D:\\Games and a tidied c:/assets/ are used as they are; a repeat is mapped once; a second folder on the same path moves');
-        t.check(awkward.notes.some((n) => n.includes('C:\\Windows\\foo') && n.includes('keeps for itself') && n.includes('C:\\Mapped\\C\\Windows\\foo')), 'a note says where a reserved path went and why', awkward.notes.join('\n'));
-        t.check(awkward.notes.some((n) => n.startsWith(other) && n.includes('already used by') && n.includes(game)), 'a conflict note names both folders', awkward.notes.join('\n'));
-        t.check(!/<SandboxFolder>C:\\(Windows|Users|AgentData\\y|Mirror\\F\\x)/i.test(awkward.wsb), 'a reserved guest path never reaches the .wsb');
-        const derived = placed([{ host: game, readOnly: true }]);
-        t.check(derived.guests.length === 1 && (/^C:\\Mapped\\C\\Users\\/i.test(derived.guests[0]) || derived.guests[0].toLowerCase() === game.toLowerCase()), 'no guest, outside the project: the PC path, or C:\\Mapped\\... when that path is reserved (the temp folder is under C:\\Users)', JSON.stringify(derived));
+        t.equal(usable.guests, ['D:\\Games', 'C:\\assets'], 'a usable guest path is used exactly as asked (c:/assets/ tidied); the same folder at the same place is mapped once');
+        const refused = await t.thrownMessage(() => placed([
+            { host: game, guest: 'C:\\Windows\\foo', readOnly: true },
+            { host: game, guest: 'steamapps\\Game', readOnly: true },
+            { host: game, guest: 'G:\\Projects\\work-a', readOnly: true },
+            { host: game, guest: 'C:\\Assets', readOnly: true },
+            { host: other, guest: 'C:\\Assets', readOnly: true },
+        ]));
+        t.check(refused.includes('4 mapped folders cannot be used'), 'unusable guest paths stop the launch, all named in one message (never moved elsewhere)', refused);
+        t.check(refused.includes('C:\\Windows\\foo is a folder the sandbox keeps for itself') &&
+            refused.includes('steamapps\\Game is not a full path') &&
+            refused.includes('already used by'), '... each with why: reserved, relative, overlapping', refused);
+        t.check(refused.includes('Fix: set "guest" to a full path'), '... and the fix', refused);
+        t.excludes(refused, 'C:\\Mapped', 'no folder is ever placed under C:\\Mapped');
+        const derived = await t.thrownMessage(() => placed([{ host: game, readOnly: true }]));
+        t.check(derived === '' || derived.includes('give it a "guest" path'), 'no guest, outside the project: the PC path, or (under C:\\Users, like the temp folder) a message asking for a guest path', derived);
         const inside = t.dir('work-a', 'data');
         const insideRun = await f.run();
-        const insideGen = f.generate({ ...insideRun, config: { ...insideRun.config, mappings: [{ host: inside, readOnly: true }] } });
-        t.check(!insideGen.mappings.some((m) => m.host === inside) && insideGen.mappingNotes.some((n) => n.includes('already in the sandbox at C:\\Workspace\\work-a\\data')), 'no guest, inside the project: already there, no second mapping', insideGen.mappingNotes.join('\n'));
-        const missingRequired = await t.thrownMessage(() => f.generate({ ...run, config: { ...run.config, mappings: [{ host: t.at('nope-1'), readOnly: true }, { host: t.at('nope-2'), guest: 'C:\\Windows', readOnly: true }] } }));
-        t.check(missingRequired.includes('2 mapped folders cannot be used') && missingRequired.includes('nope-1') && missingRequired.includes('nope-2') && missingRequired.includes('"optional": true'), 'folders that are not there: one message listing each, with the fix', missingRequired);
+        const insideGen = f.generate({
+            ...insideRun,
+            config: { ...insideRun.config, mappings: [{ host: inside, readOnly: true }] },
+        });
+        t.check(!insideGen.mappings.some((m) => m.host === inside) &&
+            insideGen.mappingNotes.some((n) => n.includes('already in the sandbox at C:\\Workspace\\work-a\\data')), 'no guest, inside the project: already there, no second mapping', insideGen.mappingNotes.join('\n'));
+        const missingRequired = await t.thrownMessage(() => f.generate({
+            ...run,
+            config: {
+                ...run.config,
+                mappings: [
+                    { host: t.at('nope-1'), readOnly: true },
+                    { host: t.at('nope-2'), guest: 'C:\\Windows', readOnly: true },
+                ],
+            },
+        }));
+        t.check(missingRequired.includes('2 mapped folders cannot be used') &&
+            missingRequired.includes('nope-1') &&
+            missingRequired.includes('nope-2') &&
+            missingRequired.includes('"optional": true'), 'folders that are not there: one message listing each, with the fix', missingRequired);
         t.section('exec, attach and history for a mirrored workspace');
         const workspace = 'F:\\AgentProjects\\mw2-agent';
         t.equal(guestPathFor(workspace + '\\crates\\engine', workspace, workspace), workspace + '\\crates\\engine', 'a host folder maps to the same guest folder');

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

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

package/dist/selftest/network.test.js

@@ -1,6 +1,6 @@
-import { isSandboxAddress } from '../host/attach.js';
-import { buildFirewallCommands, cidrToRange, ipv4DnsServers, parseDefaultGateways, parseDnsServers, subtractIps } from '../shared/netrules.js';
-import { expandAllowList, hostAllowed, withBlockedHosts } from '../shared/netpolicy.js';
+import { isSandboxAddress } from '../host/channel/index.js';
+import { buildFirewallCommands, cidrToRange, ipv4DnsServers, parseDefaultGateways, parseDnsServers, subtractIps, } from '../shared/network/index.js';
+import { expandAllowList, hostAllowed, withBlockedHosts } from '../shared/network/index.js';
 export const networkSuite = {
     name: 'network',
     title: 'firewall maths, gateway/DNS parsing, attach address checks',
@@ -17,19 +17,28 @@ export const networkSuite = {
         t.equal(ipv4DnsServers(['172.28.80.1', '8.8.8.8:1053', '[::1]:53', 'fe80::1']), ['172.28.80.1', '8.8.8.8'], 'DNS servers from the resolver (any Windows language): IPv4 only, ports dropped');
         t.section('attach only reaches into the sandbox');
         const interfaces = {
-            'vEthernet (Default Switch)': [{ address: '172.20.0.1', netmask: '255.255.240.0', family: 'IPv4', internal: false, mac: '', cidr: null }],
-            'vEthernet (WSL (Hyper-V firewall))': [{ address: '172.30.0.1', netmask: '255.255.240.0', family: 'IPv4', internal: false, mac: '', cidr: null }],
-            Ethernet: [{ address: '192.168.1.10', netmask: '255.255.255.0', family: 'IPv4', internal: false, mac: '', cidr: null }],
+            'vEthernet (Default Switch)': [
+                { address: '172.20.0.1', netmask: '255.255.240.0', family: 'IPv4', internal: false, mac: '', cidr: null },
+            ],
+            'vEthernet (WSL (Hyper-V firewall))': [
+                { address: '172.30.0.1', netmask: '255.255.240.0', family: 'IPv4', internal: false, mac: '', cidr: null },
+            ],
+            Ethernet: [
+                { address: '192.168.1.10', netmask: '255.255.255.0', family: 'IPv4', internal: false, mac: '', cidr: null },
+            ],
         };
         t.check(isSandboxAddress('172.20.5.9', interfaces), 'an address in the Hyper-V subnet is the sandbox');
         t.check(!isSandboxAddress('192.168.1.20', interfaces), 'a LAN address is not');
         t.check(!isSandboxAddress('172.30.4.4', interfaces), 'an address on the WSL Hyper-V network is not (keystrokes never go to a WSL VM)');
         t.check(!isSandboxAddress('127.0.0.1', interfaces), 'loopback is not');
         t.check(!isSandboxAddress('8.8.8.8', interfaces), 'an internet address is not');
-        t.check(!isSandboxAddress('172.20.0.1', interfaces), 'this PC\'s own address on that subnet is not');
+        t.check(!isSandboxAddress('172.20.0.1', interfaces), "this PC's own address on that subnet is not");
         t.section('network settings');
         const allow = expandAllowList(['@developer', 'Example.COM', '*.corp.example', 'not a host!']);
-        t.check(allow.includes('registry.npmjs.org') && allow.includes('api.anthropic.com') && allow.includes('example.com') && !allow.includes('not a host!'), 'allowOnly: @developer expands to registries, GitHub and AI providers; bad entries are dropped');
+        t.check(allow.includes('registry.npmjs.org') &&
+            allow.includes('api.anthropic.com') &&
+            allow.includes('example.com') &&
+            !allow.includes('not a host!'), 'allowOnly: @developer expands to registries, GitHub and AI providers; bad entries are dropped');
         t.equal(['a.corp.example', 'corp.example', 'example.com', 'www.example.com', 'evil-example.com'].map((h) => hostAllowed(h, allow)), [true, false, true, false, false], 'allowOnly: *.x covers subdomains only, a name covers only itself');
         const hosts = '127.0.0.1 localhost\r\n# mine\r\n';
         const once = withBlockedHosts(hosts, ['Telemetry.Example.com', '*.bad']);

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

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

package/dist/selftest/personalization.test.js

@@ -2,8 +2,8 @@
 // PowerShell 7 profile. The Windows Terminal part is only tried on temp copies.
 import fs from 'node:fs';
 import path from 'node:path';
-import { toRegFile } from '../host/personalize.js';
-import { PWSH_PROFILE_GUID, syncPwshProfile, withPwshProfile } from '../host/terminal.js';
+import { toRegFile } from '../host/profile/index.js';
+import { PWSH_PROFILE_GUID, syncPwshProfile, withPwshProfile } from '../host/tools/index.js';
 export const personalizationSuite = {
     name: 'personalization',
     title: 'registry personalisation (.reg) and the Windows Terminal PowerShell 7 profile',
@@ -27,9 +27,16 @@ export const personalizationSuite = {
         t.check(Boolean(shownProfiles?.defaults) && shown?.theme === 'dark', 'the rest of the settings are kept');
         t.equal(withPwshProfile(shown, true), null, 'nothing is rewritten when the profile is already there');
         t.equal(withPwshProfile({ profiles: { defaults: {} } }, false), null, 'nothing is rewritten when pwsh was never wanted');
-        const edited = { profiles: { list: [{ guid: 'other' }, { guid: PWSH_PROFILE_GUID.toUpperCase(), name: 'My pwsh', fontSize: 14 }] } };
+        const edited = {
+            profiles: { list: [{ guid: 'other' }, { guid: PWSH_PROFILE_GUID.toUpperCase(), name: 'My pwsh', fontSize: 14 }] },
+        };
         const hidden = withPwshProfile(edited, false)?.profiles;
-        t.equal({ hidden: hidden?.list[1].hidden, name: hidden?.list[1].name, fontSize: hidden?.list[1].fontSize, count: hidden?.list.length }, { hidden: true, name: 'My pwsh', fontSize: 14, count: 2 }, 'turning pwsh off hides the profile and keeps the user\'s edits');
+        t.equal({
+            hidden: hidden?.list[1].hidden,
+            name: hidden?.list[1].name,
+            fontSize: hidden?.list[1].fontSize,
+            count: hidden?.list.length,
+        }, { hidden: true, name: 'My pwsh', fontSize: 14, count: 2 }, "turning pwsh off hides the profile and keeps the user's edits");
         const oldForm = withPwshProfile({ profiles: [{ guid: 'a' }] }, true)?.profiles;
         t.equal(oldForm.list.length, 2, 'the old array form of "profiles" works');
         t.section('Windows Terminal settings.json on disk (JSONC, temp copy)');
@@ -42,7 +49,7 @@ export const personalizationSuite = {
         t.write(path.join(data, 'tools', 'pwsh', 'pwsh.exe'), 'MZ');
         syncPwshProfile(data, true);
         const added = read();
-        t.equal(added.theme, 'light', 'once pwsh is installed the profile is added and the user\'s settings are kept');
+        t.equal(added.theme, 'light', "once pwsh is installed the profile is added and the user's settings are kept");
         t.equal(added.profiles.list.map((p) => p.guid), ['{x}', PWSH_PROFILE_GUID], 'the profile is added after the existing ones');
         syncPwshProfile(data, false);
         t.equal(read().profiles.list[1].hidden, true, 'the profile is hidden when pwsh is turned off');

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

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