windows-development-sandbox 1.1.0 → 1.4.1

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

@@ -0,0 +1,305 @@
+// Editing one value with the screen that fits it: on/off flips, choices are picked from a list, numbers and text are
+// typed and checked as you type, lists and maps get an editor of their own (add, change, remove), and objects (a
+// mapped folder, an agent) open as a small form. JSON is only the last resort for shapes none of these fit.
+import _ from 'lodash';
+import { Text, Theme } from '../../tui/index.js';
+/** A value in one short line, for the right-hand column. */
+export const formatValue = (value, max = 60) => {
+    if (value === undefined)
+        return Theme.muted('not set');
+    if (value === true)
+        return Theme.ok('On');
+    if (value === false)
+        return Theme.muted('Off');
+    if (value === null)
+        return Theme.muted('none');
+    if (typeof value === 'string')
+        return value === '' ? Theme.muted('(empty)') : Text.truncate(value, max);
+    if (typeof value === 'number')
+        return String(value);
+    if (Array.isArray(value))
+        return value.length === 0 ? Theme.muted('none') : Text.truncate(value.length + ' · ' + value.map((v) => (typeof v === 'object' ? summary(v) : String(v))).join(', '), max);
+    const keys = Object.keys(value);
+    return keys.length ? Text.truncate(keys.length + ' · ' + keys.join(', '), max) : Theme.muted('none');
+};
+/** A one-line name for an object in a list (a mapping's folders, an agent's package ...). */
+const summary = (value) => {
+    if (!_.isPlainObject(value))
+        return String(value);
+    const o = value;
+    const strings = Object.entries(o).filter(([, v]) => typeof v === 'string' && v);
+    if (typeof o.host === 'string' && typeof o.guest === 'string')
+        return o.host + ' → ' + o.guest + (o.readOnly ? ' (read-only)' : '');
+    return strings.slice(0, 2).map(([, v]) => v).join(' · ') || '{ ' + Object.keys(o).join(', ') + ' }';
+};
+const choiceLabel = (v) => (v === true ? 'On' : v === false ? 'Off' : String(v));
+export class ValueEditor {
+    app;
+    hints;
+    constructor(app, hints = {}) {
+        this.app = app;
+        this.hints = hints;
+    }
+    async edit(path, key, node, current) {
+        const about = node.description ? [node.description] : [];
+        const suggestions = this.hints.suggestions?.(key);
+        if (suggestions?.length && node.type === 'string')
+            return this.suggest(path, key, node, current, suggestions);
+        switch (node.editor) {
+            case 'boolean': return { value: !(current ?? false) };
+            case 'choice': return this.pick(path, node, current, node.choiceValues);
+            case 'union': {
+                const open = node.openOption;
+                const custom = '@custom';
+                const picked = await this.app.choose(path, node.description ?? '', [...node.choiceValues.map((v) => ({ value: v, label: choiceLabel(v) })), ...(open ? [{ value: custom, label: 'Custom ' + open.type + '…', description: 'Type a ' + open.type + ' of your own.' }] : [])], node.choiceValues.includes(current) ? current : open && current !== undefined ? custom : undefined);
+                if (picked === undefined)
+                    return undefined;
+                return picked === custom && open ? this.edit(path, key, open, node.choiceValues.includes(current) ? undefined : current) : { value: picked };
+            }
+            case 'number': {
+                const range = node.min !== undefined || node.max !== undefined ? ' (' + (node.min ?? '…') + ' to ' + (node.max ?? '…') + ')' : '';
+                const typed = await this.app.text({ path, label: Text.humanize(key[key.length - 1]) + range, about, initial: current === undefined ? '' : String(current), validate: (v) => (v.trim() === '' || !Number.isFinite(Number(v)) ? 'Enter a number.' : node.check(Number(v))) });
+                return typed === undefined ? undefined : { value: Number(typed) };
+            }
+            case 'string': {
+                const typed = await this.app.text({ path, label: Text.humanize(key[key.length - 1]), about, initial: typeof current === 'string' ? current : '', allowEmpty: node.check('') === true, validate: (v) => node.check(v) });
+                return typed === undefined ? undefined : { value: typed };
+            }
+            case 'choice-list': {
+                const ticked = Array.isArray(current) ? current : [];
+                const picked = await this.app.list({ path, intro: node.description, multi: true, items: node.element.choices.map((v) => ({ value: v, label: String(v), checked: ticked.includes(v) })) });
+                return picked.kind === 'multi' ? { value: picked.values } : undefined;
+            }
+            case 'string-list': return new StringListEditor(this.app, path, node, this).run(Array.isArray(current) ? current : []);
+            case 'string-map': return new MapEditor(this.app, path, node, this).run(_.isPlainObject(current) ? current : {});
+            case 'object-list': return new ObjectListEditor(this.app, path, node, this).run(Array.isArray(current) ? current : []);
+            case 'object-map': return new ObjectMapEditor(this.app, path, node, this).run(_.isPlainObject(current) ? current : {});
+            case 'object': return new ObjectEditor(this.app, path, node, this).run(_.isPlainObject(current) ? current : node.initial());
+            default: return this.json(path, key, node, current);
+        }
+    }
+    async pick(path, node, current, values) {
+        const picked = await this.app.choose(path, node.description ?? '', values.map((v) => ({ value: v, label: choiceLabel(v) })), current);
+        return picked === undefined ? undefined : { value: picked };
+    }
+    async suggest(path, key, node, current, suggestions) {
+        const other = '@other';
+        const picked = await this.app.choose(path, node.description ?? '', [...suggestions.map((s) => ({ value: s, label: s })), { value: other, label: 'Other…', description: 'Type a name that is not in the list.' }], typeof current === 'string' ? current : undefined);
+        if (picked === undefined)
+            return undefined;
+        if (picked !== other)
+            return { value: picked };
+        const typed = await this.app.text({ path, label: Text.humanize(key[key.length - 1]), initial: typeof current === 'string' ? current : '', validate: (v) => node.check(v) });
+        return typed === undefined ? undefined : { value: typed };
+    }
+    async json(path, key, node, current) {
+        const typed = await this.app.text({
+            path, label: Text.humanize(key[key.length - 1]) + ' (JSON)', about: node.description ? [node.description] : [], initial: current === undefined ? '' : JSON.stringify(current),
+            validate: (v) => { try {
+                return node.check(JSON.parse(v));
+            }
+            catch {
+                return 'This is not valid JSON.';
+            } },
+        });
+        return typed === undefined ? undefined : { value: JSON.parse(typed) };
+    }
+}
+// ---- collections -----------------------------------------------------------------------------------------------------
+const SAVE = '@save';
+const ADD = '@add';
+/**
+ * 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.
+ */
+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;
+        }
+    }
+}
+/** A list of strings (project roots, scripts, extra packages ...). */
+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);
+    }
+}
+/** A map of names to simple values (environment variables). */
+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]; }
+}
+/** A list of objects (mapped folders). */
+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); }
+}
+/** A map of names to objects (agents). */
+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]; }
+}
+/** One object as a form: each field with its value, Enter to change it, r to clear an optional one. */
+export class ObjectEditor {
+    app;
+    path;
+    node;
+    editor;
+    constructor(app, path, node, editor) {
+        this.app = app;
+        this.path = path;
+        this.node = node;
+        this.editor = editor;
+    }
+    async run(start, isNew = false) {
+        const value = structuredClone(start);
+        let focus;
+        let notice;
+        for (;;) {
+            const dirty = isNew || !_.isEqual(value, start);
+            const problem = this.node.check(value);
+            const fields = this.node.children();
+            const picked = await this.app.list({
+                path: this.path,
+                intro: this.node.description,
+                notice,
+                items: [
+                    { value: SAVE, label: problem === true ? (dirty ? Theme.ok(Theme.glyph.ok + ' Save') : Theme.muted(Theme.glyph.ok + ' Done (no changes)')) : Theme.warn(Theme.glyph.cross + ' Not complete yet'), description: problem === true ? undefined : problem, section: 'Actions' },
+                    ...fields.map(([name, field]) => ({ value: name, label: Text.humanize(name), hint: formatValue(value[name]), description: field.description, section: 'Fields' })),
+                ],
+                startAt: focus,
+                actions: [{ key: 'r', label: 'clear' }],
+            });
+            notice = undefined;
+            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) {
+                if (problem !== true) {
+                    notice = Theme.warn(problem);
+                    continue;
+                }
+                return dirty ? { value } : undefined;
+            }
+            const name = picked.kind === 'pick' || picked.kind === 'action' ? picked.value : undefined;
+            if (!name || name === SAVE)
+                continue;
+            focus = name;
+            const field = this.node.child(name);
+            if (picked.kind === 'action') {
+                delete value[name];
+                continue;
+            }
+            const edited = await this.editor.edit([...this.path, Text.humanize(name)], [name], field, value[name]);
+            if (edited)
+                value[name] = edited.value;
+        }
+    }
+}

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

@@ -0,0 +1,32 @@
+import { App } from '../../tui/index.js';
+import { ConfigFile } from './config-file.js';
+import type { SchemaNode } from './schema-node.js';
+export { CATEGORIES, nameOf } from './categories.js';
+export { ConfigFile, editConfigText, fileValue, type SettingsTarget } from './config-file.js';
+export { SchemaNode } from './schema-node.js';
+interface Setting {
+    key: string[];
+    node: SchemaNode;
+    category: string;
+    section?: string;
+}
+export type Scope = 'user' | 'project';
+export declare class SettingsEditor {
+    private readonly app;
+    private readonly files;
+    private scope;
+    private readonly dataPath;
+    private readonly editor;
+    /** files: your config and this folder's project file; dataPath: where the apps catalogue looks for installed apps. */
+    constructor(app: App, files: Record<Scope, ConfigFile>, scope?: Scope, dataPath?: string);
+    /** The file the current tab edits. */
+    get file(): ConfigFile;
+    private get title();
+    /** Every editable setting with the category and heading it is shown under. */
+    settings(): Setting[];
+    private item;
+    run(): Promise<void>;
+    private edit;
+    /** Saves (or resets) one setting and returns the notice to show. */
+    private save;
+}

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

@@ -0,0 +1,136 @@
+// The settings screen: two scopes on tabs, your own settings ("All projects", blue) and this folder's
+// .sandbox-config.json ("This project", purple); Tab switches and keeps your place. Every setting is grouped into
+// categories (sidebar), searchable, with its value in both scopes, its default and description. Enter edits (on/off
+// flips at once), r resets. Edits keep the file's comments and formatting, and nothing is saved unless the whole file
+// stays valid.
+import _ from 'lodash';
+import { NEVER_LOOSER } from '../../../core/local-config.js';
+import { Text, Theme } from '../../tui/index.js';
+import { AppsCatalogue } from '../apps.js';
+import { CATEGORIES, categoryOf, nameOf } from './categories.js';
+import { formatValue, ValueEditor } from './editors.js';
+export { CATEGORIES, nameOf } from './categories.js';
+export { ConfigFile, editConfigText, fileValue } from './config-file.js';
+export { SchemaNode } from './schema-node.js';
+const SCOPES = [
+    { scope: 'user', tab: { label: 'All projects', badge: 'YOURS', paint: Theme.scopeGlobal } },
+    { scope: 'project', tab: { label: 'This project', badge: 'PROJECT', paint: Theme.scopeProject } },
+];
+export class SettingsEditor {
+    app;
+    files;
+    scope;
+    dataPath;
+    editor;
+    /** files: your config and this folder's project file; dataPath: where the apps catalogue looks for installed apps. */
+    constructor(app, files, scope = 'user', dataPath = '') {
+        this.app = app;
+        this.files = files;
+        this.scope = scope;
+        this.dataPath = dataPath;
+        this.editor = new ValueEditor(app, { suggestions: (key) => (['defaultHarness', 'harness'].includes(key.join('.')) ? Object.keys(this.file.userConfig().harnesses) : undefined) });
+    }
+    /** The file the current tab edits. */
+    get file() { return this.files[this.scope]; }
+    get title() { return 'Settings · ' + (this.file.isProject ? 'This project' : 'All projects'); }
+    /** Every editable setting with the category and heading it is shown under. */
+    settings() {
+        return this.file.schema.children().flatMap(([top, node]) => {
+            const category = categoryOf(top);
+            if (!category)
+                return [];
+            const several = category.keys.filter((k) => this.file.schema.child(k)).length > 1;
+            if (!node.isSection)
+                return [{ key: [top], node, category: category.id, section: several && category.id !== 'general' ? nameOf(top) : undefined }];
+            return node.leaves([top]).map(({ key, node: leaf }) => {
+                const heading = [several ? nameOf(top) : undefined, key.length > 2 ? key.slice(1, -1).map(nameOf).join(' › ') : undefined].filter(Boolean).join(' › ');
+                return { key, node: leaf, category: category.id, section: heading || undefined };
+            });
+        });
+    }
+    item(s, config) {
+        const inFile = this.file.valueInFile(s.key);
+        const set = inFile !== undefined;
+        const yours = _.get(config, s.key);
+        const id = s.key.join('.');
+        const project = this.files.project;
+        const inProject = project.schema.leaves().some((l) => l.key.join('.') === id) ? project.valueInFile(s.key) : undefined;
+        const paint = this.file.isProject ? Theme.project : Theme.changed;
+        const value = this.file.isProject && !set ? Theme.muted('all projects: ') + formatValue(yours, 40) : formatValue(this.file.effective(s.key, config));
+        const details = [
+            Theme.muted('Setting       ') + id,
+            Theme.muted('All projects  ') + formatValue(yours, 40) + Theme.muted(this.files.user.valueInFile(s.key) === undefined ? '  (built-in default)' : '  (your file)'),
+            Theme.muted('This project  ') + (inProject === undefined ? Theme.muted('not set') : Theme.project(Text.strip(formatValue(inProject, 40)))),
+            ...(!this.file.isProject ? [Theme.muted('Default       ') + formatValue(this.file.defaultOf(s.key), 40)] : []),
+            ...(this.file.isProject && NEVER_LOOSER.includes(id) ? [Theme.warn(Theme.glyph.lock + ' A project can only make this stricter than your own setting.')] : []),
+        ];
+        return {
+            value: id,
+            label: Text.humanize(s.key[s.key.length - 1]),
+            hint: set ? paint(Text.strip(value)) + ' ' + paint(Theme.glyph.changed) : value,
+            description: s.node.description,
+            details,
+            section: s.section,
+            category: s.category,
+            keywords: id,
+        };
+    }
+    async run() {
+        let focus;
+        let notice;
+        for (;;) {
+            const config = this.file.userConfig();
+            const settings = this.settings();
+            const categories = CATEGORIES.filter((c) => settings.some((s) => s.category === c.id)).map((c) => ({ id: c.id, label: c.label, description: c.description }));
+            const picked = await this.app.list({
+                path: [this.title],
+                tabs: { items: SCOPES.map((x) => x.tab), active: SCOPES.findIndex((x) => x.scope === this.scope) },
+                status: (this.file.isProject ? Theme.project('●') : Theme.accent('●')) + Theme.muted(' Editing ') + Text.middle(this.file.file, 80) + (this.file.exists ? '' : Theme.muted(' (created when you save)')) + (this.file.isProject ? Theme.muted('  · only what a project may set; needs your approval at the next launch') : ''),
+                items: settings.map((s) => this.item(s, config)),
+                categories,
+                startAt: focus,
+                actions: [{ key: 'r', label: this.file.isProject ? 'remove from project' : 'reset to default' }],
+                notice,
+            });
+            notice = undefined;
+            if (picked.kind === 'back')
+                return;
+            // The other tab, on the same setting when that scope has it.
+            if (picked.kind === 'tab') {
+                this.scope = SCOPES[picked.index].scope;
+                continue;
+            }
+            if (picked.kind !== 'pick' && picked.kind !== 'action')
+                continue;
+            if (picked.value === undefined)
+                continue;
+            focus = picked.value;
+            const setting = settings.find((s) => s.key.join('.') === picked.value);
+            if (picked.kind === 'action')
+                notice = this.save(setting.key, undefined, 'reset');
+            else
+                notice = await this.edit(setting, config);
+        }
+    }
+    async edit(s, config) {
+        // The apps list is picked from the catalogue (by category, with sizes), not typed.
+        if (s.key.join('.') === 'apps.install')
+            return new AppsCatalogue(this.app, this.file, this.dataPath).run();
+        const current = this.file.isProject ? this.file.valueInFile(s.key) ?? _.get(config, s.key) : _.get(config, s.key);
+        const path = [this.title, ...s.key.slice(0, -1).map(nameOf), Text.humanize(s.key[s.key.length - 1])];
+        const edited = await this.editor.edit(path, s.key, s.node, current);
+        return edited ? this.save(s.key, edited.value, 'save') : undefined;
+    }
+    /** Saves (or resets) one setting and returns the notice to show. */
+    save(key, value, how) {
+        const name = key.join('.');
+        const result = this.file.set(key, value);
+        if (result === 'unchanged')
+            return Theme.muted(how === 'reset' ? name + ' is already the default.' : 'Unchanged.');
+        if (typeof result === 'object')
+            return Theme.error(Theme.glyph.cross + ' Not saved: ' + result.problems.join('; '));
+        // The approval is tied to the file's exact contents, so any change makes the project file need approval again.
+        const after = this.file.isProject ? ' The next launch asks you to approve the project file again.' : ' New sandboxes use it.';
+        return Theme.ok(Theme.glyph.ok + ' ' + (how === 'reset' ? 'Reset ' + name + '.' : 'Saved ' + name + '.')) + Theme.muted(after);
+    }
+}

package/dist/cli/menu/settings/schema-node.d.ts

@@ -0,0 +1,62 @@
+import type { z } from 'zod';
+type Def = {
+    type: string;
+    options?: ZodLike[];
+    values?: unknown[];
+    entries?: Record<string, string>;
+    element?: ZodLike;
+    innerType?: ZodLike;
+    keyType?: ZodLike;
+    valueType?: ZodLike;
+    defaultValue?: unknown;
+    in?: ZodLike;
+    out?: ZodLike;
+};
+type ZodLike = z.ZodType & {
+    _zod: {
+        def: Def;
+    };
+    shape?: Record<string, ZodLike>;
+    description?: string;
+    minValue?: number | null;
+    maxValue?: number | null;
+};
+/** The editor a setting gets. */
+export type EditorKind = 'boolean' | 'choice' | 'union' | 'number' | 'string' | 'string-list' | 'choice-list' | 'object-list' | 'string-map' | 'object-map' | 'object' | 'json';
+export declare class SchemaNode {
+    readonly schema: ZodLike;
+    constructor(schema: unknown);
+    /** The real type under optional() / default() / nullable() / transforms. */
+    get inner(): ZodLike;
+    get type(): string;
+    /** A group of settings (an object with known fields), opened rather than edited. */
+    get isSection(): boolean;
+    /** The description, which .partial() / .optional() wrappers may carry on the inner schema instead. */
+    get description(): string | undefined;
+    get min(): number | undefined;
+    get max(): number | undefined;
+    /** The fields of an object, in schema order. */
+    children(): [string, SchemaNode][];
+    child(name: string): SchemaNode | undefined;
+    /** Every setting below this one that has an editor of its own (not a section), with its path. */
+    leaves(key?: string[]): {
+        key: string[];
+        node: SchemaNode;
+    }[];
+    /** Array items, or a map's values. */
+    get element(): SchemaNode | undefined;
+    /** Union members. */
+    get options(): SchemaNode[];
+    /** The values an enum or literal allows. */
+    get choices(): unknown[];
+    get editor(): EditorKind;
+    /** Every value a choice allows (booleans of a union included). */
+    get choiceValues(): unknown[];
+    /** The member of a union that is not a fixed value (a number, a string ...), edited after "Custom...". */
+    get openOption(): SchemaNode | undefined;
+    /** What a new entry (in a list or a map) starts as: the default if there is one, otherwise the simplest valid shape. */
+    initial(): unknown;
+    /** Is `value` acceptable here on its own? (The whole file is checked again when it is saved.) */
+    check(value: unknown): true | string;
+}
+export {};

package/dist/cli/menu/settings/schema-node.js

@@ -0,0 +1,104 @@
+/** Settings never shown (the link to the JSON Schema). */
+const HIDDEN = new Set(['$schema']);
+export class SchemaNode {
+    schema;
+    constructor(schema) { this.schema = schema; }
+    /** The real type under optional() / default() / nullable() / transforms. */
+    get inner() {
+        let s = this.schema;
+        for (;;) {
+            const def = s._zod.def;
+            if (['optional', 'default', 'nullable', 'prefault', 'readonly'].includes(def.type) && def.innerType)
+                s = def.innerType;
+            else if (def.type === 'pipe' && def.in)
+                s = def.in;
+            else
+                return s;
+        }
+    }
+    get type() { return this.inner._zod.def.type; }
+    /** A group of settings (an object with known fields), opened rather than edited. */
+    get isSection() { return this.type === 'object' && Boolean(this.inner.shape); }
+    /** The description, which .partial() / .optional() wrappers may carry on the inner schema instead. */
+    get description() { return this.schema.description ?? this.inner.description; }
+    get min() { return this.inner.minValue ?? undefined; }
+    get max() { return this.inner.maxValue ?? undefined; }
+    /** The fields of an object, in schema order. */
+    children() {
+        return Object.entries(this.inner.shape ?? {}).filter(([name]) => !HIDDEN.has(name)).map(([name, s]) => [name, new SchemaNode(s)]);
+    }
+    child(name) {
+        const s = this.inner.shape?.[name];
+        return s ? new SchemaNode(s) : undefined;
+    }
+    /** Every setting below this one that has an editor of its own (not a section), with its path. */
+    leaves(key = []) {
+        return this.children().flatMap(([name, child]) => (child.isSection ? child.leaves([...key, name]) : [{ key: [...key, name], node: child }]));
+    }
+    /** Array items, or a map's values. */
+    get element() {
+        const def = this.inner._zod.def;
+        return def.type === 'array' && def.element ? new SchemaNode(def.element) : def.type === 'record' && def.valueType ? new SchemaNode(def.valueType) : undefined;
+    }
+    /** Union members. */
+    get options() { return (this.inner._zod.def.options ?? []).map((o) => new SchemaNode(o)); }
+    /** The values an enum or literal allows. */
+    get choices() {
+        const def = this.inner._zod.def;
+        if (def.type === 'enum')
+            return Object.values(def.entries ?? {});
+        if (def.type === 'literal')
+            return def.values ?? [];
+        return [];
+    }
+    get editor() {
+        const type = this.type;
+        if (type === 'boolean')
+            return 'boolean';
+        if (type === 'enum' || type === 'literal')
+            return 'choice';
+        if (type === 'union')
+            return this.options.every((o) => ['literal', 'enum', 'boolean'].includes(o.type)) ? 'choice' : 'union';
+        if (type === 'number' || type === 'string')
+            return type;
+        const element = this.element;
+        if (type === 'array' && element)
+            return element.type === 'string' ? 'string-list' : element.type === 'enum' ? 'choice-list' : element.type === 'object' ? 'object-list' : 'json';
+        if (type === 'record' && element)
+            return ['string', 'number', 'boolean'].includes(element.type) ? 'string-map' : element.type === 'object' ? 'object-map' : 'json';
+        if (type === 'object')
+            return 'object';
+        return 'json';
+    }
+    /** Every value a choice allows (booleans of a union included). */
+    get choiceValues() {
+        if (this.type !== 'union')
+            return this.choices;
+        return this.options.flatMap((o) => (o.type === 'boolean' ? [true, false] : o.choices));
+    }
+    /** The member of a union that is not a fixed value (a number, a string ...), edited after "Custom...". */
+    get openOption() { return this.options.find((o) => !['literal', 'enum', 'boolean'].includes(o.type)); }
+    /** What a new entry (in a list or a map) starts as: the default if there is one, otherwise the simplest valid shape. */
+    initial() {
+        const def = this.schema._zod.def;
+        if (def.type === 'default')
+            return structuredClone(def.defaultValue);
+        switch (this.type) {
+            case 'boolean': return false;
+            case 'number': return this.min ?? 0;
+            case 'string': return '';
+            case 'enum':
+            case 'literal': return this.choices[0];
+            case 'union': return this.options[0]?.initial();
+            case 'array': return [];
+            case 'record': return {};
+            case 'object': return Object.fromEntries(this.children().filter(([, c]) => !['optional', 'default'].includes(c.schema._zod.def.type)).map(([name, c]) => [name, c.initial()]));
+            default: return null;
+        }
+    }
+    /** Is `value` acceptable here on its own? (The whole file is checked again when it is saved.) */
+    check(value) {
+        const result = this.schema.safeParse(value);
+        return result.success ? true : result.error.issues.map((i) => (i.path.length ? i.path.join('.') + ': ' : '') + i.message).join('; ');
+    }
+}

package/dist/cli/{menu-multi.d.ts → menu/several.d.ts}

@@ -1,4 +1,5 @@
-import type { Context } from './commands/context.js';
+import type { Context } from '../commands/context.js';
+import { App } from '../tui/index.js';
 /** Folders worth offering: this one, the projects started before, and the folders inside your roots. */
 export declare const candidateFolders: (ctx: Context, cwd?: string) => string[];
 /** The command line for several sessions: one --session per (agent, folder), with the shared options. */
@@ -9,4 +10,11 @@ export declare const severalAgentsArgv: (sessions: {
     headless: boolean;
     attachFirst: boolean;
 }) => string[];
-export declare const askSeveralAgents: (ctx: Context) => Promise<string[] | null>;
+export declare class SeveralAgents {
+    private readonly app;
+    private readonly ctx;
+    private readonly path;
+    constructor(app: App, ctx: Context);
+    run(): Promise<string[] | null>;
+    private folders;
+}