windows-development-sandbox 1.4.3 → 1.5.0

package/dist/selftest/accounts.test.js

@@ -19,18 +19,18 @@ export const accountsSuite = {
             claudeDir: t.at('host-login'),
             globalStateFile: t.at('host-login.json'),
         });
-        t.equal(new AccountStore(storage).list(dataA).length, 2, 'accounts can be saved from the sandbox and from this PC');
-        t.equal(new AccountStore(storage).defaultName(), 'personal', 'the first account saved becomes the default');
-        t.equal(new AccountStore(storage).activeFor(dataA), 'personal', 'the first account saved is the active one');
-        t.check(!fs.existsSync(path.join(sandboxClaude, '.agent-sandbox-account')), 'which account is active is not recorded inside the sandbox...');
-        t.check(fs.existsSync(path.join(storage, 'accounts', 'index.json')), '... it is recorded host-side');
+        t.check(new AccountStore(storage).list(dataA).length === 2 &&
+            new AccountStore(storage).defaultName() === 'personal' &&
+            new AccountStore(storage).activeFor(dataA) === 'personal', 'accounts can be saved from the sandbox and from this PC; the first one saved is the default and active');
+        t.check(!fs.existsSync(path.join(sandboxClaude, '.agent-sandbox-account')) &&
+            fs.existsSync(path.join(storage, 'accounts', 'index.json')), 'which account is active is recorded host-side, not inside the sandbox');
         t.write(path.join(sandboxClaude, '.credentials.json'), '{"claudeAiOauth":{"refreshToken":"personal-2"}}');
         new AccountStore(storage).activate(dataA, 'work');
         const stateAfter = f.readJson(path.join(sandboxClaude, '.claude.json'));
-        t.includes(fs.readFileSync(path.join(sandboxClaude, '.credentials.json'), 'utf8'), 'work-1', "switching swaps in the other account's credentials");
-        t.equal(stateAfter.oauthAccount.emailAddress, 'me@work', 'switching swaps the signed-in account');
-        t.equal(stateAfter.other, 1, 'switching keeps the rest of the sandbox state');
-        t.equal(new AccountStore(storage).activeFor(dataA), 'work', 'the new account is active');
+        t.check(fs.readFileSync(path.join(sandboxClaude, '.credentials.json'), 'utf8').includes('work-1') &&
+            stateAfter.oauthAccount.emailAddress === 'me@work' &&
+            stateAfter.other === 1 &&
+            new AccountStore(storage).activeFor(dataA) === 'work', 'switching swaps in the other credentials and account, keeps the rest of the sandbox state, and marks it active');
         t.includes(JSON.stringify(new AccountStore(storage).read('personal')?.credentials), 'personal-2', "the outgoing account's refreshed tokens are saved back before switching");
         t.section('removing and refusing');
         new AccountStore(storage).setDefault('work');

package/dist/selftest/agent-commands.test.js

@@ -21,8 +21,8 @@ export const agentCommandsSuite = {
         const PATH = [commandsDir(storage), npmDir, localBin].join(path.delimiter);
         const on = { ...DEFAULTS, agentCommands: { enabled: true, agents: 'auto' } };
         t.section('finding agents');
-        t.equal(realAgent('claude', commandsDir(storage), PATH), path.join(localBin, 'claude.exe'), "the real agent is found on PATH, skipping this tool's own forwarding files");
-        t.equal(realAgent('nope', commandsDir(storage), PATH), null, 'an agent that is not installed is not found');
+        t.check(realAgent('claude', commandsDir(storage), PATH) === path.join(localBin, 'claude.exe') &&
+            realAgent('nope', commandsDir(storage), PATH) === null, "the real agent is found on PATH, skipping this tool's own forwarding files; one not installed is not found");
         const commandsOf = (config, searchPath) => agentCommands(config, storage, searchPath)
             .map((a) => a.command)
             .sort();
@@ -34,13 +34,13 @@ export const agentCommandsSuite = {
         t.section('the forwarding files');
         const claude = { harness: 'claude', command: 'claude', real: path.join(localBin, 'claude.exe') };
         const cmd = forwardingCmd(claude, 'C:\\node\\node.exe', 'C:\\tool\\dist\\bin\\sandbox.js');
-        t.includes(cmd, '"C:\\node\\node.exe" "C:\\tool\\dist\\bin\\sandbox.js" launch --harness claude --headless --terminal -- %*', 'the .cmd starts the agent in a hidden sandbox attached to this terminal...');
-        t.includes(cmd, 'if "%SANDBOX_AGENT_DIRECT%"=="1" goto direct', '... unless SANDBOX_AGENT_DIRECT=1...');
-        t.includes(cmd, 'call "' + claude.real + '" %*', '... which runs the real agent');
+        t.check(cmd.includes('"C:\\node\\node.exe" "C:\\tool\\dist\\bin\\sandbox.js" launch --harness claude --headless --terminal -- %*') &&
+            cmd.includes('if "%SANDBOX_AGENT_DIRECT%"=="1" goto direct') &&
+            cmd.includes('call "' + claude.real + '" %*'), 'the .cmd starts the agent in a hidden sandbox attached to this terminal, unless SANDBOX_AGENT_DIRECT=1 (real agent)');
         const sh = forwardingSh({ ...claude, real: "C:\\Users\\me\\it's\\claude.exe" }, 'C:\\node\\node.exe', 'C:\\tool\\sandbox.js');
-        t.check(sh.startsWith('#!/bin/sh'), 'Git Bash gets a shell script');
-        t.includes(sh, "exec '/c/node/node.exe' '/c/tool/sandbox.js' launch --harness claude --headless --terminal -- \"$@\"", 'the shell script starts the same sandbox, with POSIX paths');
-        t.includes(sh, "'/c/Users/me/it'\\''s/claude.exe'", 'the shell script quotes awkward paths safely');
+        t.check(sh.startsWith('#!/bin/sh') &&
+            sh.includes("exec '/c/node/node.exe' '/c/tool/sandbox.js' launch --harness claude --headless --terminal -- \"$@\"") &&
+            sh.includes("'/c/Users/me/it'\\''s/claude.exe'"), 'Git Bash gets a shell script with POSIX paths, quoted safely');
         t.section('off changes nothing');
         // Off with nothing set up: nothing to do, no PATH edit (which would be refused during the self-test anyway).
         const fresh = t.at('agent-cmd-fresh');

package/dist/selftest/channel.test.js

@@ -12,10 +12,10 @@ export const channelSuite = {
         const validRequest = (r) => GuestRequestSchema.safeParse(r).success;
         const validSession = (s) => SessionStatusSchema.safeParse(s).success;
         await t.throws(() => safeId('../evil'), 'invalid id', 'a path-like id is rejected');
-        t.check(!validRequest({ kind: 'shell', id: 'a' }), 'unknown request kinds are rejected');
-        t.check(!validRequest({ kind: 'exec', id: 'a/b', command: ['x'], cwd: 'C:\\', timeoutSeconds: 1 }), 'request ids must be safe file names');
-        t.check(validRequest({ kind: 'ping', id: 'abc', createdAt: 'x' }), 'a known request kind with a safe id is accepted');
-        t.check(!validRequest({ kind: 'ping', id: 'abc', createdAt: 'x', extra: 1 }), 'requests with unknown keys are rejected');
+        t.check(validRequest({ kind: 'ping', id: 'abc', createdAt: 'x' }) &&
+            !validRequest({ kind: 'shell', id: 'a' }) &&
+            !validRequest({ kind: 'exec', id: 'a/b', command: ['x'], cwd: 'C:\\', timeoutSeconds: 1 }) &&
+            !validRequest({ kind: 'ping', id: 'abc', createdAt: 'x', extra: 1 }), 'requests: known kinds with safe ids pass; unknown kinds, path-like ids and unknown keys are rejected');
         const goodSession = {
             id: 's1',
             launchId: 'l',
@@ -27,9 +27,9 @@ export const channelSuite = {
             startedAt: 'x',
             attach: { addresses: ['172.20.1.5'], port: 5000, token: 't' },
         };
-        t.check(validSession(goodSession), 'a well-formed session status is accepted');
-        t.check(!validSession({ ...goodSession, attach: { ...goodSession.attach, port: 70000 } }), 'a session status with an impossible port is rejected');
-        t.check(!validSession({ ...goodSession, phase: 'pwned' }), 'a session status with an unknown phase is rejected');
+        t.check(validSession(goodSession) &&
+            !validSession({ ...goodSession, attach: { ...goodSession.attach, port: 70000 } }) &&
+            !validSession({ ...goodSession, phase: 'pwned' }), 'session status: a well-formed one passes; an impossible port or unknown phase is rejected');
         t.section('boot progress');
         const goodStatus = {
             launchId: 'l1',
@@ -49,14 +49,14 @@ export const channelSuite = {
             total: 6,
         };
         const parsed = (s) => SandboxStatusSchema.safeParse(s);
-        t.equal(parsed({ ...goodStatus, progress }).data?.progress, progress, 'a well-formed boot progress is accepted');
-        t.check(parsed(goodStatus).success && parsed(goodStatus).data?.progress === undefined, 'a status without progress (an older sandbox) is accepted');
+        t.check(JSON.stringify(parsed({ ...goodStatus, progress }).data?.progress) === JSON.stringify(progress) &&
+            parsed(goodStatus).success &&
+            !parsed({ ...goodStatus, phase: 'pwned', progress }).success, 'a well-formed boot progress is accepted (also none, from an older sandbox); an unknown phase is rejected');
         const hostile = [
             { ...progress, title: 'x'.repeat(5000) },
             { ...progress, active: Array.from({ length: 100 }, () => ({ name: 'a' })) },
             { ...progress, active: [{ name: 'a', percent: 500 }] },
             { ...progress, step: -1 },
-            { ...progress, done: 1e9 },
             { ...progress, extra: 1 },
             'pwned',
         ];
@@ -64,50 +64,55 @@ export const channelSuite = {
             const r = parsed({ ...goodStatus, progress: p });
             return r.success && r.data.progress === undefined;
         }), hostile.map(() => true), 'an oversized or malformed progress is dropped, the status itself still counts');
-        t.check(!parsed({ ...goodStatus, phase: 'pwned', progress }).success, 'a status with an unknown phase is still rejected');
         const line = (p) => bootLine(parsed({ ...goodStatus, progress: p }).data ?? null).line;
-        t.equal(line(progress), '[3/8] Developer tools: downloading Rust 40%; setting up Go (2 of 6 done)', 'the line shows the step, the download and what is set up');
-        t.equal(line({ ...progress, title: 'Agent: claude', step: 6, active: [], done: 0, total: 0 }), '[6/8] Agent: claude', 'a step without tools is just its title');
-        t.equal(line({ ...progress, active: [{ name: '\x1b]52;c;ZXZpbA==\x07Ru\x1b[2Jst\r\n', percent: 99 }] }), '[3/8] Developer tools: downloading Rust 99% (2 of 6 done)', 'escape sequences and control characters from the sandbox never reach the terminal');
-        t.equal(bootLine(null).line, 'Starting Windows Sandbox', 'before the sandbox writes anything');
-        t.equal(bootLine(parsed({ ...goodStatus, message: 'Installing Go (1 of 3 done)' }).data).line, 'Installing Go (1 of 3 done)', 'an older sandbox: its message');
-        t.equal(bootLine(parsed({ ...goodStatus, progress: { ...progress, active: [{ name: 'Rust', percent: 50 }] } }).data).key, bootLine(parsed({ ...goodStatus, progress: { ...progress, active: [{ name: 'Rust', percent: 60 }] } }).data).key, 'a download moving on is no new plain line (only a new step or tool is)');
-        t.equal(stillWorking('Rust', 3 * 60 * 1000), 'Still working on Rust (3 min). Full log: sandbox logs -f', 'the notice after a long quiet spell');
-        t.equal(readyIn(432_000), 'Ready in 7 min 12 s.', 'the time a first start took');
+        t.equal([
+            line(progress),
+            line({ ...progress, title: 'Agent: claude', step: 6, active: [], done: 0, total: 0 }),
+            line({ ...progress, active: [{ name: '\x1b]52;c;ZXZpbA==\x07Ru\x1b[2Jst\r\n', percent: 99 }] }),
+            bootLine(null).line,
+        ], [
+            '[3/8] Developer tools: downloading Rust 40%; setting up Go (2 of 6 done)',
+            '[6/8] Agent: claude',
+            '[3/8] Developer tools: downloading Rust 99% (2 of 6 done)',
+            'Starting Windows Sandbox',
+        ], 'the boot line shows step, download and setup; escape sequences and control characters from the sandbox never reach the terminal');
+        t.equal([
+            bootLine(parsed({ ...goodStatus, progress: { ...progress, active: [{ name: 'Rust', percent: 50 }] } }).data)
+                .key,
+            stillWorking('Rust', 3 * 60 * 1000),
+            readyIn(432_000),
+        ], [
+            bootLine(parsed({ ...goodStatus, progress: { ...progress, active: [{ name: 'Rust', percent: 60 }] } }).data)
+                .key,
+            'Still working on Rust (3 min). Full log: sandbox logs -f',
+            'Ready in 7 min 12 s.',
+        ], 'a download moving on is no new plain line; the quiet-spell notice and ready time read well');
         const pending = pendingDownloads(['node', 'rust', 'cpp', 'postgres', 'node', 'constructor'], (dir) => dir === 'nvm');
-        t.equal(pending, { names: ['rust', 'C/C++', 'PostgreSQL'], mb: 900 }, 'only what is not downloaded yet counts, once each');
-        t.equal(firstStartNotice(false, { names: [], mb: 0 }), null, 'a later start with everything downloaded says nothing');
-        t.check(/^First start: .*\(about 900 MB: rust, C\/C\+\+, PostgreSQL\)\. This can take 5-20 minutes/.test(firstStartNotice(true, pending) ?? ''), 'the first start says what it downloads, roughly how much, and how long it can take');
-        t.check(/^New tools for this project: .*about 1\.8 GB: MSVC, rust/.test(firstStartNotice(false, pendingDownloads(['msvc', 'rust'], () => false)) ?? ''), 'a new toolchain later on gets its own heads-up');
+        t.check(JSON.stringify(pending) === JSON.stringify({ names: ['rust', 'C/C++', 'PostgreSQL'], mb: 900 }) &&
+            firstStartNotice(false, { names: [], mb: 0 }) === null &&
+            /^First start: .*\(about 900 MB: rust, C\/C\+\+, PostgreSQL\)\. This can take 5-20 minutes/.test(firstStartNotice(true, pending) ?? ''), 'only what is not downloaded yet counts, once each; the first start says what and how much, a later one says nothing');
         t.section('terminal frames');
-        const filter = new OutputFilter();
-        const filtered = Buffer.concat([
-            filter.push(Buffer.from('a\x1b]52;c;ZXZpbA==\x07b\x1b]0;title\x07')),
-            filter.push(Buffer.from('c\x1b]5')),
-            filter.push(Buffer.from('2;c;cGF5\x1b\\d')),
-        ]).toString('latin1');
-        t.equal(filtered, 'a' + 'b\x1b]0;title\x07' + 'c' + 'd', 'clipboard writes (OSC 52) from the sandbox are stripped, even split across chunks; titles pass');
         const through = (...chunks) => {
             const f = new OutputFilter();
             return Buffer.concat(chunks.map((s) => f.push(Buffer.from(s, 'latin1')))).toString('latin1');
         };
-        t.equal(through('x\x1b]52;c;QUFB\x1b', '\\y'), 'xy', 'an OSC 52 whose terminator is split between chunks is still stripped');
-        t.equal(through('x\x1b]052;c;QUFB\x07y'), 'xy', 'OSC 052 (leading zero) is stripped too');
-        t.equal(through('x\x1b]52;c;' + 'A'.repeat(70000), 'B'.repeat(100), '\x07y'), 'xy', 'a huge OSC 52 stays stripped across chunks');
-        t.equal(through('x\xc2\x9d52;c;QUFB\xc2\x9cy\x1bP1$qm\x1b\\z'), 'xyz', 'C1 (UTF-8) OSC and DCS strings are stripped');
-        t.equal(through('\x1b]8;;https://a.b\x1b\\link\x1b]8;;\x1b\\ \x1b[31mred\x1b[0m é\xc2\xa0'), '\x1b]8;;https://a.b\x1b\\link\x1b]8;;\x1b\\ \x1b[31mred\x1b[0m é\xc2\xa0', 'links, colours and ordinary UTF-8 (incl. U+00A0) pass unchanged');
-        t.equal(through('\x1b]9;9;macro\x07\x1b]9;4;1;50\x07'), '\x1b]9;4;1;50\x07', 'only the progress form of OSC 9 passes (ConEmu macros do not)');
-        const oversizedHeader = Buffer.concat([Buffer.from([16]), Buffer.from([0, 0, 0, 0x7f])]);
-        await t.throws(() => new FrameReader().push(oversizedHeader), 'frame too large', 'a frame announcing too much data is rejected instead of buffered');
-        t.equal(new FrameReader().push(encodeFrame(16, Buffer.alloc(MAX_FRAME_BYTES))).length, 1, 'a frame of exactly the maximum size is accepted');
+        t.equal([
+            through('a\x1b]52;c;ZXZpbA==\x07b\x1b]0;title\x07', 'c\x1b]5', '2;c;cGF5\x1b\\d'),
+            through('x\x1b]52;c;QUFB\x1b', '\\y'),
+            through('x\x1b]052;c;QUFB\x07y'),
+            through('x\x1b]52;c;' + 'A'.repeat(70000), 'B'.repeat(100), '\x07y'),
+            through('x\xc2\x9d52;c;QUFB\xc2\x9cy\x1bP1$qm\x1b\\z'),
+        ], ['ab\x1b]0;title\x07cd', 'xy', 'xy', 'xy', 'xyz'], 'clipboard writes (OSC 52) from the sandbox are stripped in every disguise (split chunks, leading zero, huge, C1); titles pass');
+        const plain = '\x1b]8;;https://a.b\x1b\\link\x1b]8;;\x1b\\ \x1b[31mred\x1b[0m é\xc2\xa0';
+        t.equal([through(plain), through('\x1b]9;9;macro\x07\x1b]9;4;1;50\x07')], [plain, '\x1b]9;4;1;50\x07'], 'links, colours and UTF-8 pass unchanged; only the progress form of OSC 9 passes (ConEmu macros do not)');
+        await t.throws(() => new FrameReader().push(Buffer.concat([Buffer.from([16]), Buffer.from([0, 0, 0, 0x7f])])), 'frame too large', 'a frame announcing too much data is rejected instead of buffered');
         const hello = new FrameReader().push(helloFrame('tok', 100, 30, 2))[0];
-        t.equal({
-            type: hello.type,
-            cols: hello.payload.readInt16LE(0),
-            rows: hello.payload.readInt16LE(2),
-            flags: hello.payload[4],
-            token: hello.payload.subarray(5).toString(),
-        }, { type: FrameType.Hello, cols: 100, rows: 30, flags: 2, token: 'tok' }, 'a hello frame carries size, flags and token');
+        t.check(new FrameReader().push(encodeFrame(16, Buffer.alloc(MAX_FRAME_BYTES))).length === 1 &&
+            hello.type === FrameType.Hello &&
+            hello.payload.readInt16LE(0) === 100 &&
+            hello.payload.readInt16LE(2) === 30 &&
+            hello.payload[4] === 2 &&
+            hello.payload.subarray(5).toString() === 'tok', 'a frame of exactly the maximum size is accepted; a hello frame carries size, flags and token');
         t.equal(fixWindowsKeys(Buffer.from([0x61, 0x08, 0x7f, 0x1b])), Buffer.from([0x61, 0x7f, 0x08, 0x1b]), 'Windows console Backspace (^H) reaches the agent as DEL, so it deletes one character, not a word');
         t.section('typed input keeps escape sequences whole');
         const joined = (...chunks) => {
@@ -116,12 +121,13 @@ export const channelSuite = {
             out.push(j.flush().toString('latin1'));
             return out.filter(Boolean);
         };
-        t.equal(joined('ab\x1b[', 'C'), ['ab', '\x1b[C'], 'a Right arrow split after ESC[ is sent whole (ConPTY would read Alt+[ and a typed "C")');
-        t.equal(joined('\x1b', '[<0;10;', '5M', 'x'), ['\x1b[<0;10;5M', 'x'], 'a mouse report split three ways is sent as one');
-        t.equal(joined('\x1bO', 'A'), ['\x1bOA'], 'an SS3 key split after ESC O is sent whole');
-        t.equal(joined('a\x1b'), ['a', '\x1b'], 'a lone Esc key is held, then sent by the flush');
-        t.equal(joined('\x1b[A\x1bx\x7f'), ['\x1b[A\x1bx\x7f'], 'complete keys (arrows, Alt+x, Backspace) pass at once');
-        t.equal(joined('\x1b[' + '1;'.repeat(40)), ['\x1b[' + '1;'.repeat(40)], 'an endless "sequence" is not held back');
+        t.equal([
+            joined('ab\x1b[', 'C'),
+            joined('\x1b', '[<0;10;', '5M', 'x'),
+            joined('a\x1b'),
+            joined('\x1b[A\x1bx\x7f'),
+            joined('\x1b[' + '1;'.repeat(40)),
+        ], [['ab', '\x1b[C'], ['\x1b[<0;10;5M', 'x'], ['a', '\x1b'], ['\x1b[A\x1bx\x7f'], ['\x1b[' + '1;'.repeat(40)]], 'split arrows and mouse reports are sent whole; a lone Esc is held then flushed; complete keys and endless sequences pass at once');
         t.check(MOUSE_OFF.includes('\x1b[?1000l') && MOUSE_OFF.includes('\x1b[?1003l') && MOUSE_OFF.includes('\x1b[?1006l'), 'leaving a session turns every mouse tracking mode off in your terminal');
     },
 };

package/dist/selftest/cli.test.js

@@ -8,10 +8,10 @@ import { commandLine, readHistory, recordHistory } from '../cli/history.js';
 import { splitArgs } from '../cli/args.js';
 import { optionProblem } from '../cli/menu/index.js';
 import { cleanTargetOf } from '../cli/commands/data/collect.js';
-import { ago, colorEnabled, shorten, shortenMiddle } from '../cli/output/index.js';
+import { ago, colorEnabled, shorten } from '../cli/output/index.js';
 import { hoistConfig, withoutConfig } from '../cli/argv.js';
 import { closest, validNodeSpec, validPythonSpec } from '../cli/validate.js';
-import { CATEGORIES, editConfigText, nameOf, SchemaNode } from '../cli/menu/settings/index.js';
+import { CATEGORIES, editConfigText, SchemaNode } from '../cli/menu/settings/index.js';
 import { Frame, ListScreen, Text, TextScreen } from '../cli/tui/index.js';
 import { ConfigSchema, LocalOverridesSchema } from '../core/schema/index.js';
 export const cliSuite = {
@@ -21,136 +21,108 @@ export const cliSuite = {
         t.section('manifest and parser');
         const program = buildProgram(() => undefined);
         const visible = COMMANDS.filter((c) => !c.hidden).map((c) => c.name);
-        const missingFromParser = visible.filter((name) => !program.commands.some((c) => c.name() === name));
-        t.equal(missingFromParser, [], 'every manifest command exists in the parser');
-        t.check(program.commands.find((c) => c.name() === 'launch').options.some((o) => o.long === '--terminal'), 'every manifest option exists in the parser (launch --terminal)');
+        t.equal(visible.filter((name) => !program.commands.some((c) => c.name() === name)), [], 'every manifest command exists in the parser');
         const packageJson = JSON.parse(fs.readFileSync(path.join(t.packageRoot, 'package.json'), 'utf8'));
-        t.equal(program.version(), packageJson.version, '--version prints the package version');
-        t.check(program.options.some((o) => o.short === '-v' && o.long === '--version'), '-v is a short form of --version');
+        t.check(program.version() === packageJson.version &&
+            program.commands.find((c) => c.name() === 'launch').options.some((o) => o.long === '--terminal'), '--version is the package version and manifest options exist in the parser');
         const start = parseCli(['start', '--headless']);
-        t.equal({ command: start.command, noAgent: start.noAgent, headless: start.headless }, { command: 'launch', noAgent: true, headless: true }, '`start` is launch without an agent');
         const clean = parseCli(['data', 'clean', 'tools/go', 'logs', '--yes']);
-        t.equal({ command: clean.command, positionals: clean.positionals, yes: clean.yes }, { command: 'data', positionals: ['clean', 'tools/go', 'logs'], yes: true }, 'data clean takes targets and --yes');
-        t.equal(parseCli(['start', '--database', 'postgres,redis', '--database', 'mongodb']).databases, ['postgres', 'redis', 'mongodb'], '--database takes lists and can repeat');
-        t.equal(parseCli(['db', 'start', 'redis']).positionals, ['start', 'redis'], '`db` takes an action and a name');
-        t.equal(parseCli(['launch', '--harness', 'opencode', '--', '--continue']).passthrough, ['--continue'], 'agent arguments after -- reach the agent');
+        t.equal([
+            [start.command, start.noAgent, start.headless],
+            [clean.command, clean.positionals, clean.yes],
+            parseCli(['start', '--database', 'postgres,redis', '--database', 'mongodb']).databases,
+            parseCli(['launch', '--harness', 'opencode', '--', '--continue']).passthrough,
+        ], [
+            ['launch', true, true],
+            ['data', ['clean', 'tools/go', 'logs'], true],
+            ['postgres', 'redis', 'mongodb'],
+            ['--continue'],
+        ], '`start` is launch without an agent; positionals, repeated lists and arguments after -- parse');
         t.section('parser: agent wrappers (claude-sbx ...) and agent-sandbox');
         const wrapped = parseCli(['--terminal', '--continue', '--headless', '--node', '20', '--', '--terminal'], true);
-        t.equal({
-            command: wrapped.command,
-            terminal: wrapped.terminal,
-            headless: wrapped.headless,
-            node: wrapped.node,
-            passthrough: wrapped.passthrough,
-        }, { command: 'launch', terminal: true, headless: true, node: '20', passthrough: ['--continue', '--terminal'] }, 'claude-sbx: sandbox flags are consumed, everything else goes to the agent');
+        t.equal([wrapped.command, wrapped.terminal, wrapped.headless, wrapped.node, wrapped.passthrough], ['launch', true, true, '20', ['--continue', '--terminal']], 'claude-sbx: sandbox flags are consumed, everything else goes to the agent');
         await t.throws(() => parseCli(['status', '--bogus']), 'unknown option', 'agent-sandbox: unknown options are errors');
-        t.equal(parseCli(['account', 'use', 'work', '--no-restart']).positionals, ['use', 'work'], 'agent-sandbox: positionals are collected');
-        t.equal(parseCli(['clean', '--days=3']).days, 3, 'agent-sandbox: --opt=value works');
         const agentFlags = parseCli(['--model', 'opus', '-p', 'fix it', '--json', '-f', 'x', '--timeout', '5', '--resume', 'abc'], true);
-        t.equal(agentFlags.passthrough, ['--model', 'opus', '-p', 'fix it', '--json', '-f', 'x', '--timeout', '5', '--resume', 'abc'], 'claude-sbx: any flag that is not a launch option goes to the agent, in order (even ones agent-sandbox uses elsewhere)');
-        t.equal({ json: agentFlags.json, follow: agentFlags.follow, timeout: agentFlags.timeout }, { json: false, follow: false, timeout: 600 }, "claude-sbx: the agent's flags do not set agent-sandbox options");
+        t.check(agentFlags.passthrough.join('|') === '--model|opus|-p|fix it|--json|-f|x|--timeout|5|--resume|abc' &&
+            !agentFlags.json &&
+            !agentFlags.follow &&
+            agentFlags.timeout === 600, 'claude-sbx: any flag that is not a launch option goes to the agent in order and sets no agent-sandbox option');
         const reserved = parseCli(['--sbx-terminal', '--terminal', '--sbx-node=18'], true);
-        t.equal({ terminal: reserved.terminal, node: reserved.node, passthrough: reserved.passthrough }, { terminal: true, node: '18', passthrough: [] }, '--sbx-<option> always means agent-sandbox');
-        t.equal(parseCli(['launch', '--continue', '--sbx-headless']).passthrough, ['--continue'], 'agent-sandbox launch passes agent flags too');
+        t.equal([reserved.terminal, reserved.node, reserved.passthrough], [true, '18', []], '--sbx-<option> always means agent-sandbox');
         await t.throws(() => parseCli(['--sbx-nope'], true), 'Unknown option: --sbx-nope', 'an unknown --sbx-<option> is an error');
         t.section('menu helpers');
-        t.equal(splitArgs('--model "big one" -c \'x y\''), ['--model', 'big one', '-c', 'x y'], 'menu: arguments split like a shell');
-        t.equal(commandLine(['exec', 'echo', 'a b']), 'sandbox exec echo "a b"', 'menu: command lines are quoted');
+        t.check(splitArgs('--model "big one" -c \'x y\'').join('|') === '--model|big one|-c|x y' &&
+            commandLine(['exec', 'echo', 'a b']) === 'sandbox exec echo "a b"', 'menu: arguments split like a shell and command lines are quoted');
         const optionOf = (flag) => COMMANDS.flatMap((cmd) => cmd.options).find((o) => o.flag === flag);
-        t.check(optionProblem(optionOf('--node'), 'abc') !== undefined, 'menu: a bad Node version is rejected while typing');
-        t.check(optionProblem(optionOf('--node'), '22') === undefined, 'menu: a good Node version is accepted');
-        t.check(optionProblem(optionOf('--workspace'), path.join(t.packageRoot, 'no-such-folder-here')) !== undefined, 'menu: a missing folder is rejected');
-        t.check(optionProblem(optionOf('--workspace'), t.packageRoot) === undefined, 'menu: an existing folder is accepted');
-        t.check(optionProblem(optionOf('--days'), '0') !== undefined, 'menu: a number below the minimum is rejected');
+        t.check(optionProblem(optionOf('--node'), 'abc') !== undefined &&
+            optionProblem(optionOf('--node'), '22') === undefined &&
+            optionProblem(optionOf('--workspace'), path.join(t.packageRoot, 'no-such-folder-here')) !== undefined &&
+            optionProblem(optionOf('--workspace'), t.packageRoot) === undefined &&
+            optionProblem(optionOf('--days'), '0') !== undefined, 'menu: bad Node versions, missing folders and numbers below the minimum are rejected while typing');
         const rowOf = (area, name) => ({ area, name, path: 'x', bytes: 1 });
         t.equal([
             cleanTargetOf(rowOf('tools', 'go')),
-            cleanTargetOf(rowOf('tools', 'agents/claude')),
-            cleanTargetOf(rowOf('databases', 'databases/pg')),
             cleanTargetOf(rowOf('host', 'launches')),
-        ], ['tools/go', 'tools/agents/claude', 'databases/pg', 'launches'], 'data menu: removable rows become checkbox targets');
-        t.equal([cleanTargetOf(rowOf('host', 'accounts')), cleanTargetOf(rowOf('tools', '(files in tools)'))], [null, null], 'data menu: accounts and loose files are never offered');
-        t.equal(COMMANDS.find((cmd) => cmd.name === 'data').options.find((o) => o.flag === '--yes')?.noMenu, true, 'data menu: --yes is never offered');
+            cleanTargetOf(rowOf('host', 'accounts')),
+            cleanTargetOf(rowOf('tools', '(files in tools)')),
+        ], ['tools/go', 'launches', null, null], 'data menu: removable rows become targets; accounts and loose files are never offered');
         t.section('--config placement, history, validation, text helpers');
-        t.equal(hoistConfig(['--config', 'a.json', 'status', '--json']), ['status', '--config', 'a.json', '--json'], '--config before the command is moved behind it');
-        t.equal(hoistConfig(['--config=a.json']), ['menu', '--config', 'a.json'], '--config alone opens the menu with it');
-        t.equal(withoutConfig(['status', '--config', 'a.json', '--json']), ['status', '--json'], 'the recorded history drops --config');
+        t.equal([
+            hoistConfig(['--config', 'a.json', 'status', '--json']),
+            hoistConfig(['--config=a.json']),
+            withoutConfig(['status', '--config', 'a.json', '--json']),
+        ], [
+            ['status', '--config', 'a.json', '--json'],
+            ['menu', '--config', 'a.json'],
+            ['status', '--json'],
+        ], '--config is moved behind the command, alone it opens the menu, and history drops it');
         recordHistory(['launch', '--harness', 'claude']);
         recordHistory(['status']);
         recordHistory(['launch', '--harness', 'claude']);
         recordHistory(['menu']);
         t.equal(readHistory().map((h) => h.argv.join(' ')), ['launch --harness claude', 'status'], 'history: newest first, no duplicates, the menu itself is not recorded');
-        t.check(validNodeSpec('22') && validNodeSpec('v22.1.0') && validNodeSpec('lts/*') && !validNodeSpec('abc'), 'validation: Node version syntax');
-        t.check(validPythonSpec('3.12') && !validPythonSpec('2.7'), 'validation: Python version syntax');
-        t.equal(closest('cluade', ['claude', 'codex']), 'claude', 'validation: did-you-mean for agent names');
-        t.equal(closest('zzzzzz', ['claude']), undefined, 'validation: nothing is suggested for an unrelated name');
-        const env = (vars, isTty) => colorEnabled(vars, isTty);
-        t.check(env({}, true), 'colours: on for a terminal');
-        t.check(!env({}, false), 'colours: off for a pipe');
-        t.check(!env({ NO_COLOR: '1' }, true) && !env({ TERM: 'dumb' }, true), 'colours: off for NO_COLOR and TERM=dumb');
-        t.check(env({ FORCE_COLOR: '1' }, false) && !env({ FORCE_COLOR: '0' }, true), 'colours: FORCE_COLOR overrides');
-        t.equal(shorten('abcdefghij', 6), 'abcde…', 'text helpers: shorten');
-        t.equal(shortenMiddle('C:\\Users\\me\\project', 11), 'C:\\Us…oject', 'text helpers: shorten in the middle');
-        t.equal([ago(0, 10 * 60 * 1000), ago(0, 5000), ago(0, 3 * 86400 * 1000)], ['10 min ago', 'just now', '3 d ago'], 'text helpers: relative time');
+        t.check(validNodeSpec('22') &&
+            validNodeSpec('lts/*') &&
+            !validNodeSpec('abc') &&
+            validPythonSpec('3.12') &&
+            !validPythonSpec('2.7') &&
+            closest('cluade', ['claude', 'codex']) === 'claude' &&
+            closest('zzzzzz', ['claude']) === undefined, 'validation: version syntax and did-you-mean for agent names');
+        t.check(colorEnabled({}, true) &&
+            !colorEnabled({}, false) &&
+            !colorEnabled({ NO_COLOR: '1' }, true) &&
+            colorEnabled({ FORCE_COLOR: '1' }, false) &&
+            !colorEnabled({ FORCE_COLOR: '0' }, true), 'colours: on for a terminal, off for a pipe or NO_COLOR, FORCE_COLOR overrides');
+        t.equal([shorten('abcdefghij', 6), ago(0, 10 * 60 * 1000), ago(0, 5000)], ['abcde…', '10 min ago', 'just now'], 'text helpers: shorten and relative time');
         t.section('settings screen');
         const original = '{\n  // my notes stay\n  "sandbox": { "headless": true }\n}\n';
         const set = editConfigText(original, ['attach', 'auto'], true);
         const nested = 'text' in set ? editConfigText(set.text, ['databases', 'postgres', 'port'], 6543) : set;
         const reset = 'text' in nested ? editConfigText(nested.text, ['sandbox', 'headless'], undefined) : nested;
-        t.check('text' in reset, 'editing a config file gives new text');
         const resetText = 'text' in reset ? reset.text : '';
-        t.includes(resetText, '// my notes stay', "settings screen: changes keep the file's comments");
-        t.includes(resetText, '"auto": true', 'settings screen: a new setting is added');
-        t.includes(resetText, '"port": 6543', 'settings screen: nested keys are created');
-        t.excludes(resetText, 'headless', 'settings screen: reset removes a key');
+        t.check(resetText.includes('// my notes stay') &&
+            resetText.includes('"auto": true') &&
+            resetText.includes('"port": 6543') &&
+            !resetText.includes('headless'), "settings screen: changes keep the file's comments, add new and nested keys, and reset removes a key", resetText);
         const invalid = editConfigText(original, ['sandbox', 'memoryMb'], 12);
-        t.check('problems' in invalid && invalid.problems.join().includes('memoryMb'), 'settings screen: invalid values are not saved', JSON.stringify(invalid));
-        const missing = editConfigText('{ "storage": { "root": "C:\\\\x" } }', ['agentCommands', 'enabled'], undefined);
-        t.check('text' in missing && missing.text.includes('"root"'), 'removing a setting the file does not have changes nothing (no crash)');
-        const projectEdit = editConfigText('{}', ['downloads', 'requireChecksum'], true, 'project');
         const projectBad = editConfigText('{}', ['storage', 'root'], 'C:\\x', 'project');
-        t.check('text' in projectEdit && projectEdit.text.includes('requireChecksum'), 'settings screen: a project file accepts project settings');
-        t.check('problems' in projectBad, 'settings screen: a project file is validated against the project schema (storage cannot be set there)');
+        t.check('problems' in invalid && invalid.problems.join().includes('memoryMb') && 'problems' in projectBad, 'settings screen: invalid values are not saved; a project file cannot set storage', JSON.stringify(invalid));
         // Every setting must be reachable in the settings screen, in a category, with an editor that fits it.
         const userSchema = new SchemaNode(ConfigSchema);
         const projectSchema = new SchemaNode(LocalOverridesSchema);
         const userLeaves = userSchema.leaves();
-        const projectLeaves = projectSchema.leaves();
-        t.check(userLeaves.length > 100 && projectLeaves.length > 50, 'settings screen: every setting is a leaf (' +
-            userLeaves.length +
-            ' settings, ' +
-            projectLeaves.length +
-            ' in a project file)');
         const uncategorised = [...userSchema.children(), ...projectSchema.children()]
             .map(([name]) => name)
             .filter((name) => !CATEGORIES.some((c) => c.keys.includes(name)));
         t.equal(uncategorised, [], 'settings screen: every top-level setting belongs to a category');
-        const kinds = new Set(userLeaves.map((l) => l.node.editor));
-        t.equal([
-            'boolean',
-            'choice',
-            'union',
-            'number',
-            'string',
-            'string-list',
-            'choice-list',
-            'object-list',
-            'string-map',
-            'object-map',
-        ].filter((k) => !kinds.has(k)), [], 'settings screen: every kind of editor is used');
         t.equal(userLeaves.filter((l) => l.node.editor === 'json').map((l) => l.key.join('.')), [], 'settings screen: no setting falls back to typing JSON');
-        t.check(userLeaves.some((l) => l.key.join('.') === 'downloads.requireChecksum') &&
-            projectLeaves.some((l) => l.key.join('.') === 'downloads.requireChecksum'), 'settings screen: downloads.requireChecksum is reachable in both files');
         const harness = userSchema.child('harnesses').element;
-        t.includes(String(harness.check(harness.initial())), 'npmPackage', 'settings screen: a new agent says what it still needs (a package to install)');
-        t.equal(harness.check({ ...harness.initial(), npmPackage: 'my-cli', npmBin: 'my-cli' }), true, '... and is valid once it has one');
-        const mapping = userSchema.child('mappings').element;
-        t.check(mapping.check(mapping.initial()) !== true, 'settings screen: a new mapped folder needs its folders filled in before it is valid');
-        t.equal([Text.humanize('memoryMb'), Text.humanize('vGpu'), nameOf('node')], ['Memory MB', 'V GPU', 'Node.js'], 'settings screen: readable names');
+        t.check(String(harness.check(harness.initial())).includes('npmPackage') &&
+            harness.check({ ...harness.initial(), npmPackage: 'my-cli', npmBin: 'my-cli' }) === true, 'settings screen: a new agent says what it still needs, and is valid once it has it');
         t.section('screens');
         const fit = Text.fit('\x1b[31mred text\x1b[0m', 5);
-        t.equal([Text.width(fit), Text.strip(fit)], [5, 'red …'], 'a coloured label is cut to the width without breaking its colour');
-        t.equal(Text.width('日本'), 4, 'wide characters take two columns');
+        t.equal([Text.width(fit), Text.strip(fit), Text.width('日本')], [5, 'red …', 4], 'a coloured label is cut to the width without breaking its colour; wide characters take two columns');
+        const key = (name, text = '') => ({ name, text, ctrl: false, meta: false, shift: false });
         const screen = new ListScreen({
             path: ['T'],
             items: [
@@ -162,23 +134,11 @@ export const cliSuite = {
                 { id: 'y', label: 'Y' },
             ],
         });
-        const key = (name, text = '') => ({ name, text, ctrl: false, meta: false, shift: false });
         screen.handle(key('left'));
         screen.handle(key('down'));
         screen.handle(key('right'));
         t.equal(screen.handle(key('return')), { done: { kind: 'pick', value: 'b' } }, 'list screen: arrows switch category, Enter picks');
-        const search = new ListScreen({
-            path: ['T'],
-            items: [
-                { value: 'a', label: 'Alpha' },
-                { value: 'b', label: 'Beta' },
-            ],
-        });
-        for (const k of [key('', '/'), key('b', 'b'), key('e', 'e')])
-            search.handle(k);
-        t.equal(search.handle(key('return')), { done: { kind: 'pick', value: 'b' } }, 'list screen: / searches');
-        const lines = Frame.render(screen.render({ width: 60, height: Frame.bodyHeight(20) }), 60, 20);
-        t.equal(lines.length, 20, 'a frame fills the terminal height exactly');
+        t.equal(Frame.render(screen.render({ width: 60, height: Frame.bodyHeight(20) }), 60, 20).length, 20, 'a frame fills the terminal height exactly');
         const multi = new ListScreen({
             path: ['T'],
             multi: true,
@@ -190,11 +150,10 @@ export const cliSuite = {
         multi.handle(key('space'));
         t.equal(multi.handle(key('return')), { done: { kind: 'multi', values: ['a', 'b'] } }, 'list screen: space ticks several');
         const typed = new TextScreen({ path: ['T'], label: 'Port', validate: (v) => (Number(v) > 0 ? true : 'a number') });
-        for (const ch of 'x')
-            typed.handle(key(ch, ch));
-        t.equal(typed.handle(key('return')), undefined, 'text field: an invalid value is not accepted');
+        typed.handle(key('x', 'x'));
+        const refused = typed.handle(key('return'));
         typed.handle(key('backspace'));
         typed.handle(key('8', '8'));
-        t.equal(typed.handle(key('return')), { done: '8' }, 'text field: a valid value is');
+        t.equal([refused, typed.handle(key('return'))], [undefined, { done: '8' }], 'text field: an invalid value is not accepted, a valid one is');
     },
 };

package/dist/selftest/cmdline.test.js

@@ -1,5 +1,5 @@
-// How the sandbox builds command lines for npm-installed agents (.cmd files run through cmd.exe): & | < > ^ % and quotes
-// must reach the agent unchanged.
+// How the sandbox builds command lines for npm-installed agents (.cmd files run through cmd.exe): & | < > ^ % and
+// quotes must reach the agent unchanged.
 import { spawnSync } from 'node:child_process';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
@@ -25,7 +25,8 @@ export const cmdlineSuite = {
     title: 'cmd.exe quoting for npm-installed agents',
     run: async (t) => {
         t.section('command lines');
-        // guest/cmdline.ts is loaded in a child process with a throwaway launch/data folder (it reads session.json on load).
+        // guest/cmdline.ts is loaded in a child process with a throwaway launch/data folder (it reads session.json on
+        // load).
         const quoteDir = t.at('quote');
         t.write(path.join(quoteDir, 'launch', 'session.json'), '{}');
         const agentCmd = t.write(path.join(quoteDir, 'agent.cmd'), '@"' + process.execPath + '" -e "console.log(JSON.stringify(process.argv.slice(1)))" %*\r\n');