windows-development-sandbox 1.4.1 → 1.4.3

package/dist/cli/menu/menu.js

@@ -0,0 +1,185 @@
+// The interactive menu (`sandbox` with no arguments): a full-screen app. The home screen groups everything into
+// categories (start, sessions, sandbox, apps, settings ...); commands open as a form that shows the exact command line,
+// which then runs like typing it. Settings and the project's .sandbox-config.json are edited in place.
+import fs from 'node:fs';
+import path from 'node:path';
+import { errMsg, plainText } from '../../core/util/index.js';
+import { loadConfig } from '../../core/config/index.js';
+import { SandboxChannel } from '../../host/channel/index.js';
+import { isSandboxRunning } from '../../host/sandbox/index.js';
+import { syncAgentCommands } from '../commands/agent-commands.js';
+import { commandLine, readHistory } from '../history.js';
+import { COMMANDS, commandSpec } from '../manifest.js';
+import { App, ExitRequested, Frame, Text, Theme } from '../tui/index.js';
+import { AppsCatalogue, appsSummary } from './apps.js';
+import { CommandForm } from './command-form.js';
+import { ConfigFile, SettingsEditor } from './settings/index.js';
+import { SeveralAgents } from './several.js';
+import { CATEGORY_OF_GROUP, TITLES, CATEGORIES } from './home.js';
+export class Menu {
+    ctx;
+    runArgv;
+    app = new App();
+    last;
+    /** The result of the last action (saved apps ...), shown on the home screen once. */
+    notice;
+    constructor(ctx, runArgv) {
+        this.ctx = ctx;
+        this.runArgv = runArgv;
+        this.app.status = () => this.status();
+        try {
+            Frame.version =
+                JSON.parse(fs.readFileSync(path.join(ctx.packageRoot, 'package.json'), 'utf8'))
+                    .version ?? '';
+        }
+        catch {
+            /* no version shown */
+        }
+    }
+    status() {
+        const folder = Theme.muted(Text.middle(process.cwd(), 70));
+        if (!isSandboxRunning())
+            return Theme.muted(Theme.glyph.off + ' No sandbox running') + '   ' + folder;
+        const n = new SandboxChannel(this.ctx.dataPath).runningSessions().length;
+        return (Theme.ok(Theme.glyph.on + ' Sandbox running') +
+            Theme.muted(' · ' + n + ' session' + (n === 1 ? '' : 's')) +
+            '   ' +
+            folder);
+    }
+    /** Is this agent already in the sandbox's persistent storage (so starting it needs no install)? */
+    installed(name) {
+        const h = this.ctx.loaded.config.harnesses[name];
+        const dir = path.join(this.ctx.dataPath, 'tools', 'agents', name);
+        return (Boolean(h) &&
+            [h.hostExecutable, h.npmBin && h.npmBin + '.cmd', h.uvBin && h.uvBin + '.exe'].some((f) => f && fs.existsSync(path.join(dir, f))));
+    }
+    homeItems() {
+        const config = this.ctx.loaded.config;
+        const def = config.defaultHarness;
+        const last = readHistory()[0];
+        const items = [];
+        const add = (category, section, label, action, description, hint) => {
+            items.push({ value: JSON.stringify(action), label, category, section, description, hint });
+        };
+        if (last)
+            add('start', 'Quick start', 'Repeat last', { kind: 'run', argv: last.argv }, 'Runs the last command again.', Theme.muted(Text.truncate(commandLine(last.argv), 50)));
+        add('start', 'Quick start', 'Start ' + def + ' in this folder', { kind: 'run', argv: ['launch', '--harness', def] }, 'Starts ' + def + ' in a sandbox for ' + process.cwd() + ' (or another session in the running sandbox).', this.installed(def) ? Theme.ok('ready') : Theme.muted('installs on first start'));
+        add('start', 'Quick start', 'Start ' + def + ' with options…', { kind: 'form', command: 'launch', preset: ['--harness', def] }, 'Choose options first: attach this terminal, Node or Python version, databases, scripts ...');
+        add('start', 'Quick start', 'Start several agents…', { kind: 'several' }, 'One or more projects, one or more agents each, all in one sandbox; attach to any of them.');
+        for (const name of Object.keys(config.harnesses).filter((n) => n !== def))
+            add('start', 'Other agents', 'Start ' + name, { kind: 'form', command: 'launch', preset: ['--harness', name] }, 'Opens the start form for ' + name + '.', this.installed(name) ? Theme.ok('ready') : Theme.muted('installs on first start'));
+        if (isSandboxRunning()) {
+            for (const s of new SandboxChannel(this.ctx.dataPath).runningSessions().slice(-12)) {
+                add('sessions', 'Running now', plainText(s.harness) + ' · ' + plainText(path.win32.basename(s.cwd)), { kind: 'run', argv: ['attach', plainText(s.id)] }, 'Shows this session in this terminal (Ctrl+] detaches; the session keeps running).', Theme.muted(plainText(s.id)));
+            }
+        }
+        const userFile = ConfigFile.user(this.ctx.loaded.configPath);
+        add('apps', 'Apps', 'Browse the apps catalogue…', { kind: 'apps', target: 'user' }, 'Tick the apps every sandbox should have: by category, searchable, with sizes. Each downloads once and is kept.', Theme.muted(appsSummary(userFile)));
+        add('apps', 'Apps', 'Apps for this project only…', { kind: 'apps', target: 'project' }, 'Catalogue apps this project needs (saved in its .sandbox-config.json, added to yours).');
+        add('settings', 'Settings', 'Settings for all projects', { kind: 'settings', target: 'user' }, "Your own settings, used by every project: languages, databases, the sandbox machine, agents, security ... (Tab switches to this project's.)", Theme.scopeGlobal(' YOURS '));
+        add('settings', 'Settings', 'Settings for this project', { kind: 'settings', target: 'project' }, "This folder's .sandbox-config.json: only what a project may set, on top of yours. A changed file needs your approval at the next launch. (Tab switches to all projects.)", Theme.scopeProject(' PROJECT '));
+        for (const spec of COMMANDS.filter((s) => !s.hidden && s.name !== 'launch')) {
+            const category = CATEGORY_OF_GROUP[spec.group];
+            const section = category === 'start' ? 'More' : category === 'settings' ? 'Tools' : 'Commands';
+            add(category, section, TITLES[spec.name] ?? Text.humanize(spec.name), { kind: 'form', command: spec.name }, spec.summary.replace(/^./, (c) => c.toUpperCase()) + '.', Theme.muted('sandbox ' + spec.name));
+        }
+        return items;
+    }
+    /** Runs the menu until you leave it, or until a command that takes over the terminal (launch, attach) has run. */
+    async start() {
+        if (!process.stdin.isTTY) {
+            console.log('The menu needs an interactive terminal. Run sandbox --help for the commands.');
+            return 1;
+        }
+        try {
+            for (;;) {
+                const picked = await this.app.list({
+                    path: [],
+                    items: this.homeItems(),
+                    categories: CATEGORIES,
+                    startAt: this.last,
+                    escapeLabel: 'quit',
+                    notice: this.notice,
+                });
+                this.notice = undefined;
+                if (picked.kind === 'back')
+                    return 0;
+                if (picked.kind !== 'pick')
+                    continue;
+                this.last = picked.value;
+                const code = await this.perform(JSON.parse(picked.value));
+                if (code !== undefined)
+                    return code;
+            }
+        }
+        catch (e) {
+            // Ctrl+C anywhere: leave quietly.
+            if (e instanceof ExitRequested || (e instanceof Error && e.name === 'ExitPromptError'))
+                return 130;
+            throw e;
+        }
+        finally {
+            this.app.close();
+        }
+    }
+    fileFor(target) {
+        return target === 'user' ? ConfigFile.user(this.ctx.loaded.configPath) : ConfigFile.project(process.cwd());
+    }
+    /** Does what a home entry says. A number ends the menu with that exit code. */
+    async perform(action) {
+        if (action.kind === 'settings') {
+            await new SettingsEditor(this.app, { user: this.fileFor('user'), project: this.fileFor('project') }, action.target, this.ctx.dataPath).run();
+            this.applyAgentCommands();
+            return undefined;
+        }
+        if (action.kind === 'apps') {
+            this.notice = await new AppsCatalogue(this.app, this.fileFor(action.target), this.ctx.dataPath).run();
+            return undefined;
+        }
+        const argv = action.kind === 'run'
+            ? action.argv
+            : action.kind === 'several'
+                ? await new SeveralAgents(this.app, this.ctx).run()
+                : await new CommandForm(this.app, this.ctx, commandSpec(action.command), action.preset).run();
+        return argv ? this.execute(argv) : undefined;
+    }
+    /** Runs an argv like typing it, on the normal screen; the menu comes back afterwards unless the command took over. */
+    async execute(argv) {
+        const code = await this.app.suspend(async () => {
+            process.stdout.write('\x1b[2J\x1b[3J\x1b[H' + Theme.muted('$ ' + commandLine(argv)) + '\n\n');
+            return this.runArgv(argv);
+        });
+        if (commandSpec(argv[0])?.interactive)
+            return code;
+        await pressAnyKey((code === 0 ? Theme.ok('Done.') : Theme.warn('Exit code ' + code + '.')) +
+            Theme.muted(' Press any key for the menu…'));
+        return undefined;
+    }
+    /** The settings screen may have switched agentCommands (Beta): apply it now, from the saved file. */
+    applyAgentCommands() {
+        try {
+            syncAgentCommands(this.ctx, loadConfig(this.ctx.loaded.configPath ?? undefined).config);
+        }
+        catch (e) {
+            console.warn('Agent commands (Beta): ' + errMsg(e));
+        }
+    }
+}
+/** Waits for one key on the normal screen, so a command's output stays until you have read it. Ctrl+C leaves. */
+function pressAnyKey(message) {
+    return new Promise((resolve, reject) => {
+        process.stdout.write('\n' + message);
+        const { stdin } = process;
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.once('data', (key) => {
+            stdin.setRawMode(false);
+            stdin.pause();
+            process.stdout.write('\n');
+            if (key[0] === 3)
+                reject(new ExitRequested());
+            else
+                resolve();
+        });
+    });
+}

package/dist/cli/menu/settings/categories.d.ts

@@ -5,5 +5,5 @@ export interface SettingsCategory {
     keys: string[];
 }
 export declare const CATEGORIES: SettingsCategory[];
-export declare const nameOf: (key: string) => string;
-export declare const categoryOf: (topKey: string) => SettingsCategory | undefined;
+export declare function nameOf(key: string): string;
+export declare function categoryOf(topKey: string): SettingsCategory | undefined;

package/dist/cli/menu/settings/categories.js

@@ -2,27 +2,130 @@
 // top-level setting of both files must belong to a category (a self-test checks it), so nothing is ever hidden.
 import { Text } from '../../tui/index.js';
 export const CATEGORIES = [
-    { id: 'general', label: 'General', description: 'Which agent starts, where the project appears in the sandbox, and extra folders from this PC.', keys: ['defaultHarness', 'harness', 'guestWorkspace', 'readOnly', 'mappings', 'scripts'] },
-    { id: 'machine', label: 'Sandbox machine', description: 'Memory, CPU, window, GPU, clipboard, audio and network of the sandbox itself.', keys: ['sandbox'] },
-    { id: 'languages', label: 'Languages & tools', description: 'Toolchains installed in the sandbox. "auto" follows your project\'s files and what this PC has.', keys: ['toolchains'] },
-    { id: 'apps', label: 'Apps', description: 'Desktop apps installed in the sandbox: editors, database clients, API clients, game engines ... (also: Apps catalogue on the home screen).', keys: ['apps'] },
-    { id: 'databases', label: 'Databases', description: 'Databases that run inside the sandbox. Their data persists between sandboxes.', keys: ['databases'] },
-    { id: 'agents', label: 'Agents & attaching', description: 'The agents you can start, attaching your terminal to them, and the (Beta) agent commands.', keys: ['harnesses', 'attach', 'agentCommands'] },
-    { id: 'claude', label: 'Claude profile', description: 'Which of your Claude settings, history and memory are copied in and synced back.', keys: ['claudeProfile'] },
-    { id: 'network', label: 'Network', description: 'What the sandbox can reach: your LAN, only some hosts, blocked hosts, DNS, a proxy, and ports forwarded from this PC to servers inside. (No network at all: Sandbox machine > Networking.)', keys: ['network'] },
-    { id: 'security', label: 'Security & privacy', description: 'Git-ignored files kept out, secrets kept out of the sandbox, download checks and what is kept on this PC.', keys: ['workspaceFilter', 'audit', 'secrets', 'downloads', 'storage'] },
-    { id: 'setup', label: 'Setup & hooks', description: 'How tools get into the sandbox (copied from this PC or downloaded), Git, the terminal, and hook scripts.', keys: ['provisioning', 'hooks'] },
-    { id: 'projects', label: 'Projects', description: 'Several projects in one sandbox: project roots mapped at every start, adding folders while it runs.', keys: ['projects'] },
-    { id: 'desktop', label: 'Desktop look', description: 'Copy your theme, accent colour, taskbar and wallpaper into the sandbox.', keys: ['personalization'] },
+    {
+        id: 'general',
+        label: 'General',
+        description: 'Which agent starts, where the project appears in the sandbox, and extra folders from this PC.',
+        keys: ['defaultHarness', 'harness', 'guestWorkspace', 'readOnly', 'mappings', 'scripts'],
+    },
+    {
+        id: 'machine',
+        label: 'Sandbox machine',
+        description: 'Memory, CPU, window, GPU, clipboard, audio and network of the sandbox itself.',
+        keys: ['sandbox'],
+    },
+    {
+        id: 'languages',
+        label: 'Languages & tools',
+        description: 'Toolchains installed in the sandbox. "auto" follows your project\'s files and what this PC has.',
+        keys: ['toolchains'],
+    },
+    {
+        id: 'apps',
+        label: 'Apps',
+        description: 'Desktop apps installed in the sandbox: editors, database clients, API clients, game engines ... (also: Apps catalogue on the home screen).',
+        keys: ['apps'],
+    },
+    {
+        id: 'databases',
+        label: 'Databases',
+        description: 'Databases that run inside the sandbox. Their data persists between sandboxes.',
+        keys: ['databases'],
+    },
+    {
+        id: 'agents',
+        label: 'Agents & attaching',
+        description: 'The agents you can start, attaching your terminal to them, and the (Beta) agent commands.',
+        keys: ['harnesses', 'attach', 'agentCommands'],
+    },
+    {
+        id: 'claude',
+        label: 'Claude profile',
+        description: 'Which of your Claude settings, history and memory are copied in and synced back.',
+        keys: ['claudeProfile'],
+    },
+    {
+        id: 'network',
+        label: 'Network',
+        description: 'What the sandbox can reach: your LAN, only some hosts, blocked hosts, DNS, a proxy, and ports forwarded from this PC to servers inside. (No network at all: Sandbox machine > Networking.)',
+        keys: ['network'],
+    },
+    {
+        id: 'security',
+        label: 'Security & privacy',
+        description: 'Git-ignored files kept out, secrets kept out of the sandbox, download checks and what is kept on this PC.',
+        keys: ['workspaceFilter', 'audit', 'secrets', 'downloads', 'storage'],
+    },
+    {
+        id: 'setup',
+        label: 'Setup & hooks',
+        description: 'How tools get into the sandbox (copied from this PC or downloaded), Git, the terminal, and hook scripts.',
+        keys: ['provisioning', 'hooks'],
+    },
+    {
+        id: 'projects',
+        label: 'Projects',
+        description: 'Several projects in one sandbox: project roots mapped at every start, adding folders while it runs.',
+        keys: ['projects'],
+    },
+    {
+        id: 'desktop',
+        label: 'Desktop look',
+        description: 'Copy your theme, accent colour, taskbar and wallpaper into the sandbox.',
+        keys: ['personalization'],
+    },
 ];
 /** Readable names for sections and toolchains (anything missing gets a name made from its key). */
 const NAMES = {
-    sandbox: 'Sandbox machine', attach: 'Attaching your terminal', agentCommands: 'Agent commands (Beta)', provisioning: 'Provisioning', downloads: 'Downloads',
-    secrets: 'Secrets', claudeProfile: 'Claude profile', storage: 'Storage on this PC', network: 'Network', hooks: 'Hooks', personalization: 'Desktop look',
-    projects: 'Projects', harnesses: 'Agents', databases: 'Databases', toolchains: 'Toolchains', git: 'Git', terminal: 'Windows Terminal', conpty: 'Pseudo console',
-    node: 'Node.js', python: 'Python', java: 'Java (JDK)', dotnet: '.NET', go: 'Go', rust: 'Rust', cpp: 'C / C++ (MinGW)', msvc: 'Visual C++ (MSVC)', ruby: 'Ruby',
-    php: 'PHP', deno: 'Deno', bun: 'Bun', pwsh: 'PowerShell 7', vscode: 'VS Code', mesa: 'OpenGL (Mesa)', uv: 'uv', pnpm: 'pnpm', yarn: 'Yarn', cli: 'Command-line tools',
-    postgres: 'PostgreSQL', mysql: 'MySQL', mongodb: 'MongoDB', redis: 'Redis', dynamodb: 'DynamoDB Local', environment: 'Environment variables', workspaceFilter: 'Git-ignored files', audit: 'Audit log',
+    sandbox: 'Sandbox machine',
+    attach: 'Attaching your terminal',
+    agentCommands: 'Agent commands (Beta)',
+    provisioning: 'Provisioning',
+    downloads: 'Downloads',
+    secrets: 'Secrets',
+    claudeProfile: 'Claude profile',
+    storage: 'Storage on this PC',
+    network: 'Network',
+    hooks: 'Hooks',
+    personalization: 'Desktop look',
+    projects: 'Projects',
+    harnesses: 'Agents',
+    databases: 'Databases',
+    toolchains: 'Toolchains',
+    git: 'Git',
+    terminal: 'Windows Terminal',
+    conpty: 'Pseudo console',
+    node: 'Node.js',
+    python: 'Python',
+    java: 'Java (JDK)',
+    dotnet: '.NET',
+    go: 'Go',
+    rust: 'Rust',
+    cpp: 'C / C++ (MinGW)',
+    msvc: 'Visual C++ (MSVC)',
+    ruby: 'Ruby',
+    php: 'PHP',
+    deno: 'Deno',
+    bun: 'Bun',
+    pwsh: 'PowerShell 7',
+    vscode: 'VS Code',
+    mesa: 'OpenGL (Mesa)',
+    uv: 'uv',
+    pnpm: 'pnpm',
+    yarn: 'Yarn',
+    cli: 'Command-line tools',
+    postgres: 'PostgreSQL',
+    mysql: 'MySQL',
+    mongodb: 'MongoDB',
+    redis: 'Redis',
+    dynamodb: 'DynamoDB Local',
+    environment: 'Environment variables',
+    workspaceFilter: 'Git-ignored files',
+    audit: 'Audit log',
 };
-export const nameOf = (key) => NAMES[key] ?? Text.humanize(key);
-export const categoryOf = (topKey) => CATEGORIES.find((c) => c.keys.includes(topKey));
+export function nameOf(key) {
+    return NAMES[key] ?? Text.humanize(key);
+}
+export function categoryOf(topKey) {
+    return CATEGORIES.find((c) => c.keys.includes(topKey));
+}

package/dist/cli/menu/settings/collections/collection-editor.d.ts

@@ -0,0 +1,23 @@
+import { type App, type ListItem } from '../../../tui/index.js';
+import { type SchemaNode } from '../schema-node.js';
+import type { ValueEditor, Edited } from '../value-editor.js';
+/**
+ * The shared shape of the list and map editors: a working copy shown as a list with "Save" and "Add" at the top, Enter
+ * to change an entry, d to delete it. Esc with unsaved changes asks first.
+ */
+export declare abstract class CollectionEditor<C> {
+    protected readonly app: App;
+    protected readonly path: string[];
+    protected readonly node: SchemaNode;
+    protected readonly editor: ValueEditor;
+    protected value: C;
+    private original;
+    constructor(app: App, path: string[], node: SchemaNode, editor: ValueEditor);
+    protected abstract entries(): ListItem<string>[];
+    protected abstract add(): Promise<void>;
+    protected abstract open(id: string): Promise<void>;
+    protected abstract remove(id: string): void;
+    protected move?(id: string, by: number): string | undefined;
+    protected noun: string;
+    run(start: C): Promise<Edited>;
+}

package/dist/cli/menu/settings/collections/collection-editor.js

@@ -0,0 +1,89 @@
+import _ from 'lodash';
+import { Theme } from '../../../tui/index.js';
+import { SAVE, ADD } from '../editor-actions.js';
+/**
+ * The shared shape of the list and map editors: a working copy shown as a list with "Save" and "Add" at the top, Enter
+ * to change an entry, d to delete it. Esc with unsaved changes asks first.
+ */
+export class CollectionEditor {
+    app;
+    path;
+    node;
+    editor;
+    value;
+    original;
+    constructor(app, path, node, editor) {
+        this.app = app;
+        this.path = path;
+        this.node = node;
+        this.editor = editor;
+    }
+    noun = 'entry';
+    async run(start) {
+        this.original = structuredClone(start);
+        this.value = structuredClone(start);
+        let focus;
+        for (;;) {
+            const dirty = !_.isEqual(this.value, this.original);
+            const entries = this.entries();
+            const picked = await this.app.list({
+                path: this.path,
+                intro: this.node.description,
+                items: [
+                    {
+                        value: SAVE,
+                        label: dirty
+                            ? Theme.ok(Theme.glyph.ok + ' Save changes')
+                            : Theme.muted(Theme.glyph.ok + ' Done (no changes)'),
+                        section: 'Actions',
+                    },
+                    { value: ADD, label: '+ Add ' + this.noun, section: 'Actions' },
+                    ...entries.map((e) => ({
+                        ...e,
+                        section: entries.length + ' ' + this.noun + (entries.length === 1 ? '' : 's'),
+                    })),
+                ],
+                startAt: focus,
+                actions: [
+                    { key: 'd', label: 'delete' },
+                    ...(this.move
+                        ? [
+                            { key: 'u', label: 'move up' },
+                            { key: 'j', label: 'move down' },
+                        ]
+                        : []),
+                ],
+                empty: 'No ' + this.noun + 's yet.',
+            });
+            if (picked.kind === 'back') {
+                if (!dirty ||
+                    (await this.app.confirm({
+                        path: this.path,
+                        question: 'Discard your changes?',
+                        yes: 'Discard',
+                        no: 'Keep editing',
+                        initial: false,
+                        danger: true,
+                    })))
+                    return undefined;
+                continue;
+            }
+            if (picked.kind === 'pick' && picked.value === SAVE)
+                return dirty ? { value: this.value } : undefined;
+            if (picked.kind === 'pick' && picked.value === ADD) {
+                await this.add();
+                continue;
+            }
+            const id = picked.kind === 'pick' || picked.kind === 'action' ? picked.value : undefined;
+            if (id === undefined || id === SAVE || id === ADD)
+                continue;
+            focus = id;
+            if (picked.kind === 'pick')
+                await this.open(id);
+            else if (picked.kind === 'action' && picked.key === 'd')
+                this.remove(id);
+            else if (picked.kind === 'action' && this.move)
+                focus = this.move(id, picked.key === 'u' ? -1 : 1) ?? id;
+        }
+    }
+}

package/dist/cli/menu/settings/collections/map-editor.d.ts

@@ -0,0 +1,10 @@
+import { type ListItem } from '../../../tui/index.js';
+import { CollectionEditor } from './collection-editor.js';
+/** A map of names to simple values (environment variables). */
+export declare class MapEditor extends CollectionEditor<Record<string, unknown>> {
+    protected noun: string;
+    protected entries(): ListItem<string>[];
+    protected add(): Promise<void>;
+    protected open(id: string): Promise<void>;
+    protected remove(id: string): void;
+}

package/dist/cli/menu/settings/collections/map-editor.js

@@ -0,0 +1,34 @@
+import { CollectionEditor } from './collection-editor.js';
+import { formatValue } from '../format.js';
+/** A map of names to simple values (environment variables). */
+export class MapEditor extends CollectionEditor {
+    noun = 'variable';
+    entries() {
+        return Object.entries(this.value).map(([k, v]) => ({ value: k, label: k, hint: formatValue(v) }));
+    }
+    async add() {
+        const name = await this.app.text({
+            path: this.path,
+            label: 'Name',
+            about: ['Letters, digits and _ only, e.g. NPM_CONFIG_REGISTRY.'],
+            validate: (v) => this.value[v] !== undefined
+                ? 'That name is there already.'
+                : /^[A-Za-z_][A-Za-z0-9_]*$/.test(v)
+                    ? true
+                    : 'Letters, digits and _ only.',
+        });
+        if (name === undefined)
+            return;
+        const edited = await this.editor.edit([...this.path, name], [name], this.node.element, this.node.element.initial());
+        if (edited)
+            this.value[name] = edited.value;
+    }
+    async open(id) {
+        const edited = await this.editor.edit([...this.path, id], [id], this.node.element, this.value[id]);
+        if (edited)
+            this.value[id] = edited.value;
+    }
+    remove(id) {
+        delete this.value[id];
+    }
+}

package/dist/cli/menu/settings/collections/object-list-editor.d.ts

@@ -0,0 +1,10 @@
+import { type ListItem } from '../../../tui/index.js';
+import { CollectionEditor } from './collection-editor.js';
+/** A list of objects (mapped folders). */
+export declare class ObjectListEditor extends CollectionEditor<Record<string, unknown>[]> {
+    protected noun: string;
+    protected entries(): ListItem<string>[];
+    protected add(): Promise<void>;
+    protected open(id: string): Promise<void>;
+    protected remove(id: string): void;
+}

package/dist/cli/menu/settings/collections/object-list-editor.js

@@ -0,0 +1,23 @@
+import { CollectionEditor } from './collection-editor.js';
+import { summary } from '../format.js';
+import { ObjectEditor } from '../object-editor.js';
+/** A list of objects (mapped folders). */
+export class ObjectListEditor extends CollectionEditor {
+    noun = 'entry';
+    entries() {
+        return this.value.map((v, i) => ({ value: String(i), label: summary(v) }));
+    }
+    async add() {
+        const edited = await new ObjectEditor(this.app, [...this.path, 'New'], this.node.element, this.editor).run(this.node.element.initial(), true);
+        if (edited)
+            this.value.push(edited.value);
+    }
+    async open(id) {
+        const edited = await new ObjectEditor(this.app, [...this.path, summary(this.value[Number(id)])], this.node.element, this.editor).run(this.value[Number(id)]);
+        if (edited)
+            this.value[Number(id)] = edited.value;
+    }
+    remove(id) {
+        this.value.splice(Number(id), 1);
+    }
+}

package/dist/cli/menu/settings/collections/object-map-editor.d.ts

@@ -0,0 +1,10 @@
+import { type ListItem } from '../../../tui/index.js';
+import { CollectionEditor } from './collection-editor.js';
+/** A map of names to objects (agents). */
+export declare class ObjectMapEditor extends CollectionEditor<Record<string, Record<string, unknown>>> {
+    protected noun: string;
+    protected entries(): ListItem<string>[];
+    protected add(): Promise<void>;
+    protected open(id: string): Promise<void>;
+    protected remove(id: string): void;
+}

package/dist/cli/menu/settings/collections/object-map-editor.js

@@ -0,0 +1,35 @@
+import { Theme } from '../../../tui/index.js';
+import { CollectionEditor } from './collection-editor.js';
+import { summary } from '../format.js';
+import { ObjectEditor } from '../object-editor.js';
+/** A map of names to objects (agents). */
+export class ObjectMapEditor extends CollectionEditor {
+    noun = 'entry';
+    entries() {
+        return Object.entries(this.value).map(([k, v]) => ({ value: k, label: k, hint: Theme.muted(summary(v)) }));
+    }
+    async add() {
+        const name = await this.app.text({
+            path: this.path,
+            label: 'Name',
+            validate: (v) => this.value[v] !== undefined
+                ? 'That name is there already.'
+                : /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(v)
+                    ? true
+                    : 'Letters, digits, . _ and - only.',
+        });
+        if (name === undefined)
+            return;
+        const edited = await new ObjectEditor(this.app, [...this.path, name], this.node.element, this.editor).run(this.node.element.initial(), true);
+        if (edited)
+            this.value[name] = edited.value;
+    }
+    async open(id) {
+        const edited = await new ObjectEditor(this.app, [...this.path, id], this.node.element, this.editor).run(this.value[id]);
+        if (edited)
+            this.value[id] = edited.value;
+    }
+    remove(id) {
+        delete this.value[id];
+    }
+}

package/dist/cli/menu/settings/collections/string-list-editor.d.ts

@@ -0,0 +1,12 @@
+import { type ListItem } from '../../../tui/index.js';
+import { CollectionEditor } from './collection-editor.js';
+/** A list of strings (project roots, scripts, extra packages ...). */
+export declare class StringListEditor extends CollectionEditor<string[]> {
+    protected noun: string;
+    protected entries(): ListItem<string>[];
+    private ask;
+    protected add(): Promise<void>;
+    protected open(id: string): Promise<void>;
+    protected remove(id: string): void;
+    protected move(id: string, by: number): string;
+}

package/dist/cli/menu/settings/collections/string-list-editor.js

@@ -0,0 +1,39 @@
+import { Theme } from '../../../tui/index.js';
+import { CollectionEditor } from './collection-editor.js';
+/** A list of strings (project roots, scripts, extra packages ...). */
+export class StringListEditor extends CollectionEditor {
+    noun = 'item';
+    entries() {
+        return this.value.map((v, i) => ({ value: String(i), label: v || Theme.muted('(empty)') }));
+    }
+    async ask(initial) {
+        const element = this.node.element;
+        return this.app.text({
+            path: this.path,
+            label: 'Value',
+            about: this.node.description ? [this.node.description] : [],
+            initial,
+            validate: (v) => element.check(v),
+        });
+    }
+    async add() {
+        const v = await this.ask('');
+        if (v !== undefined)
+            this.value.push(v);
+    }
+    async open(id) {
+        const v = await this.ask(this.value[Number(id)]);
+        if (v !== undefined)
+            this.value[Number(id)] = v;
+    }
+    remove(id) {
+        this.value.splice(Number(id), 1);
+    }
+    move(id, by) {
+        const from = Number(id);
+        const to = Math.max(0, Math.min(this.value.length - 1, from + by));
+        const [item] = this.value.splice(from, 1);
+        this.value.splice(to, 0, item);
+        return String(to);
+    }
+}