windows-development-sandbox 1.4.0 → 1.4.3

package/dist/selftest/config.test.js

@@ -1,8 +1,8 @@
 // Loading the settings: built-in defaults, a user config file, and the example config that ships with the tool.
 import path from 'node:path';
 import _ from 'lodash';
-import { DEFAULTS, loadConfig } from '../core/config.js';
-import { readJsonc } from '../core/util.js';
+import { DEFAULTS, loadConfig } from '../core/config/index.js';
+import { readJsonc } from '../core/util/index.js';
 export const configSuite = {
     name: 'config',
     title: 'built-in defaults, user config file, config.example.json',
@@ -23,16 +23,23 @@ export const configSuite = {
             mappings: [{ host: 'rel-folder', guest: 'C:\\Rel', readOnly: true }],
         });
         const custom = loadConfig(customFile);
-        t.equal({ headless: custom.config.sandbox.headless, rust: custom.config.toolchains.rust.enabled, python: custom.config.toolchains.python.enabled }, { headless: true, rust: false, python: 'auto' }, 'a config file only needs the keys it changes (deep merge over the defaults)');
+        t.equal({
+            headless: custom.config.sandbox.headless,
+            rust: custom.config.toolchains.rust.enabled,
+            python: custom.config.toolchains.python.enabled,
+        }, { headless: true, rust: false, python: 'auto' }, 'a config file only needs the keys it changes (deep merge over the defaults)');
         await t.throws(() => loadConfig(t.at('missing.json')), 'Config file not found', 'an explicit --config that does not exist is an error');
         t.dir('rel-folder');
         const relativeRun = await f.run({}, { ...custom.config, storage: f.baseConfig.storage });
         const mappedHosts = relativeRun.config.mappings.map((m) => m.host);
-        t.check(mappedHosts.includes(t.at('rel-folder')), 'relative mappings in the user config resolve against the config file\'s folder', 'mapped hosts: ' + JSON.stringify(mappedHosts));
+        t.check(mappedHosts.includes(t.at('rel-folder')), "relative mappings in the user config resolve against the config file's folder", 'mapped hosts: ' + JSON.stringify(mappedHosts));
         t.section('config.example.json');
         const examplePath = path.join(t.packageRoot, 'config.example.json');
         t.equal(loadConfig(examplePath).config.defaultHarness, 'claude', 'config.example.json is valid');
         const example = _.omit(readJsonc(examplePath), '$schema');
-        t.check(_.isEqual(example, DEFAULTS), 'config.example.json lists exactly the built-in defaults', 'the differences are in: ' + Object.keys(DEFAULTS).filter((key) => !_.isEqual(example[key], DEFAULTS[key])).join(', '));
+        t.check(_.isEqual(example, DEFAULTS), 'config.example.json lists exactly the built-in defaults', 'the differences are in: ' +
+            Object.keys(DEFAULTS)
+                .filter((key) => !_.isEqual(example[key], DEFAULTS[key]))
+                .join(', '));
     },
 };

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

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

package/dist/selftest/data.test.js

@@ -6,7 +6,7 @@ import { resolveCleanTargets } from '../cli/commands/data/clean.js';
 import { removeTree } from '../cli/commands/data/remove.js';
 import { findLinks } from '../cli/commands/repair/finders.js';
 import { humanBytes, sizeOf } from '../core/disk.js';
-import { pruneStorage } from '../host/cleanup.js';
+import { pruneStorage } from '../host/storage/index.js';
 export const dataSuite = {
     name: 'data',
     title: 'data clean targets, sizes and removal with links, storage cleanup',
@@ -21,13 +21,33 @@ export const dataSuite = {
         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('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');
-        const badTargets = ['', '..', 'tools/..', 'tools/../../x', '../data', 'C:\\Windows', 'C:tools', '/etc', '\\\\server\\share', 'tools/*', 'tools/go:stream', 'tools/a/b', 'tools/agents/a/b', 'logs/guest.log', 'accounts', 'sync', 'windows', 'tools/.', 'tools/go.'];
+        const badTargets = [
+            '',
+            '..',
+            'tools/..',
+            'tools/../../x',
+            '../data',
+            'C:\\Windows',
+            'C:tools',
+            '/etc',
+            '\\\\server\\share',
+            'tools/*',
+            'tools/go:stream',
+            'tools/a/b',
+            'tools/agents/a/b',
+            'logs/guest.log',
+            'accounts',
+            'sync',
+            'windows',
+            'tools/.',
+            'tools/go.',
+        ];
         const accepted = badTargets.filter((target) => {
             try {
                 resolveCleanTargets([target], dataPath, storage);
@@ -50,7 +70,9 @@ export const dataSuite = {
             fs.symlinkSync(outside, path.join(sized, 'sub', 'escape'), 'junction');
             linked = true;
         }
-        catch { /* no junctions here */ }
+        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');
         if (linked)
@@ -60,8 +82,15 @@ export const dataSuite = {
         t.check(fs.existsSync(path.join(outside, 'keep.txt')), 'removing a folder never deletes what a link inside points to');
         t.section('storage cleanup');
         const store = t.at('prune');
-        const aged = (p, days) => { const d = new Date(Date.now() - days * 86400000); fs.utimesSync(p, d, d); };
-        for (const [name, days] of [['old', 9], ['kept', 30], ['new', 1]]) {
+        const aged = (p, days) => {
+            const d = new Date(Date.now() - days * 86400000);
+            fs.utimesSync(p, d, d);
+        };
+        for (const [name, days] of [
+            ['old', 9],
+            ['kept', 30],
+            ['new', 1],
+        ]) {
             aged(t.write(path.join(store, 'launches', name, 'agent.wsb'), 'x'), days);
             aged(path.join(store, 'launches', name), days);
         }

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

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

package/dist/selftest/detect.test.js

@@ -1,8 +1,8 @@
 // "What does this project need?": databases and toolchains detected from project files, and the plans built from them.
-import { databasesFromServices, detectDatabases } from '../core/detect-databases.js';
-import { DEFAULTS } from '../core/config.js';
-import { databaseCatalog, planDatabases } from '../host/database-plan.js';
-import { decideToolchains, resolveToolchains } from '../core/detect-toolchains.js';
+import { databasesFromServices, detectDatabases } from '../core/detect/index.js';
+import { DEFAULTS } from '../core/config/index.js';
+import { databaseCatalog, planDatabases } from '../host/launch/index.js';
+import { decideToolchains, resolveToolchains } from '../core/detect/index.js';
 const found = (files, host = []) => detectDatabases(files, host).map((d) => d.database);
 const file = (path, text) => ({ path, text });
 export const detectSuite = {
@@ -16,10 +16,16 @@ export const detectSuite = {
         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('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([
+            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');
         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');
@@ -35,10 +41,17 @@ export const detectSuite = {
         const took = Date.now() - started;
         t.check(took < 2000, 'database detection stays fast on hostile workspace files (no catastrophic backtracking)', 'took ' + took + ' ms');
         t.section('the database plan');
-        const plan = planDatabases({ ...DEFAULTS.databases, mongodb: { ...DEFAULTS.databases.mongodb, enabled: true }, redis: { ...DEFAULTS.databases.redis, enabled: false } }, 'unused', { files: [compose], host: [] });
+        const plan = planDatabases({
+            ...DEFAULTS.databases,
+            mongodb: { ...DEFAULTS.databases.mongodb, enabled: true },
+            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 } });
+        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.section('toolchains from project files');

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

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

package/dist/selftest/generate.test.js

@@ -2,10 +2,8 @@
 // session.json, the staged Claude profile, and the values read from this PC (git identity, free RAM).
 import fs from 'node:fs';
 import path from 'node:path';
-import { LocalOverrides } from '../core/schema.js';
-import { logonEnv } from '../host/generate.js';
-import { gitIdentity } from '../host/launch/stage.js';
-import { buildWsb, resolveMemoryMb } from '../host/launch/wsb.js';
+import { LocalOverridesSchema } from '../core/schema/index.js';
+import { buildWsb, gitIdentity, logonEnv, resolveMemoryMb } from '../host/launch/index.js';
 export const generateSuite = {
     name: 'generate',
     title: 'generated .wsb, launch folder and session.json',
@@ -15,14 +13,31 @@ export const generateSuite = {
         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.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.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 = ['package.json', 'runtime/main.js', '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'];
+        const expectedFiles = [
+            'package.json',
+            'runtime/main.js',
+            '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',
+        ];
         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');
@@ -44,11 +59,20 @@ export const generateSuite = {
             nvmFromHost: Boolean(session.hostTools.nvm),
             nodeSpec: session.versions.node.spec,
             gitAccess: session.provisioning.git.access,
-        }, { launchId: true, workspace: 'C:\\Workspace\\work-a', workspaceHost: f.workA, firstArgument: '--version', gitFromHost: true, nvmFromHost: true, nodeSpec: '22.3.0', gitAccess: 'full' }, 'session.json carries the id, paths, agent arguments, host tools, versions and git access');
+        }, {
+            launchId: true,
+            workspace: 'C:\\Workspace\\work-a',
+            workspaceHost: f.workA,
+            firstArgument: '--version',
+            gitFromHost: true,
+            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)');
-        t.check(!LocalOverrides.safeParse({ sandbox: { cpuLimit: 'none' } }).success, "a project's .sandbox-config.json cannot lift your CPU cap (sandbox.cpuLimit is yours only)");
+        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)));

package/dist/selftest/git-access.test.d.ts

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

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

@@ -1,15 +1,53 @@
 // Git access modes ("full", "readonly", "none"): which git commands the guard allows and the matching Claude deny rules.
-import { gitDecision } from '../guest/gitguard.js';
-import { gitDenyRules } from '../guest/gitrules.js';
+import { gitDecision } from '../guest/git/decision.js';
+import { gitDenyRules } from '../guest/setup/git-rules.js';
 export const gitAccessSuite = {
     name: 'git-access',
     title: 'git access modes and Claude deny rules',
     run: (t) => {
         t.section('readonly');
         const allowed = (args, mode = 'readonly') => gitDecision(args, mode).allow;
-        const reading = ['status', 'log --oneline', 'diff HEAD~1', 'show HEAD', 'blame a.ts', 'branch', 'branch -a', 'branch --contains HEAD', 'tag', 'tag -l v*', 'remote -v', 'config --get user.name', 'stash list', '-C sub status', '--no-pager log'];
+        const reading = [
+            'status',
+            'log --oneline',
+            'diff HEAD~1',
+            'show HEAD',
+            'blame a.ts',
+            'branch',
+            'branch -a',
+            'branch --contains HEAD',
+            'tag',
+            'tag -l v*',
+            'remote -v',
+            'config --get user.name',
+            'stash list',
+            '-C sub status',
+            '--no-pager log',
+        ];
         t.equal(reading.filter((command) => !allowed(command.split(' '))), [], 'readonly: reading commands are allowed');
-        const writing = ['commit -m x', 'push', 'add .', 'checkout main', 'switch -c x', 'reset --hard', 'stash', 'stash pop', 'branch new', 'branch -D x', 'tag v1', 'merge x', 'rebase main', 'fetch', 'pull', 'config user.name x', 'remote add o u', '-c core.hooksPath=x status', '--git-dir=x status', 'clean -fd', 'apply p.diff'];
+        const writing = [
+            'commit -m x',
+            'push',
+            'add .',
+            'checkout main',
+            'switch -c x',
+            'reset --hard',
+            'stash',
+            'stash pop',
+            'branch new',
+            'branch -D x',
+            'tag v1',
+            'merge x',
+            'rebase main',
+            'fetch',
+            'pull',
+            'config user.name x',
+            'remote add o u',
+            '-c core.hooksPath=x status',
+            '--git-dir=x status',
+            'clean -fd',
+            'apply p.diff',
+        ];
         t.equal(writing.filter((command) => allowed(command.split(' '))), [], 'readonly: anything that writes (or overrides config) is refused');
         t.section('none and full');
         t.check(!allowed(['status'], 'none') && !allowed(['--version'], 'none'), 'none: every git call is refused');

package/dist/selftest/guest-boot.test.d.ts

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

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

@@ -2,7 +2,7 @@
 // what it copies in, and what it refuses to.
 import fs from 'node:fs';
 import path from 'node:path';
-import { readJsonFile } from '../shared/rundir.js';
+import { readJsonFile } from '../shared/io/index.js';
 export const guestBootSuite = {
     name: 'guest-boot',
     title: 'guest boot in dry-run mode (provisioning, Claude state, git policy)',
@@ -15,7 +15,16 @@ export const guestBootSuite = {
         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 ['would provision nvm and Node 22.3.0 (from this PC)', 'would provision Python 3', 'would provision MinGW-w64 GCC', 'would provision Rust', '.NET SDK', 'would provision bun', 'would provision uv', 'would provision Git for Windows from this PC']) {
+        for (const step of [
+            'would provision nvm and Node 22.3.0 (from this PC)',
+            'would provision Python 3',
+            'would provision MinGW-w64 GCC',
+            'would provision Rust',
+            '.NET SDK',
+            '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...');
@@ -23,7 +32,7 @@ export const guestBootSuite = {
         t.equal(readJsonFile(path.join(data1, 'run', 'sandbox.json'))?.phase, 'ready', 'the guest reports "ready" in run/sandbox.json');
         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.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');
@@ -34,13 +43,20 @@ export const guestBootSuite = {
         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.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.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({ ...guestState, oauthAccount: { emailAddress: 'sandbox@x' }, mcpServers: { local: { command: 'x' } } }));
-        t.writeJson(path.join(gen.launchPath, 'claude-profile', '.claude.json'), { mcpServers: { github: { command: 'npx2' } }, projects: { [f.workA.replace(/\\/g, '/')]: { mcpServers: { db: { command: 'pg' } } } } });
+        fs.writeFileSync(path.join(claudeState, '.claude.json'), JSON.stringify({
+            ...guestState,
+            oauthAccount: { emailAddress: 'sandbox@x' },
+            mcpServers: { local: { command: 'x' } },
+        }));
+        t.writeJson(path.join(gen.launchPath, 'claude-profile', '.claude.json'), {
+            mcpServers: { github: { command: 'npx2' } },
+            projects: { [f.workA.replace(/\\/g, '/')]: { mcpServers: { db: { command: 'pg' } } } },
+        });
         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');
@@ -63,7 +79,9 @@ export const guestBootSuite = {
         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');
         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') });
+        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');

package/dist/selftest/host-sim.test.d.ts

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

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

@@ -7,7 +7,22 @@
 // (every one is a fresh Node process, which is what makes this the slowest suite when run one by one).
 import fs from 'node:fs';
 import path from 'node:path';
-const SANDBOX_ONLY_VARS = ['CLAUDE_CONFIG_DIR', 'CODEX_HOME', 'GEMINI_CLI_HOME', 'AGENT_WORKSPACE', 'AGENT_DATA', 'AGENT_TOOLS', 'AGENT_PROJECT', 'NVM_HOME', 'NVM_SYMLINK', 'BASH_ENV', 'CLAUDE_CODE_GIT_BASH_PATH', 'AGENT_GIT_ACCESS', 'AGENT_REAL_GIT', 'AGENT_SANDBOX_CONFIG'];
+const SANDBOX_ONLY_VARS = [
+    'CLAUDE_CONFIG_DIR',
+    'CODEX_HOME',
+    'GEMINI_CLI_HOME',
+    'AGENT_WORKSPACE',
+    'AGENT_DATA',
+    'AGENT_TOOLS',
+    'AGENT_PROJECT',
+    'NVM_HOME',
+    'NVM_SYMLINK',
+    'BASH_ENV',
+    'CLAUDE_CODE_GIT_BASH_PATH',
+    'AGENT_GIT_ACCESS',
+    'AGENT_REAL_GIT',
+    'AGENT_SANDBOX_CONFIG',
+];
 const PARALLEL = 2;
 const sandbox = (label, ...args) => ({ bin: 'agent-sandbox', label, args, config: true });
 const COMMANDS = [
@@ -61,7 +76,11 @@ export const hostSimSuite = {
         const freshPc = (name) => {
             const home = t.dir('host-sim', name, 'home');
             const storage = t.dir('host-sim', name, 'storage');
-            const config = t.writeJson(t.at('host-sim', name, 'config.json'), { storage: { root: storage }, personalization: { enabled: false }, provisioning: { terminal: { enabled: false } } });
+            const config = t.writeJson(t.at('host-sim', name, 'config.json'), {
+                storage: { root: storage },
+                personalization: { enabled: false },
+                provisioning: { terminal: { enabled: false } },
+            });
             return { home, config };
         };
         const broken = [];
@@ -71,7 +90,12 @@ export const hostSimSuite = {
             const crashed = r.status === null || r.status > 1 || /Unexpected error|node:internal|^\s+at .+:\d+:\d+\)?$/m.test(r.out);
             const unexplained = r.status === 1 && !/(^|\n)(Error: |error: )/.test(r.out) && command.bin !== 'claude-host';
             if (crashed || unexplained)
-                broken.push(command.label + ' (exit ' + r.status + (r.timedOut ? ', timed out' : '') + '): ' + r.out.trim().split('\n').slice(0, 4).join(' | '));
+                broken.push(command.label +
+                    ' (exit ' +
+                    r.status +
+                    (r.timedOut ? ', timed out' : '') +
+                    '): ' +
+                    r.out.trim().split('\n').slice(0, 4).join(' | '));
         };
         // `config init` twice must see the same home (the second run finds the files the first one made).
         const initPc = freshPc('init');

package/dist/selftest/hostile-input.test.d.ts

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

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

@@ -3,12 +3,12 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { assertCmdSafePath } from '../host/platform.js';
+import { assertCmdSafePath } from '../host/sandbox/index.js';
 import { assertSafeMapping } from '../core/safe-paths.js';
-import { safeText } from '../core/util.js';
-import { isSafeFileName } from '../shared/paths.js';
-import { removeRefusal, safeRemove } from '../shared/safe-remove.js';
-import { writeJsonAtomic } from '../shared/rundir.js';
+import { safeText } from '../core/util/index.js';
+import { isSafeFileName } from '../shared/paths/index.js';
+import { removeRefusal, safeRemove } from '../shared/io/index.js';
+import { writeJsonAtomic } from '../shared/io/index.js';
 export const hostileInputSuite = {
     name: 'hostile-input',
     title: 'file names, deletes, printed text, mappings and state files from an untrusted sandbox',

package/dist/selftest/index.d.ts

@@ -1,4 +1,4 @@
-import type { Suite } from './suite.js';
+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. */

package/dist/selftest/index.js

@@ -6,10 +6,10 @@
 // comma-separated list) to run only those: `sandbox self-test config`, `npm test -- live-daemon`.
 import os from 'node:os';
 import path from 'node:path';
-import { errMsg } from '../core/util.js';
-import { createFixtures } from './fixtures.js';
-import { createHarness } from './harness.js';
-import { liveTestsAvailable } from './live.js';
+import { errMsg } from '../core/util/index.js';
+import { createFixtures } from './support/fixtures.js';
+import { createHarness } from './support/harness.js';
+import { liveTestsAvailable } from './support/live.js';
 import { accountsSuite } from './accounts.test.js';
 import { agentCommandsSuite } from './agent-commands.test.js';
 import { channelSuite } from './channel.test.js';
@@ -42,29 +42,61 @@ import { toolchainsSuite } from './toolchains.test.js';
 import { workspaceSuite } from './workspace.test.js';
 import { workspaceViewSuite } from './workspace-view.test.js';
 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';
 /** 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, workspaceSuite, localConfigSuite,
+    configSuite,
+    workspaceSuite,
+    localConfigSuite,
     // the generated sandbox and the guest that boots it
-    generateSuite, guestBootSuite, mirrorSuite, projectsSuite,
+    generateSuite,
+    guestBootSuite,
+    mirrorSuite,
+    projectsSuite,
     // syncing with this PC
-    syncSuite, accountsSuite, workspaceViewSuite, auditSuite,
+    syncSuite,
+    accountsSuite,
+    workspaceViewSuite,
+    auditSuite,
     // an untrusted sandbox: what the host refuses to do with what it finds
-    linksSuite, channelSuite, gitAccessSuite, repoGuardSuite, secretsSuite, hostileInputSuite, testGuardSuite,
+    linksSuite,
+    channelSuite,
+    gitAccessSuite,
+    repoGuardSuite,
+    secretsSuite,
+    hostileInputSuite,
+    testGuardSuite,
     // pure helpers and the command line
-    toolchainsSuite, detectSuite, networkSuite, personalizationSuite, cmdlineSuite, setupSuite, dataSuite, repairSuite, cliSuite, agentCommandsSuite,
+    layoutSuite,
+    toolchainsSuite,
+    detectSuite,
+    networkSuite,
+    personalizationSuite,
+    cmdlineSuite,
+    setupSuite,
+    dataSuite,
+    repairSuite,
+    cliSuite,
+    agentCommandsSuite,
     // every command as its own process
     hostSimSuite,
     // real processes
-    liveDaemonSuite, liveProjectsSuite, liveGitSuite, liveNetworkSuite,
+    liveDaemonSuite,
+    liveProjectsSuite,
+    liveGitSuite,
+    liveNetworkSuite,
+    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';
 const withDeadline = async (work, ms, what) => {
     let timer;
-    const deadline = new Promise((_, reject) => { timer = setTimeout(() => reject(new Error(what + ' did not finish within ' + Math.round(ms / 1000) + ' s')), ms); });
+    const deadline = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(what + ' did not finish within ' + Math.round(ms / 1000) + ' s')), ms);
+    });
     try {
         return await Promise.race([work, deadline]);
     }
@@ -90,21 +122,46 @@ const runSuite = async (suite, t, f) => {
             t.check(false, 'suite "' + suite.name + '" stopped with an unexpected error', errMsg(e) + (e instanceof Error && e.stack ? '\n' + e.stack : ''));
         }
     }
-    return { suite, checks: t.checks() - checksBefore, failed: t.failures() - failedBefore, seconds: (Date.now() - started) / 1000, note };
+    return {
+        suite,
+        checks: t.checks() - checksBefore,
+        failed: t.failures() - failedBefore,
+        seconds: (Date.now() - started) / 1000,
+        note,
+    };
 };
 const printSummary = (results) => {
     const width = Math.max(...results.map((r) => r.suite.name.length));
     console.log('\n\x1b[36m-- summary\x1b[0m');
     for (const r of results) {
         const state = r.note ?? (r.failed ? r.failed + ' FAILED' : 'ok');
-        console.log('  ' + r.suite.name.padEnd(width) + '  ' + String(r.checks).padStart(4) + ' checks  ' + r.seconds.toFixed(1).padStart(6) + ' s  ' + state);
+        console.log('  ' +
+            r.suite.name.padEnd(width) +
+            '  ' +
+            String(r.checks).padStart(4) +
+            ' checks  ' +
+            r.seconds.toFixed(1).padStart(6) +
+            ' s  ' +
+            state);
     }
     const total = results.reduce((sum, r) => sum + r.checks, 0);
-    console.log('  ' + 'total'.padEnd(width) + '  ' + String(total).padStart(4) + ' checks  ' + results.reduce((sum, r) => sum + r.seconds, 0).toFixed(1).padStart(6) + ' s');
+    console.log('  ' +
+        'total'.padEnd(width) +
+        '  ' +
+        String(total).padStart(4) +
+        ' checks  ' +
+        results
+            .reduce((sum, r) => sum + r.seconds, 0)
+            .toFixed(1)
+            .padStart(6) +
+        ' s');
 };
 /** Resolves "a,b" / ["a", "b"] to suites; throws with the list of valid names for an unknown one. */
 export const pickSuites = (names) => {
-    const wanted = names.flatMap((n) => n.split(',')).map((n) => n.trim()).filter(Boolean);
+    const wanted = names
+        .flatMap((n) => n.split(','))
+        .map((n) => n.trim())
+        .filter(Boolean);
     if (wanted.length === 0)
         return SUITES;
     const unknown = wanted.filter((name) => !SUITES.some((s) => s.name === name));
@@ -114,7 +171,7 @@ export const pickSuites = (names) => {
 };
 export const selfTest = async (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.');
+        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;
     }
     let chosen;