windows-development-sandbox 1.7.0 → 1.10.0

package/dist/selftest/app.test.js

@@ -0,0 +1,324 @@
+// The shared core: the kernel (definitions checked in and out, Fields from zod, questions and their fake, errors across
+// a surface, the RPC messages), parity (every operation and query reachable on the CLI, the menu and the web, or
+// exempt with a reason), the reference views' pages, their CLI and menu renderings, and the settings feature run
+// against a config file of its own.
+import fs from 'node:fs';
+import { z } from 'zod';
+import { DEFINITIONS, NAV, QUERIES, VIEWS, viewById } from '../app/features/defs.js';
+import { sandboxPage } from '../app/features/sandbox/index.js';
+import { sessionsPage } from '../app/features/sessions/index.js';
+import { settingsPage } from '../app/features/settings/index.js';
+import { ago, Cancelled, ClientMessageSchema, defineOperation, exemption, fakeIO, fieldOf, fieldProblem, FieldSchema, fieldsOf, fromWireError, humanize, implementer, invoke, pageActions, ServerMessageSchema, SURFACE_NAMES, toWireError, valueText, } from '../app/kernel/index.js';
+import { IMPLEMENTATIONS, readQuery, runDefinition } from '../app/registry.js';
+import { parseCli } from '../cli/args.js';
+import { COMMANDS, commandSpec } from '../cli/manifest.js';
+import { menuView } from '../cli/menu/render-view.js';
+import { MENU_VIEWS } from '../cli/menu/views.js';
+import { cliInput, commandSpecOf, definitionFor } from '../cli/operations/index.js';
+import { pageLines } from '../cli/output/index.js';
+import { secret } from '../core/schema/index.js';
+import { UserError } from '../core/util/index.js';
+const NOW = Date.now();
+const running = (id, here) => ({
+    id,
+    launchId: 'l1',
+    harness: 'claude',
+    cwd: 'C:\\Projects\\api',
+    phase: 'running',
+    message: 'running',
+    updatedAt: new Date(NOW).toISOString(),
+    startedAt: new Date(NOW - 5 * 60000).toISOString(),
+    projectName: 'api',
+    here,
+    viewers: { viewers: 1, remote: 1 },
+    canOpen: true,
+});
+const STATUS = {
+    sandbox: {
+        running: true,
+        phase: 'ready',
+        message: 'Ready',
+        headless: true,
+        startedAt: NOW - 3 * 3600000,
+        daemon: 'pong (2 session(s) running)',
+        account: 'work',
+        syncWatcher: true,
+    },
+    here: { folder: 'C:\\Projects\\api', project: 'api', guest: 'C:\\Projects\\api' },
+    roots: [{ host: 'C:\\Projects', guest: 'C:\\Projects' }],
+    projects: [
+        {
+            name: 'api',
+            host: 'C:\\Projects\\api',
+            guest: 'C:\\Projects\\api',
+            mechanism: 'launch',
+            here: true,
+            setup: { phase: 'ready', message: '' },
+            databases: [{ database: 'postgres', port: 5432, state: 'running' }],
+            sessions: [
+                { id: 's1', harness: 'claude', viewers: '1 here, 0 in sandbox', started: new Date(NOW).toISOString() },
+            ],
+            repoGuard: [],
+        },
+    ],
+    otherSessions: [],
+    repoGuard: { guarded: 1, findings: ['hook: C:\\Projects\\api: .git/hooks/pre-commit'] },
+};
+/** The operations and queries a list of views can reach. */
+function reached(views) {
+    return new Set(views.flatMap((v) => [...v.operations.map((o) => o.id), ...Object.values(v.queries).map((q) => q.id)]));
+}
+/** Why a definition is not reachable on a surface ('' when it is). */
+function gap(def, surface, reach) {
+    if (exemption(def, surface)?.trim())
+        return '';
+    if (surface === 'cli')
+        return def.cli ? '' : 'no CLI hint and no exemption';
+    return reach[surface].has(def.id) ? '' : 'no ' + surface + ' view offers it and it declares no exemption';
+}
+export const appSuite = {
+    name: 'app',
+    title: 'shared core: kernel, parity of the three surfaces, reference views and their renderings, settings',
+    run: async (t) => {
+        t.section('definitions are checked going in and coming out');
+        const implement = implementer();
+        const add = defineOperation({
+            id: 'test.add',
+            title: 'Add',
+            summary: 'adds',
+            input: z.object({ n: z.number().int().describe('how many'), twice: z.boolean().default(false) }),
+            output: z.object({ total: z.number() }),
+            text: (o) => 'total ' + o.total,
+        });
+        const addRun = implement(add, (ctx, input) => ({ total: ctx.base + input.n * (input.twice ? 2 : 1) }));
+        const io = fakeIO().io;
+        t.equal(await invoke(addRun, { base: 1 }, { n: 2 }, io), { total: 3 }, 'defaults are filled in before run');
+        await t.throws(() => invoke(addRun, { base: 1 }, { n: 'x' }, io), 'That does not work for add', 'a bad input');
+        const broken = implement(add, () => ({ total: 'nope' }));
+        await t.throws(() => invoke(broken, { base: 0 }, { n: 1 }, io), 'expected number', 'an output that does not fit');
+        t.section('questions, and the fake that answers them');
+        const fake = fakeIO([true, 'too short', 'long enough']);
+        const asked = await fake.io.confirm({ title: 'Sure?' });
+        const typed = await fake.io.text({ title: 'Name', validate: (v) => (v.length > 9 ? true : 'Longer, please.') });
+        fake.io.progress('working');
+        fake.io.log('a line', 'muted');
+        t.check(asked === true &&
+            typed === 'long enough' &&
+            fake.seen.questions.length === 3 &&
+            fake.seen.questions[2].kind === 'text' &&
+            'problem' in fake.seen.questions[2] &&
+            fake.seen.questions[2].problem === 'Longer, please.' &&
+            fake.seen.progress[0] === 'working' &&
+            fake.seen.logs[0].tone === 'muted', 'answers come in order, a typed answer is asked again with what was wrong, lines are recorded');
+        await t.throws(() => fakeIO().io.confirm({ title: 'Unplanned?' }), 'No answer for: Unplanned?', 'no answer left');
+        t.section('errors cross a surface as message and fix');
+        const user = toWireError(new UserError('It broke.', 'Do this.'));
+        t.equal(user, { kind: 'user', message: 'It broke.', fix: 'Do this.' }, 'a UserError keeps its fix');
+        t.equal(toWireError(new Cancelled()).kind, 'cancelled', 'a declined question is "cancelled"');
+        t.equal(toWireError(new Error('C:\\secret')), { kind: 'bug', message: 'Something went wrong.' }, 'a bug says little');
+        t.equal(toWireError(z.number().safeParse('x').error).kind, 'invalid', 'a value that does not fit is "invalid"');
+        const back = fromWireError(user);
+        t.check(back instanceof UserError && back.fix === 'Do this.', 'and it becomes a UserError again on the other side');
+        t.section('Fields from zod');
+        const schema = z.object({
+            on: z.boolean().default(true).describe('Switch it'),
+            size: z.union([z.literal('auto'), z.number().int().min(1).max(64)]).describe('How big'),
+            days: z.number().int().min(1).max(365).default(7),
+            name: z.string().optional(),
+            apiKey: secret(z.string()).default('hunter2'),
+            cacheDir: z.string(),
+            tags: z.array(z.string()),
+            env: z.record(z.string(), secret(z.string())),
+            mapping: z.object({ host: z.string(), readOnly: z.boolean().optional() }),
+        });
+        const fields = fieldsOf(schema);
+        const kinds = Object.fromEntries(fields.map((f) => [f.name, f.kind]));
+        t.equal(kinds, {
+            on: 'boolean',
+            size: 'enum',
+            days: 'number',
+            name: 'text',
+            apiKey: 'secret',
+            cacheDir: 'path',
+            tags: 'list',
+            env: 'map',
+            mapping: 'object',
+        }, 'every kind of value gets its kind of field');
+        const size = fields.find((f) => f.name === 'size');
+        const days = fields.find((f) => f.name === 'days');
+        const apiKey = fields.find((f) => f.name === 'apiKey');
+        t.check(size.help === 'How big' &&
+            size.choices?.[0]?.value === 'auto' &&
+            size.open?.kind === 'number' &&
+            days.range === '1 to 365' &&
+            days.default === 7 &&
+            days.optional &&
+            apiKey.default === '***' &&
+            fields.find((f) => f.name === 'cacheDir')?.pathKind === 'dir' &&
+            fields.find((f) => f.name === 'mapping')?.fields?.length === 2 &&
+            humanize('memoryMb') === 'Memory MB', 'label, help, default, range, choices with a value of your own, folders, objects; a secret default never shows');
+        t.check(fields.every((f) => FieldSchema.safeParse(f).success) && FieldSchema.safeParse({ kind: 'x' }).success === false, 'Fields are plain data that fits FieldSchema (what the browser receives)');
+        t.check(fieldProblem(days, 400) === 'Use 1 to 365.' &&
+            fieldProblem(days, 3) === undefined &&
+            fieldProblem(size, 'big') === undefined &&
+            fieldProblem(fieldOf(z.enum(['a', 'b'])), 'c') === 'Choose one.' &&
+            valueText('hunter2', apiKey).text === '***' &&
+            valueText(true).text === 'On', 'a Field checks a value as far as it can tell, and secrets read as ***');
+        t.section('the RPC messages');
+        const good = [
+            { t: 'call', id: 'c1', op: 'sessions.restart', input: { all: true } },
+            { t: 'answer', id: 'c1', value: true },
+            { t: 'subscribe', id: 's1', query: 'sandbox.status', input: {} },
+            { t: 'unsubscribe', id: 's1' },
+        ];
+        const bad = [
+            { t: 'call', id: 'c1', op: '../etc', input: {} },
+            { t: 'call', id: 'with space', op: 'a.b', input: {} },
+            { t: 'call', id: 'c1', op: 'a.b', input: {}, extra: 1 },
+            { t: 'shell', id: 'c1' },
+            'call',
+        ];
+        t.check(good.every((m) => ClientMessageSchema.safeParse(m).success) &&
+            bad.every((m) => !ClientMessageSchema.safeParse(m).success) &&
+            ServerMessageSchema.safeParse({ t: 'ask', id: 'c1', question: { kind: 'confirm', title: 'Go?' } }).success &&
+            !ServerMessageSchema.safeParse({ t: 'ask', id: 'c1', question: { kind: 'shell', title: 'x' } }).success, 'the browser may send only calls, answers and subscriptions of the right shape');
+        t.section('parity: every operation and query on every surface');
+        const ids = DEFINITIONS.map((d) => d.id);
+        const implemented = IMPLEMENTATIONS.map((i) => i.def.id);
+        t.check(new Set(ids).size === ids.length &&
+            ids.every((id) => implemented.includes(id)) &&
+            implemented.every((id) => ids.includes(id)) &&
+            IMPLEMENTATIONS.every((i) => DEFINITIONS.includes(i.def)), 'every definition has exactly one implementation and every implementation is registered', ids.filter((id) => !implemented.includes(id)).join(', '));
+        const webViews = NAV.flatMap((n) => (n.view ? [viewById(n.view)] : []));
+        const reach = {
+            cli: new Set(),
+            menu: reached(MENU_VIEWS.map((m) => m.view)),
+            web: reached(webViews),
+        };
+        const gaps = DEFINITIONS.flatMap((d) => SURFACE_NAMES.map((s) => [d.id, s, gap(d, s, reach)]).filter(([, , why]) => why)).map(([id, s, why]) => id + ' on ' + s + ': ' + why);
+        t.equal(gaps, [], 'the parity list shows no gaps');
+        t.check(VIEWS.every((v) => webViews.includes(v) || MENU_VIEWS.some((m) => m.view === v)) &&
+            NAV.every((n) => n.view !== undefined || Boolean(n.elsewhere)), 'every view is shown somewhere, and a web section without a view says where the area is');
+        const hinted = DEFINITIONS.filter((d) => d.cli);
+        t.check(hinted.every((d) => {
+            const names = [...(d.cli?.positional ?? []), ...Object.keys(d.cli?.flags ?? {})];
+            const shape = d.input.shape ?? {};
+            return names.every((n) => n in shape);
+        }) && hinted.filter((d) => !d.cli?.action).every((d) => commandSpecOf(d).name === d.cli?.name), 'every CLI hint names fields of its input, and every command of its own has a group');
+        t.section('the commands keep their names and flags');
+        const spec = (name) => JSON.stringify(commandSpec(name)?.options.map((o) => [o.flag, o.short ?? '', o.shownAs ?? '', o.type, o.description]));
+        t.check(['status', 'sessions', 'restart', 'stop', 'show', 'hide'].every((n) => COMMANDS.filter((c) => c.name === n).length === 1), 'status, sessions, restart, stop, show and hide are commands (once each)');
+        t.equal([spec('restart'), spec('stop'), spec('sessions')], [
+            JSON.stringify([
+                ['--harness', '', '--agent', 'string', 'only this agent'],
+                ['--all', '', '', 'boolean', "every project's sessions, not only this folder's"],
+            ]),
+            JSON.stringify([['--yes', '-y', '', 'boolean', "do not ask when other projects' sessions would end"]]),
+            JSON.stringify([['--wide', '', '', 'boolean', "also show each session's folder"]]),
+        ], 'with the flags and help they had');
+        const configChoices = commandSpec('config')?.args[0].choices;
+        t.check(Array.isArray(configChoices) && ['get', 'set', 'reset', 'list'].every((a) => configChoices.includes(a)), 'config get, set, reset and list are actions of config');
+        const restartLine = parseCli(['restart', '--agent', 'claude', '--all']);
+        const setLine = parseCli(['config', 'set', 'sandbox.memoryMb', '8192']);
+        t.equal([cliInput(definitionFor('restart', []), restartLine), cliInput(definitionFor('config', ['set']), setLine)], [
+            { harness: 'claude', all: true },
+            { key: 'sandbox.memoryMb', value: '8192' },
+        ], 'a command line becomes the input (--agent and the old --harness, positional arguments after the action)');
+        t.check(definitionFor('config', ['show']) === undefined && definitionFor('config', []) === undefined, "config's own actions stay the command's");
+        t.section('the reference views');
+        const statusPage = sandboxPage(STATUS);
+        const stoppedPage = sandboxPage({ ...STATUS, sandbox: { ...STATUS.sandbox, running: false, phase: 'stopped' } });
+        const limited = sandboxPage({
+            ...STATUS,
+            shared: { line: 'Running, started by bob (not shared)', limited: true, startedBy: 'bob' },
+        });
+        const ops = (page) => pageActions(page).flatMap((a) => (a.kind === 'operation' ? [a.op] : []));
+        t.check(ops(statusPage).join() === 'sandbox.showWindow,sandbox.hideWindow,sandbox.stop' &&
+            pageActions(statusPage).some((a) => a.kind === 'operation' && a.op === 'sandbox.stop' && a.danger) &&
+            ops(stoppedPage).length === 0 &&
+            limited.sections.length === 0 &&
+            limited.notice?.text === 'Running, started by bob (not shared)', "status: the window and stop (marked dangerous) only while it runs; another user's unshared sandbox shows only whose it is");
+        const list = {
+            sandboxRunning: true,
+            defaultAgent: 'codex',
+            wide: false,
+            sessions: [running('old', false), { ...running('new', true), startedAt: new Date(NOW).toISOString() }],
+        };
+        const sessions = sessionsPage(list);
+        const items = sessions.sections[0].items ?? [];
+        t.check(items[0].id === 'new' &&
+            items[0].primary?.kind === 'link' &&
+            items[0].primary.target.kind === 'terminal' &&
+            items[0].group === "This folder's project" &&
+            ops(sessions).includes('sessions.restart') &&
+            sessionsPage({ ...list, sessions: [] }).empty?.action?.kind === 'link', "sessions: this folder's project first, a running session opens its terminal, empty offers to start one");
+        for (const view of VIEWS) {
+            const known = new Set(view.operations.map((o) => o.id));
+            const sample = view.id === 'sandbox' ? statusPage : view.id === 'sessions' ? sessions : undefined;
+            if (sample)
+                t.check(ops(sample).every((op) => known.has(op)), view.id + ': the page offers only operations its view declares');
+        }
+        t.section('the CLI and the menu draw the same page');
+        const sessionLines = pageLines(sessionsPage({ ...list, wide: true }));
+        t.check(/^\s+ID\s+AGENT\s+PROJECT\s+STATE\s+ATTACHED\s+FOLDER\s+STARTED$/.test(sessionLines[0]) &&
+            /^\*\s+new\s/.test(sessionLines[1]) &&
+            sessionLines.includes('* = the project of this folder') &&
+            !sessionLines.some((l) => l.includes('--wide')), 'sessions on the command line: the table with the folder column (--wide), the marker and its note', sessionLines.join('\n'));
+        const statusLines = pageLines(statusPage);
+        t.check(statusLines.some((l) => /^Running\s+yes$/.test(l)) &&
+            statusLines.some((l) => /^Helper\s+responding, 2 sessions running$/.test(l)) &&
+            statusLines.includes('* api  C:\\Projects\\api  ->  C:\\Projects\\api  (started from here)') &&
+            statusLines.some((l) => l.startsWith('Repo guard  1 folder(s) guarded')), 'status on the command line: facts as rows, projects with their details, the repo guard', statusLines.join('\n'));
+        t.equal(pageLines(sessionsPage({ ...list, sessions: [] })).at(-1), 'No sessions. Start one with: sandbox claude', 'an empty page prints its command-line text');
+        const menu = menuView(sessions);
+        const chosen = menu.resolve({ kind: 'pick', value: 'new' });
+        t.check(menu.items.length === 2 &&
+            menu.actions.map((a) => a.key).join() === 'r,o,l' &&
+            menu.enterLabel(undefined, 'new') === 'attach' &&
+            chosen?.kind === 'action' &&
+            chosen.action.kind === 'link' &&
+            menu.resolve({ kind: 'action', key: 'l', value: undefined })?.kind === 'refresh', 'sessions in the menu: rows, the r/o/l keys, Enter attaches');
+        const menuStatus = menuView(statusPage, { category: 'status', prefix: 'status:' });
+        t.check(menuStatus.items.every((i) => i.category === 'status' && i.value.startsWith('status:')) &&
+            menuStatus.actions.some((a) => a.key === 'x' && a.label === 'stop'), 'a view inside one category of a page: rows in it, prefixed, with the keys of its actions');
+        t.section('settings, run against a config file');
+        const configFile = t.writeJson(t.at('app-settings', 'config.json'), {
+            storage: { root: t.dir('app-settings', 'storage') },
+            harnesses: {
+                planted: { npmPackage: 'p', npmBin: 'p', arguments: [], environment: { KEY: 'sk-planted-secret' } },
+            },
+        });
+        const ctx = {
+            loaded: { configPath: configFile },
+            options: { workspace: t.dir('app-settings', 'project') },
+            storageRoot: t.at('app-settings', 'storage'),
+        };
+        const quiet = fakeIO().io;
+        const set = (await runDefinition('settings.set', ctx, { key: 'sandbox.memoryMb', value: '8192' }, quiet));
+        const got = (await runDefinition('settings.get', ctx, { key: 'sandbox.memoryMb' }, quiet));
+        t.check(set.message === 'sandbox.memoryMb is 8192.' &&
+            got.value === 8192 &&
+            fs.readFileSync(configFile, 'utf8').includes('8192'), 'set reads text like the command line, writes the file, and get reads it back', set.message);
+        await t.throws(() => runDefinition('settings.set', ctx, { key: 'sandbox.memoryMb', value: 'lots' }, quiet), 'does not work for sandbox.memoryMb', 'a value that does not fit is refused with what is allowed');
+        await t.throws(() => runDefinition('settings.set', ctx, { key: 'sandbox.memoryMbb', value: '1' }, quiet), 'Did you mean sandbox.memoryMb', 'a typo gets a suggestion');
+        const reset = (await runDefinition('settings.reset', ctx, { key: 'sandbox.memoryMb' }, quiet));
+        t.check(reset.message.startsWith('sandbox.memoryMb is back to its default') &&
+            !fs.readFileSync(configFile, 'utf8').includes('8192'), 'reset removes the line');
+        const listed = await readQuery(QUERIES.find((q) => q.id === 'settings.list'), ctx, { scope: 'user' });
+        const rows = listed.rows;
+        const text = JSON.stringify(listed);
+        t.check(rows.length > 50 &&
+            !text.includes('sk-planted-secret') &&
+            text.includes('***') &&
+            !rows.some((r) => r.id === 'storage.root') &&
+            rows.every((r) => FieldSchema.safeParse(r.field).success), 'the rows: every setting with a Field, secrets as ***, the data folder through its own row');
+        const page = settingsPage(listed);
+        const edit = page.sections.flatMap((s) => s.items ?? []).find((i) => i.id === 'sandbox.memoryMb')?.primary;
+        t.check(page.sections.length >= 5 &&
+            edit?.kind === 'operation' &&
+            edit.op === 'settings.set' &&
+            edit.fields?.[0]?.name === 'value' &&
+            page.sections.some((s) => s.items?.some((i) => i.id === '@data-folder')), 'the settings page: a section per category, each setting edited through its Field');
+        t.equal(ago(NOW - 90 * 60000, NOW), '2 h ago', 'times read the same on every surface');
+    },
+};

package/dist/selftest/channel.test.js

@@ -108,6 +108,19 @@ export const channelSuite = {
             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 copying = (...chunks) => {
+            const f = new OutputFilter({ clipboardWrites: true });
+            return Buffer.concat(chunks.map((s) => f.push(Buffer.from(s, 'latin1')))).toString('latin1');
+        };
+        const big = 'QUFB'.repeat(50000);
+        t.equal([
+            copying('a\x1b]52;c;ZXZpbA==\x07b'),
+            copying('x\x1b]5', '2;c;cGF5\x1b', '\\y'),
+            copying('x\x1b]52;c;' + big + '\x07y').length,
+            copying('x\x1b]52;c;?\x07y'),
+            copying('x\x1b]52;c;' + 'A'.repeat(1100000) + '\x07y'),
+            copying('x\x1bP1$qm\x1b\\y\x1b]9;9;macro\x07z'),
+        ], ['a\x1b]52;c;ZXZpbA==\x07b', 'x\x1b]52;c;cGF5\x1b\\y', big.length + 10, 'xy', 'xy', 'xyz'], "with clipboard writes allowed: the agent's copy passes (split, long), a clipboard read or a huge one never does, other strings stay dropped");
         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');

package/dist/selftest/cli.test.js

@@ -13,7 +13,8 @@ import { ago, colorEnabled, shorten } from '../cli/output/index.js';
 import { versionText } from '../cli/version.js';
 import { hoistConfig, withoutConfig } from '../cli/argv.js';
 import { closest, validNodeSpec, validPythonSpec } from '../cli/validate.js';
-import { CATEGORIES, editConfigText, SchemaNode, SETTINGS_ELSEWHERE } from '../cli/menu/settings/index.js';
+import { CATEGORIES, editConfigText, SETTINGS_ELSEWHERE } from '../app/features/settings/index.js';
+import { SchemaNode } from '../app/kernel/index.js';
 import { Frame, ListScreen, Text, TextScreen } from '../cli/tui/index.js';
 import { ConfigSchema, LocalOverridesSchema } from '../core/schema/index.js';
 export const cliSuite = {

package/dist/selftest/config.test.js

@@ -1,7 +1,9 @@
 // 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 fs from 'node:fs';
 import { DEFAULTS, loadConfig } from '../core/config/index.js';
+import { diffText, exportSettings, planImport } from '../cli/menu/settings/index.js';
 import { readJsonc } from '../core/util/index.js';
 export const configSuite = {
     name: 'config',
@@ -33,6 +35,63 @@ export const configSuite = {
         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.section('export and import of settings');
+        const SECRET = 'sk-test-0123456789';
+        const mine = loadConfig(t.writeJson(t.at('share', 'mine.json'), {
+            storage: { root: t.dir('share', 'storage') },
+            sandbox: { memoryMb: 4096, headless: true },
+            toolchains: { rust: { enabled: false } },
+            mappings: [{ host: 'C:\\Somebody\\Folder', guest: 'C:\\Folder', readOnly: false }],
+            harnesses: {
+                planted: { npmPackage: 'planted', npmBin: 'planted', arguments: [], environment: { PLANTED_KEY: SECRET } },
+            },
+        })).config;
+        const exported = exportSettings(mine, false);
+        const flat = JSON.stringify(exported.data);
+        t.check(!flat.includes(SECRET) && !flat.includes('storage') && !flat.includes('Somebody'), 'an export has no secret, no storage folder and no folder of this PC', flat);
+        t.equal([exported.data.sandbox, exported.data.toolchains, exported.data.defaultHarness], [{ memoryMb: 4096, headless: true }, { rust: { enabled: false } }, undefined], 'an export keeps only what differs from the defaults');
+        t.equal(exported.skipped.map((x) => x.why).sort(), ['machine', 'path', 'secret'], 'an export says what it left out (the data folder, a folder of this PC, a secret)');
+        t.check(JSON.stringify(exportSettings(mine, true).data).includes('Somebody'), '--with-paths keeps folders of this PC (secrets and the data folder stay out)');
+        const shared = JSON.stringify({
+            $schema: './config.schema.json',
+            sandbox: { memoryMb: 2048, headless: false },
+            storage: { root: 'D:\\elsewhere' },
+            mappings: [{ host: 'D:\\theirs', guest: 'C:\\T', readOnly: false }],
+            harnesses: { planted: { environment: { PLANTED_KEY: 'theirs' } } },
+            toolchains: { rust: { enabled: false } },
+        });
+        const plan = planImport(shared, mine);
+        t.equal(diffText(plan.lines), ['sandbox.memoryMb: 4096 -> 2048', 'sandbox.headless: true -> false'], 'an import shows old -> new for each changed setting and nothing for the unchanged ones');
+        t.equal(plan.skipped.map((x) => x.why).sort(), ['machine', 'path', 'secret'], 'an import skips secrets, the data folder and paths even when the file has them');
+        t.check(planImport('{"sandbox": {"noSuchThing": 1}}', mine).problems.length > 0 &&
+            planImport('[1]', mine).problems.length > 0 &&
+            planImport('{', mine).problems.length > 0, 'an import refuses a file that is not valid settings');
+        const home = t.dir('share', 'home');
+        const baseEnv = Object.fromEntries(Object.entries(process.env).filter(([k]) => !['AGENT_SANDBOX_CONFIG', 'AGENT_WORKSPACE'].includes(k)));
+        const env = { ...baseEnv, AGENT_SANDBOX_HOME: home, NO_COLOR: '1', AGENT_SANDBOX_HOST_ONLY: '1' };
+        const yours = t.writeJson(t.at('share', 'yours.json'), {
+            storage: { root: t.dir('share', 'storage2') },
+            sandbox: { memoryMb: 4096 },
+        });
+        const sharedFile = t.at('share', 'theirs.json');
+        fs.writeFileSync(sharedFile, shared);
+        const bin = (args) => f.runBin('agent-sandbox', [...args, '--config', yours], { cwd: f.workA, env });
+        const outFile = t.at('share', 'out.json');
+        const exportRun = await bin(['config', 'export', outFile]);
+        const written = readJsonc(outFile);
+        t.check(exportRun.status === 0 && written.sandbox?.memoryMb === 4096 && written.storage === undefined, 'sandbox config export writes the file without the data folder', exportRun.out);
+        const again = await bin(['config', 'export', outFile]);
+        t.check(again.status !== 0, 'export does not overwrite a file that is there', again.out);
+        const before = fs.readFileSync(yours, 'utf8');
+        const refused = await bin(['config', 'import', sharedFile]);
+        t.check(refused.status !== 0 && fs.readFileSync(yours, 'utf8') === before, 'import without --yes and without a terminal changes nothing', refused.out);
+        const imported = await bin(['config', 'import', sharedFile, '--yes']);
+        const after = readJsonc(yours);
+        t.check(imported.status === 0 &&
+            imported.out.includes('sandbox.memoryMb: 4096 -> 2048') &&
+            after.sandbox?.memoryMb === 2048 &&
+            after.storage?.root !== 'D:\\elsewhere' &&
+            after.mappings === undefined, 'sandbox config import --yes applies the settings and never the data folder or paths', imported.out);
         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');

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

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