windows-development-sandbox 1.5.0 → 1.9.0

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

@@ -1,39 +1,9 @@
-import _ from 'lodash';
-import { Text, Theme } from '../../tui/index.js';
+// A value in one short line for the menu's right-hand column: the kernel's valueText, painted with the theme.
+import { valueText } from '../../../app/kernel/index.js';
+import { Theme } from '../../tui/index.js';
+export { choiceLabel, summary } from '../../../app/kernel/index.js';
 /** A value in one short line, for the right-hand column. */
 export function 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 ...). */
-export function 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(', ') + ' }');
-}
-export function choiceLabel(v) {
-    return v === true ? 'On' : v === false ? 'Off' : String(v);
+    const shown = valueText(value, undefined, max);
+    return shown.tone === 'ok' ? Theme.ok(shown.text) : shown.tone === 'muted' ? Theme.muted(shown.text) : shown.text;
 }

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

@@ -1,4 +1,2 @@
-export { CATEGORIES, nameOf } from './categories.js';
-export { ConfigFile, editConfigText, fileValue, type SettingChange, type SettingsTarget } from './config-file.js';
 export { Draft, type DraftResult } from './draft.js';
-export { SchemaNode } from './schema-node.js';
+export { diffText, exportSettings, planImport, skippedLine, type DiffLine, type ImportPlan, type Pruned, type Skipped, } from './share.js';

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

@@ -1,4 +1,4 @@
-export { CATEGORIES, nameOf } from './categories.js';
-export { ConfigFile, editConfigText, fileValue } from './config-file.js';
+// The menu's settings editing: staged changes (Ctrl+S saves them), sharing settings, and the editors for each kind of
+// value. What the settings are, their files and rows live in the settings feature (src/app/features/settings).
 export { Draft } from './draft.js';
-export { SchemaNode } from './schema-node.js';
+export { diffText, exportSettings, planImport, skippedLine, } from './share.js';

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

@@ -1,5 +1,5 @@
 import { type App } from '../../tui/index.js';
-import { type SchemaNode } from './schema-node.js';
+import type { SchemaNode } from '../../../app/kernel/index.js';
 import type { ValueEditor, Edited } from './value-editor.js';
 /** One object as a form: each field with its value, Enter to change it, r to clear an optional one. */
 export declare class ObjectEditor {
@@ -7,6 +7,10 @@ export declare class ObjectEditor {
     private readonly path;
     private readonly node;
     private readonly editor;
-    constructor(app: App, path: string[], node: SchemaNode, editor: ValueEditor);
+    /** The setting's key (the object's own, without list positions), so a field knows what it is. */
+    private readonly key;
+    constructor(app: App, path: string[], node: SchemaNode, editor: ValueEditor, 
+    /** The setting's key (the object's own, without list positions), so a field knows what it is. */
+    key?: string[]);
     run(start: Record<string, unknown>, isNew?: boolean): Promise<Edited>;
 }

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

@@ -7,11 +7,15 @@ export class ObjectEditor {
     path;
     node;
     editor;
-    constructor(app, path, node, editor) {
+    key;
+    constructor(app, path, node, editor, 
+    /** The setting's key (the object's own, without list positions), so a field knows what it is. */
+    key = []) {
         this.app = app;
         this.path = path;
         this.node = node;
         this.editor = editor;
+        this.key = key;
     }
     async run(start, isNew = false) {
         const value = structuredClone(start);
@@ -30,13 +34,20 @@ export class ObjectEditor {
                     ...fields.map(([name, field]) => ({
                         value: name,
                         label: Text.humanize(name),
-                        hint: formatValue(value[name]),
+                        hint: field.secret && value[name] ? '***' : formatValue(value[name]),
                         description: field.description,
                         section: 'Fields',
+                        flip: field.editor === 'boolean',
                     })),
                 ],
                 startAt: focus,
-                actions: [{ key: 'r', label: 'clear' }],
+                actions: [
+                    {
+                        key: 'r',
+                        label: 'clear',
+                        applies: (name) => Boolean(this.node.child(name)?.optional) && value[name] !== undefined,
+                    },
+                ],
             });
             notice = undefined;
             if (picked.kind === 'back') {
@@ -58,7 +69,7 @@ export class ObjectEditor {
                 delete value[name];
                 continue;
             }
-            const edited = await this.editor.edit([...this.path, Text.humanize(name)], [name], field, value[name]);
+            const edited = await this.editor.edit([...this.path, Text.humanize(name)], [...this.key, name], field, value[name]);
             if (edited)
                 value[name] = edited.value;
         }

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

@@ -0,0 +1,36 @@
+import type { Config } from '../../../core/types.js';
+import type { SettingChange } from '../../../app/features/settings/index.js';
+/** Why something was left out. */
+export interface Skipped {
+    readonly key: string;
+    readonly why: 'secret' | 'path' | 'machine';
+}
+export interface Pruned {
+    readonly data: Record<string, unknown>;
+    readonly skipped: Skipped[];
+}
+/** One line for a skipped setting. */
+export declare function skippedLine(s: Skipped): string;
+/** Your settings as a shareable object: only what differs from the defaults, without secrets or (by default) paths. */
+export declare function exportSettings(config: Config, withPaths: boolean): Pruned;
+/** One changed setting in a diff: old -> new. */
+export interface DiffLine {
+    readonly key: string[];
+    readonly from: unknown;
+    readonly to: unknown;
+}
+export interface ImportPlan {
+    /** What would change (empty: nothing). */
+    readonly changes: SettingChange[];
+    readonly lines: DiffLine[];
+    readonly skipped: Skipped[];
+    /** Why the file cannot be imported at all (not JSON, not settings). */
+    readonly problems: string[];
+}
+/**
+ * Reads a shared settings file and works out what importing it would do to `current` (your settings with defaults).
+ * Pure: nothing is written.
+ */
+export declare function planImport(text: string, current: Config): ImportPlan;
+/** The diff as plain lines: `key: old -> new`. */
+export declare function diffText(lines: readonly DiffLine[]): string[];

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

@@ -0,0 +1,131 @@
+// Sharing your settings: the part of them that differs from the defaults, as a .json a team can pass around, and the
+// reverse (read a file, show what it would change, apply the rest). Secrets (anything the schema marks), the data
+// folder and folders or files of this PC never go into a file and are never taken from one.
+import { parse } from 'jsonc-parser';
+import _ from 'lodash';
+import { DEFAULTS, mergeConfig } from '../../../core/config/index.js';
+import { ConfigSchema, describeIssues, secretPaths } from '../../../core/schema/index.js';
+import { pathKindOf } from '../../../app/kernel/index.js';
+/** Settings that are about this PC and never travel (the data folder). */
+const MACHINE_ONLY = ['storage.root'];
+/** A folder or file of this PC: a drive path, a network path, a rooted path or a %VARIABLE% path. */
+const ABSOLUTE = /^([a-zA-Z]:[\\/]|\\\\|\/|%)/;
+const WHY_TEXT = {
+    secret: 'a secret, never shared',
+    path: 'a folder or file of this PC',
+    machine: 'this PC only',
+};
+/** One line for a skipped setting. */
+export function skippedLine(s) {
+    return s.key + ' (' + WHY_TEXT[s.why] + ')';
+}
+const isSecret = (trail) => secretPaths().some((p) => p.length === trail.length && p.every((part, i) => part === '*' || part === trail[i]));
+/**
+ * `value` without secrets, machine-only settings and (unless `withPaths`) folders and files of this PC. A list item
+ * that holds such a path is dropped whole. `trail` is the key path, with * for a list item.
+ */
+function prune(value, trail, withPaths, skipped) {
+    const name = () => trail.join('.').replace(/\.\*/g, '[]');
+    if (isSecret(trail)) {
+        skipped.push({ key: name(), why: 'secret' });
+        return undefined;
+    }
+    if (MACHINE_ONLY.includes(trail.join('.'))) {
+        skipped.push({ key: name(), why: 'machine' });
+        return undefined;
+    }
+    const isPath = !withPaths && pathKindOf(trail.filter((p) => p !== '*')) !== undefined;
+    if (typeof value === 'string') {
+        if (isPath && ABSOLUTE.test(value)) {
+            skipped.push({ key: name(), why: 'path' });
+            return undefined;
+        }
+        return value;
+    }
+    if (Array.isArray(value)) {
+        const kept = [];
+        for (const item of value) {
+            const before = skipped.length;
+            const out = prune(item, [...trail, '*'], withPaths, skipped);
+            // A list item that lost a path (a folder entry without its folder) means nothing any more.
+            const lostPath = skipped.slice(before).some((x) => x.why !== 'secret');
+            if (out !== undefined && !lostPath)
+                kept.push(out);
+        }
+        return kept.length || value.length === 0 ? kept : undefined;
+    }
+    if (_.isPlainObject(value)) {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            const next = prune(v, [...trail, k], withPaths, skipped);
+            if (next !== undefined)
+                out[k] = next;
+        }
+        return _.isEmpty(out) && !_.isEmpty(value) ? undefined : out;
+    }
+    return value;
+}
+/** What `value` has that `base` does not (undefined when nothing). Lists and plain values are compared whole. */
+function differences(value, base) {
+    if (_.isPlainObject(value) && _.isPlainObject(base)) {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            const d = differences(v, base[k]);
+            if (d !== undefined)
+                out[k] = d;
+        }
+        return _.isEmpty(out) ? undefined : out;
+    }
+    return _.isEqual(value, base) ? undefined : value;
+}
+/** Your settings as a shareable object: only what differs from the defaults, without secrets or (by default) paths. */
+export function exportSettings(config, withPaths) {
+    const skipped = [];
+    const diff = differences(config, DEFAULTS) ?? {};
+    const data = (prune(diff, [], withPaths, skipped) ?? {});
+    return { data, skipped };
+}
+/** The leaves of an object as key paths; lists and plain values are leaves. */
+function leaves(value, key = []) {
+    if (_.isPlainObject(value) && !_.isEmpty(value))
+        return Object.entries(value).flatMap(([k, v]) => leaves(v, [...key, k]));
+    return key.length ? [{ key, value }] : [];
+}
+/**
+ * Reads a shared settings file and works out what importing it would do to `current` (your settings with defaults).
+ * Pure: nothing is written.
+ */
+export function planImport(text, current) {
+    const none = { changes: [], lines: [], skipped: [] };
+    const errors = [];
+    const parsed = parse(text, errors, { allowTrailingComma: true });
+    if (errors.length || !_.isPlainObject(parsed))
+        return { ...none, problems: ['The file is not a settings file (a JSON object is expected).'] };
+    const raw = _.omit(parsed, '$schema');
+    const skipped = [];
+    const safe = (prune(raw, [], false, skipped) ?? {});
+    const checked = ConfigSchema.safeParse(mergeConfig(DEFAULTS, safe));
+    if (!checked.success)
+        return { ...none, skipped, problems: describeIssues(checked.error) };
+    const changes = [];
+    const lines = [];
+    for (const { key, value } of leaves(safe)) {
+        const from = _.get(current, key);
+        if (_.isEqual(from, value))
+            continue;
+        changes.push({ key, value });
+        lines.push({ key, from, to: value });
+    }
+    return { changes, lines, skipped, problems: [] };
+}
+/** A value as one short piece of text for a diff. */
+function show(value) {
+    if (value === undefined)
+        return '(not set)';
+    const text = JSON.stringify(value);
+    return text.length > 60 ? text.slice(0, 57) + '...' : text;
+}
+/** The diff as plain lines: `key: old -> new`. */
+export function diffText(lines) {
+    return lines.map((l) => l.key.join('.') + ': ' + show(l.from) + ' -> ' + show(l.to));
+}

package/dist/cli/menu/settings/value-editor.d.ts

@@ -1,5 +1,7 @@
 import { type App } from '../../tui/index.js';
-import { type SchemaNode } from './schema-node.js';
+import { type SchemaNode } from '../../../app/kernel/index.js';
+/** What is wrong with the text typed for a number setting (true = fine), in words that name the allowed range. */
+export declare function numberProblem(node: SchemaNode, text: string): true | string;
 /** The new value, or undefined when you backed out without changing anything. */
 export type Edited = {
     value: unknown;
@@ -13,6 +15,13 @@ export declare class ValueEditor {
     private readonly hints;
     constructor(app: App, hints?: EditorHints);
     edit(path: string[], key: string[], node: SchemaNode, current: unknown): Promise<Edited>;
+    /** A choice with "Custom…" for a value of your own (a number or a text besides the fixed values). */
+    private custom;
+    /** A list: ticks for fixed values, a form per entry for objects, otherwise text (or paths) one per entry. */
+    private list;
+    private number;
+    /** A folder or file on this PC: the path picker (typing a path still works). */
+    private folderOrFile;
     private pick;
     private suggest;
     private json;

package/dist/cli/menu/settings/value-editor.js

@@ -1,14 +1,29 @@
-// 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.
+// Editing one value with the screen that fits its Field (app/kernel/fields.ts, the same descriptor the web's inputs
+// read): 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 } from '../../tui/index.js';
-import { choiceLabel } from './format.js';
+import { choiceLabel, fieldOf, pathLiterals } from '../../../app/kernel/index.js';
 import { StringListEditor } from './collections/string-list-editor.js';
 import { MapEditor } from './collections/map-editor.js';
 import { ObjectListEditor } from './collections/object-list-editor.js';
 import { ObjectMapEditor } from './collections/object-map-editor.js';
 import { ObjectEditor } from './object-editor.js';
+import { askPath } from './ask-path.js';
+/** What is wrong with the text typed for a number setting (true = fine), in words that name the allowed range. */
+export function numberProblem(node, text) {
+    const n = Number(text);
+    if (text.trim() === '' || !Number.isFinite(n))
+        return 'Enter a number.';
+    if (node.integer && !Number.isInteger(n))
+        return 'Enter a whole number.';
+    const verdict = node.check(n);
+    if (verdict === true)
+        return true;
+    const range = node.rangeText();
+    return range ? 'Use ' + range + '.' : verdict;
+}
 export class ValueEditor {
     app;
     hints;
@@ -17,84 +32,105 @@ export class ValueEditor {
         this.hints = hints;
     }
     async edit(path, key, node, current) {
-        const about = node.description ? [node.description] : [];
+        const field = fieldOf(node, key);
         const suggestions = this.hints.suggestions?.(key);
         if (suggestions?.length && node.type === 'string')
             return this.suggest(path, key, node, current, suggestions);
-        switch (node.editor) {
+        switch (field.kind) {
             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': {
+            case 'enum':
+                return field.open ? this.custom(path, key, node, current) : this.pick(path, node, current, node.choiceValues);
+            case 'number':
+                return this.number(path, key, node, current);
+            case 'path':
+                return this.folderOrFile(path, key, node, current, field.pathKind ?? 'dir');
+            case 'text':
+            case 'secret': {
                 const typed = await this.app.text({
                     path,
                     label: Text.humanize(key[key.length - 1]),
-                    about,
+                    about: field.help ? [field.help] : [],
                     initial: typeof current === 'string' ? current : '',
                     allowEmpty: node.check('') === true,
+                    masked: field.kind === 'secret',
                     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 'list':
+                return this.list(path, key, node, field, current);
+            case 'map':
+                return field.element?.kind === 'object'
+                    ? new ObjectMapEditor(this.app, path, node, this, key).run(_.isPlainObject(current) ? current : {})
+                    : new MapEditor(this.app, path, node, this, key).run(_.isPlainObject(current) ? current : {});
             case 'object':
-                return new ObjectEditor(this.app, path, node, this).run(_.isPlainObject(current) ? current : node.initial());
+                return new ObjectEditor(this.app, path, node, this, key).run(_.isPlainObject(current) ? current : node.initial());
             default:
                 return this.json(path, key, node, current);
         }
     }
+    /** A choice with "Custom…" for a value of your own (a number or a text besides the fixed values). */
+    async custom(path, key, node, current) {
+        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) })),
+            {
+                value: custom,
+                label: 'Custom ' + open.type + '…',
+                description: 'Type a ' + open.type + ' of your own.',
+            },
+        ], node.choiceValues.includes(current) ? current : current !== undefined ? custom : undefined);
+        if (picked === undefined)
+            return undefined;
+        return picked === custom
+            ? this.edit(path, key, open, node.choiceValues.includes(current) ? undefined : current)
+            : { value: picked };
+    }
+    /** A list: ticks for fixed values, a form per entry for objects, otherwise text (or paths) one per entry. */
+    async list(path, key, node, field, current) {
+        const kind = field.element?.kind;
+        if (kind === 'enum') {
+            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;
+        }
+        if (kind === 'object')
+            return new ObjectListEditor(this.app, path, node, this, key).run(Array.isArray(current) ? current : []);
+        return new StringListEditor(this.app, path, node, this, key, field.element?.pathKind).run(Array.isArray(current) ? current : []);
+    }
+    async number(path, key, node, current) {
+        const range = node.rangeText();
+        const typed = await this.app.text({
+            path,
+            label: Text.humanize(key[key.length - 1]),
+            about: node.description ? [node.description] : [],
+            hint: 'A ' + (node.integer ? 'whole number' : 'number') + (range ? ': ' + range : '') + '.',
+            accept: node.integer ? (node.min !== undefined && node.min >= 0 ? /[0-9]/ : /[-0-9]/) : /[-0-9.]/,
+            initial: current === undefined ? '' : String(current),
+            validate: (v) => numberProblem(node, v),
+        });
+        return typed === undefined ? undefined : { value: Number(typed) };
+    }
+    /** A folder or file on this PC: the path picker (typing a path still works). */
+    async folderOrFile(path, key, node, current, kind) {
+        const picked = await askPath(this.app, {
+            path,
+            title: 'Choose ' + (kind === 'file' ? 'the file' : 'the folder') + ': ' + Text.humanize(key[key.length - 1]),
+            about: node.description ? [node.description] : [],
+            kind,
+            initial: typeof current === 'string' && current !== 'auto' ? current : '',
+            literals: pathLiterals(node),
+            validate: (v) => node.check(v),
+        });
+        return picked === undefined ? undefined : { value: picked };
+    }
     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 };

package/dist/cli/menu/several.js

@@ -8,6 +8,7 @@ import { KnownProjects } from '../../host/projects/index.js';
 import { isWithin } from '../../shared/paths/index.js';
 import { commandLine } from '../history.js';
 import { Text, Theme } from '../tui/index.js';
+import { askPath } from './settings/ask-path.js';
 /** Folders worth offering: this one, the projects started before, and the folders inside your roots. */
 export function candidateFolders(ctx, cwd = process.cwd()) {
     const roots = ctx.loaded.config.projects.roots.map((r) => expandPath(r, ctx.loaded.base));
@@ -66,10 +67,10 @@ export class SeveralAgents {
         const headless = await this.app.confirm({
             path: this.path,
             question: 'Hide the sandbox window (headless)?',
-            about: ['sandbox show brings it back.'],
+            about: ['Sandbox > Show the window brings it back.'],
             initial: this.ctx.loaded.config.sandbox.headless,
         });
-        const attach = await this.app.choose(this.path, 'Attach this terminal to one of them? Each session also has a tab inside the sandbox; sandbox attach shows any of them later.', [
+        const attach = await this.app.choose(this.path, 'Attach this terminal to one of them? Each session also has a tab inside the sandbox; Sessions shows any of them later.', [
             { value: -1, label: 'None' },
             ...sessions.map((s, i) => ({ value: i, label: s.harness + ' in ' + Text.middle(s.folder, 60) })),
         ], 0);
@@ -119,9 +120,10 @@ export class SeveralAgents {
             return null;
         const folders = picked.values.filter((f) => f !== ADD);
         if (picked.values.includes(ADD)) {
-            const extra = await this.app.text({
+            const extra = await askPath(this.app, {
                 path: this.path,
-                label: 'Folder to add',
+                title: 'Choose the folder to add',
+                kind: 'dir',
                 validate: (v) => {
                     const dir = path.resolve(v.trim());
                     if (!v.trim() || !fs.existsSync(dir) || !fs.statSync(dir).isDirectory())
@@ -136,7 +138,7 @@ export class SeveralAgents {
                 },
             });
             if (extra)
-                folders.push(path.resolve(extra.trim()));
+                folders.push(path.resolve(extra));
         }
         return folders;
     }

package/dist/cli/menu/share-settings.d.ts

@@ -0,0 +1,21 @@
+import type { Context } from '../commands/context.js';
+import { type App } from '../tui/index.js';
+/** The rows' ids in the settings list. */
+export declare const EXPORT_SETTINGS = "@export-settings";
+export declare const IMPORT_SETTINGS = "@import-settings";
+export declare function shareSettingsRows(): {
+    value: string;
+    label: string;
+    hint: string;
+    description: string;
+}[];
+export declare class ShareSettingsFlow {
+    private readonly app;
+    private readonly ctx;
+    constructor(app: App, ctx: Context);
+    /** Your settings as they are on disk now (the menu may have saved changes since it started). */
+    private fresh;
+    /** Returns the notice to show (undefined when cancelled). */
+    export(): Promise<string | undefined>;
+    import(): Promise<string | undefined>;
+}