windows-development-sandbox 1.7.0 → 1.9.0

package/dist/cli/menu/pages/sessions-page.js

@@ -1,110 +1,41 @@
-// Section 2: the agent sessions of the running sandbox. Enter shows one in this terminal (the one thing that leaves the
-// menu), r restarts the agents.
-import { errMsg, safeText } from '../../../core/util/index.js';
-import { isSandboxRunning } from '../../../host/sandbox/index.js';
-import { ago } from '../../output/index.js';
-import { SessionsService, viewerText } from '../../services/index.js';
-import { Theme } from '../../tui/index.js';
+// Section 2: the agent sessions of the running sandbox, as the sessions view shows them (src/app/features/sessions).
+// Enter shows one in this terminal (the one thing that leaves the menu), r restarts the agents.
+import { listSessions, sessionsPage } from '../../../app/features/sessions/index.js';
+import { readQuery } from '../../../app/registry.js';
+import { MenuOperations } from '../io-menu.js';
+import { menuView } from '../render-view.js';
 import { ListPage } from './list-page.js';
-const START = '@start';
+function view(m) {
+    return menuView(sessionsPage({ ...m, wide: false }));
+}
 /** The list for the sessions tab. Pure. */
 export function sessionsOptions(m) {
-    return {
-        path: [],
-        items: m.sessions.length
-            ? m.sessions.map((s) => ({
-                value: s.id,
-                label: safeText(s.harness) + '  ' + safeText(s.projectName ?? '-'),
-                hint: s.phase + (s.exitCode !== undefined ? ' (' + s.exitCode + ')' : '') + '  ' + ago(s.startedAt),
-                section: s.here ? "This folder's project" : 'Other sessions',
-                description: s.phase === 'running'
-                    ? 'Enter shows this session in this terminal (Ctrl+] detaches; the session keeps running).'
-                    : undefined,
-                details: [
-                    Theme.muted('Session   ') + s.id,
-                    Theme.muted('Folder    ') + safeText(s.cwd),
-                    Theme.muted('Attached  ') + viewerText(s.viewers),
-                ],
-                ...(s.phase === 'running' ? {} : { disabled: 'This session has ended.' }),
-            }))
-            : [
-                {
-                    value: START,
-                    label: 'Start ' + m.defaultAgent,
-                    hint: Theme.muted('default agent'),
-                    section: m.sandboxRunning ? 'No sessions' : 'No sandbox is running',
-                    description: m.sandboxRunning
-                        ? 'No agent is running. Enter starts ' + m.defaultAgent + ' in this folder.'
-                        : 'Enter starts the sandbox and ' + m.defaultAgent + ' in this folder; its session is listed here.',
-                },
-            ],
-        actions: [
-            { key: 'r', label: 'restart agents', importance: 1, applies: (id) => id !== START },
-            { key: 'o', label: 'reopen last sessions', importance: 2 },
-            { key: 'l', label: 'refresh', importance: 3 },
-        ],
-        enterLabel: (_category, id) => (id === START ? 'start' : 'attach'),
-    };
+    const v = view(m);
+    return { path: [], items: v.items, actions: v.actions, enterLabel: v.enterLabel };
 }
 export class SessionsPage extends ListPage {
     ctx;
     label = 'Sessions';
     model;
-    service;
+    operations;
     constructor(app, ctx) {
         super(app);
         this.ctx = ctx;
-        this.service = new SessionsService(ctx);
-        this.model = { sandboxRunning: false, sessions: [], defaultAgent: this.defaultAgent() };
-    }
-    defaultAgent() {
-        return this.ctx.loaded.config.defaultHarness;
+        this.operations = new MenuOperations(app, ctx);
+        this.model = { sandboxRunning: false, sessions: [], defaultAgent: ctx.loaded.config.defaultHarness };
     }
     async load() {
-        const sandboxRunning = isSandboxRunning();
-        try {
-            const list = sandboxRunning ? await this.service.list() : [];
-            this.model = { sandboxRunning, sessions: this.service.ordered(list), defaultAgent: this.defaultAgent() };
-        }
-        catch (e) {
-            this.model = { sandboxRunning, sessions: [], defaultAgent: this.defaultAgent() };
-            this.say(Theme.error(Theme.glyph.cross + ' ' + errMsg(e)));
-        }
+        this.model = await readQuery(listSessions, this.ctx);
     }
     options() {
         return sessionsOptions(this.model);
     }
     async act(result) {
-        if (result.kind === 'pick' && result.value === START)
-            return { exit: { kind: 'run', argv: ['launch', '--harness', this.model.defaultAgent] } };
-        if (result.kind === 'pick')
-            return { exit: { kind: 'run', argv: ['attach', result.value] } };
-        if (result.kind !== 'action')
+        const chosen = view(this.model).resolve(result);
+        if (!chosen)
             return {};
-        if (result.key === 'l')
+        if (chosen.kind === 'refresh')
             return { reload: true };
-        if (result.key === 'o')
-            return { exit: { kind: 'run', argv: ['resume'] } };
-        if (!this.model.sandboxRunning)
-            return { notice: Theme.warn('No sandbox is running.') };
-        const scope = this.service.restartScope(false);
-        const what = scope.guest ? 'the agents of ' + scope.projectName : 'every agent';
-        const ok = await this.app.ask('Restart ' + what + '?', [
-            'The agents are started again and continue their conversations where they can.',
-            ...(scope.notAProject
-                ? [scope.folder + ' is not a project of the running sandbox: every session restarts.']
-                : []),
-        ], 'Restart');
-        if (!ok)
-            return {};
-        try {
-            return {
-                reload: true,
-                notice: Theme.ok(Theme.glyph.ok + ' ' + safeText(await this.service.restart(null, scope.guest))),
-            };
-        }
-        catch (e) {
-            return { notice: Theme.error(Theme.glyph.cross + ' ' + errMsg(e)) };
-        }
+        return this.operations.perform(chosen.action, [this.label], (text) => this.busy(text));
     }
 }

package/dist/cli/menu/pages/settings-page.d.ts

@@ -1,18 +1,10 @@
+import { settingsOf, type ConfigFile, type Setting } from '../../../app/features/settings/index.js';
 import type { Context } from '../../commands/context.js';
 import { type App, type ListItem, type ListOptions, type ListResult } from '../../tui/index.js';
-import type { ConfigFile } from '../settings/config-file.js';
 import type { Draft } from '../settings/draft.js';
-import type { SchemaNode } from '../settings/schema-node.js';
 import { type Scope } from './scopes.js';
 import { ListPage, type Outcome } from './list-page.js';
-export interface Setting {
-    readonly key: string[];
-    readonly node: SchemaNode;
-    readonly category: string;
-    readonly section?: string;
-}
-/** Every editable setting with the category and heading it is shown under. */
-export declare function settingsOf(file: ConfigFile): Setting[];
+export { settingsOf, type Setting };
 /** The row in General that opens the data folder flow (your own settings only). */
 export declare const DATA_FOLDER = "@data-folder";
 /** The list for the settings section. Pure (reads the files it is given). `extra` are rows that are not settings. */

package/dist/cli/menu/pages/settings-page.js

@@ -1,125 +1,86 @@
 // Section 5: every setting, for all projects or just this project (two scopes), grouped into categories on the left and
-// searchable, with each value, its default and its description. Changes are staged in the Draft (marked *) and
-// written with Ctrl+S; Enter edits, r resets to the default, z undoes an unsaved change.
+// searchable, with each value, its default and its description. The rows (which settings, their values, secrets as
+// ***) are the settings feature's; this page lays the unsaved changes over them: changes are staged in the Draft
+// (marked *) and written with Ctrl+S; Enter edits, r resets to the default, z undoes an unsaved change.
 import _ from 'lodash';
-import { NEVER_LOOSER } from '../../../core/local-config/index.js';
+import { CATEGORIES, labelOf, nameOf, settingRow, settingsOf, } from '../../../app/features/settings/index.js';
+import { valueText } from '../../../app/kernel/index.js';
 import { errMsg } from '../../../core/util/index.js';
 import { Text, Theme, } from '../../tui/index.js';
 import { dataFolderRow, DataFolderFlow } from '../data-folder.js';
+import { EXPORT_SETTINGS, IMPORT_SETTINGS, ShareSettingsFlow, shareSettingsRows } from '../share-settings.js';
 import { VpnLoginFlow, vpnLoginRow, VPN_LOGIN } from '../vpn-login.js';
-import { CATEGORIES, categoryOf, nameOf } from '../settings/categories.js';
-import { formatValue } from '../settings/format.js';
 import { ValueEditor } from '../settings/value-editor.js';
 import { SCOPES, scopeStatus } from './scopes.js';
 import { ListPage } from './list-page.js';
-/** Every editable setting with the category and heading it is shown under. */
-export function settingsOf(file) {
-    return file.schema.children().flatMap(([top, node]) => {
-        const category = categoryOf(top);
-        if (!category)
-            return [];
-        const several = category.keys.filter((k) => 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 };
-        });
-    });
-}
-/** What the file will say for a setting once the staged changes are saved (undefined = not set there). */
-function written(file, draft, key) {
-    return draft.has(file, key) ? draft.value(file, key) : file.valueInFile(key);
-}
-/** What is in effect for a setting once the staged changes are saved. */
-function effective(file, draft, key, config) {
-    if (file.isProject)
-        return written(file, draft, key);
-    return draft.has(file, key) ? (draft.value(file, key) ?? file.defaultOf(key)) : _.get(config, key);
+export { settingsOf };
+/** The files with the menu's unsaved changes laid over them. */
+function draftSource(draft) {
+    const written = (file, key) => draft.has(file, key) ? draft.value(file, key) : file.valueInFile(key);
+    return {
+        written,
+        effective: (file, key, config) => file.isProject
+            ? written(file, key)
+            : draft.has(file, key)
+                ? (draft.value(file, key) ?? file.defaultOf(key))
+                : _.get(config, key),
+    };
 }
-/** Plain words for settings whose key is jargon (the key itself stays in the details pane). */
-const LABELS = {
-    mappings: 'Extra folders from this PC',
-    'sandbox.vGpu': 'Graphics acceleration',
-    'sandbox.headless': 'Hide the sandbox window',
-    'sandbox.memoryMb': 'Memory (MB)',
-    'sandbox.pageFileMb': 'Swap file (MB)',
-    'network.dns': 'DNS servers',
-    'projects.wsbShare': 'Add folders while the sandbox runs',
-    'projects.all': 'Map all known projects at start',
-    'claudeProfile.hostDir': 'Claude folder on this PC',
-    'claudeProfile.globalStateFile': 'Claude state file on this PC',
-};
-function labelOf(key) {
-    return LABELS[key.join('.')] ?? Text.humanize(key[key.length - 1]);
+/** A value of a row in one short line, painted like every value in the menu. */
+function shown(row, value, max = 60) {
+    const v = valueText(value, row.field, max);
+    return v.tone === 'ok' ? Theme.ok(v.text) : v.tone === 'muted' ? Theme.muted(v.text) : v.text;
 }
-function item(s, files, scope, draft, config) {
-    const file = files[scope];
-    const id = s.key.join('.');
-    const set = written(file, draft, s.key) !== undefined;
-    const unsaved = draft.has(file, s.key);
-    const yours = effective(files.user, draft, s.key, config);
-    const project = files.project;
-    const inProject = project.schema.leaves().some((l) => l.key.join('.') === id)
-        ? written(project, draft, s.key)
-        : undefined;
+function item(row, file, draft) {
+    const unsaved = draft.has(file, row.key);
     const paint = file.isProject ? Theme.project : Theme.changed;
-    const value = file.isProject && !set
-        ? Theme.muted('all projects: ') + formatValue(yours, 40)
-        : formatValue(effective(file, draft, s.key, config));
+    const value = file.isProject && !row.set ? Theme.muted('all projects: ') + shown(row, row.yours, 40) : shown(row, row.value);
     const details = [
-        Theme.muted('Setting       ') + id,
+        Theme.muted('Setting       ') + row.id,
         Theme.muted('All projects  ') +
-            formatValue(yours, 40) +
-            Theme.muted(written(files.user, draft, s.key) === undefined ? '  (built-in default)' : '  (your file)'),
+            shown(row, row.yours, 40) +
+            Theme.muted(row.yoursSet ? '  (your file)' : '  (built-in default)'),
         Theme.muted('This project  ') +
-            (inProject === undefined ? Theme.muted('not set') : Theme.project(Text.strip(formatValue(inProject, 40)))),
-        ...(!file.isProject ? [Theme.muted('Default       ') + formatValue(file.defaultOf(s.key), 40)] : []),
+            (row.inProject === undefined ? Theme.muted('not set') : Theme.project(Text.strip(shown(row, row.inProject, 40)))),
+        ...(!file.isProject ? [Theme.muted('Default       ') + shown(row, row.default, 40)] : []),
         ...(unsaved ? [Theme.warn('Unsaved: Ctrl+S saves, z undoes this change.')] : []),
-        ...(file.isProject && NEVER_LOOSER.includes(id)
+        ...(file.isProject && row.locked
             ? [Theme.warn(Theme.glyph.lock + ' A project can only make this stricter than your own setting.')]
             : []),
     ];
     return {
-        value: id,
-        label: labelOf(s.key),
+        value: row.id,
+        label: row.label,
         hint: unsaved
             ? paint(Text.strip(value)) + ' ' + Theme.warn('*')
-            : set
+            : row.set
                 ? paint(Text.strip(value)) + ' ' + paint(Theme.glyph.changed)
                 : value,
-        description: s.node.description,
+        description: row.field.help,
         details,
-        section: s.section,
-        category: s.category,
-        keywords: id,
-        flip: s.node.editor === 'boolean',
+        section: row.section,
+        category: row.category,
+        keywords: row.id,
+        flip: row.field.kind === 'boolean',
     };
 }
+/** What a setting is now for editing: the staged value, else the file's (a project), else what is in effect. */
+function current(file, draft, key, config) {
+    const source = draftSource(draft);
+    return file.isProject ? (source.written(file, key) ?? _.get(config, key)) : source.effective(file, key, config);
+}
 /** The row in General that opens the data folder flow (your own settings only). */
 export const DATA_FOLDER = '@data-folder';
 /** The list for the settings section. Pure (reads the files it is given). `extra` are rows that are not settings. */
 export function settingsOptions(files, scope, draft, extra = []) {
     const file = files[scope];
-    const config = file.userConfig();
+    const config = files.user.userConfig();
     // The Data folder row stands in for the storage folder setting (changing it moves the data, which is asked about).
     const hideRoot = !file.isProject && extra.some((e) => e.value === DATA_FOLDER);
     const settings = settingsOf(file).filter((s) => !(hideRoot && s.key.join('.') === 'storage.root'));
-    const ids = (test) => new Set(settings.filter(test).map((s) => s.key.join('.')));
-    const set = ids((s) => written(file, draft, s.key) !== undefined);
-    const unsaved = ids((s) => draft.has(file, s.key));
+    const rows = settings.map((s) => settingRow(s, files, scope, draftSource(draft), config));
+    const set = new Set(rows.filter((r) => r.set).map((r) => r.id));
+    const unsaved = new Set(rows.filter((r) => draft.has(file, r.key)).map((r) => r.id));
     const categories = CATEGORIES.filter((c) => settings.some((s) => s.category === c.id)).map((c) => ({
         id: c.id,
         label: c.label,
@@ -129,13 +90,17 @@ export function settingsOptions(files, scope, draft, extra = []) {
         path: [],
         status: scopeStatus(file),
         tabs: { items: SCOPES.map((x) => x.tab), active: SCOPES.findIndex((x) => x.scope === scope) },
-        items: [...settings.map((s) => item(s, files, scope, draft, config)), ...(file.isProject ? [] : extra)],
+        items: [...rows.map((r) => item(r, file, draft)), ...(file.isProject ? [] : extra)],
         categories,
         actions: [
             { key: 'r', label: file.isProject ? 'remove' : 'reset to default', applies: (id) => set.has(id) },
             { key: 'z', label: 'undo', applies: (id) => unsaved.has(id) },
         ],
-        enterLabel: (_category, id) => (id === DATA_FOLDER || id === VPN_LOGIN ? 'change' : 'edit'),
+        enterLabel: (_category, id) => id === DATA_FOLDER || id === VPN_LOGIN
+            ? 'change'
+            : id === EXPORT_SETTINGS || id === IMPORT_SETTINGS
+                ? 'open'
+                : 'edit',
     };
 }
 export class SettingsPage extends ListPage {
@@ -168,6 +133,7 @@ export class SettingsPage extends ListPage {
         return settingsOptions(this.files, this.scope, this.draft, [
             { value: DATA_FOLDER, category: 'general', ...row },
             { value: VPN_LOGIN, category: 'network', ...vpnLoginRow(this.ctx) },
+            ...shareSettingsRows().map((r) => ({ ...r, category: 'general' })),
         ]);
     }
     /** Stages a value; your own file never keeps a line that only repeats the default. */
@@ -196,6 +162,13 @@ export class SettingsPage extends ListPage {
             const exit = await new DataFolderFlow(this.app, this.ctx).run();
             return exit ? { exit } : { reload: true };
         }
+        if (result.value === EXPORT_SETTINGS || result.value === IMPORT_SETTINGS) {
+            if (result.kind !== 'pick')
+                return {};
+            const flow = new ShareSettingsFlow(this.app, this.ctx);
+            const notice = await (result.value === EXPORT_SETTINGS ? flow.export() : flow.import());
+            return { reload: true, notice };
+        }
         if (result.value === VPN_LOGIN) {
             if (result.kind !== 'pick')
                 return {};
@@ -213,12 +186,9 @@ export class SettingsPage extends ListPage {
             return {};
         }
         try {
-            const config = this.file.userConfig();
-            const current = this.file.isProject
-                ? (written(this.file, this.draft, setting.key) ?? _.get(config, setting.key))
-                : effective(this.file, this.draft, setting.key, config);
+            const now = current(this.file, this.draft, setting.key, this.file.userConfig());
             const path = ['Settings', ...setting.key.slice(0, -1).map(nameOf), labelOf(setting.key)];
-            const edited = await this.editor.edit(path, setting.key, setting.node, current);
+            const edited = await this.editor.edit(path, setting.key, setting.node, now);
             if (edited)
                 this.stage(setting.key, edited.value);
         }

package/dist/cli/menu/render-view.d.ts

@@ -0,0 +1,28 @@
+import type { Action, Page } from '../../app/kernel/index.js';
+import { type ListAction, type ListItem, type ListResult } from '../tui/index.js';
+/** The row that stands for the empty state. */
+export declare const EMPTY_ROW = "@empty";
+/** What the list returned, as the page means it. */
+export type Chosen = {
+    readonly kind: 'refresh';
+} | {
+    readonly kind: 'action';
+    readonly action: Action;
+};
+export interface MenuView {
+    readonly items: ListItem<string>[];
+    readonly actions: ListAction<string>[];
+    /** What Enter does on a row ("" = it only shows information). */
+    enterLabel(category: string | undefined, id: string | undefined): string;
+    resolve(result: ListResult<string>): Chosen | undefined;
+}
+export interface MenuViewOptions {
+    /** Every row goes in this category (a view that is one category of a page). */
+    readonly category?: string;
+    /** Put before every row's value, so the rows cannot clash with the page's own rows. */
+    readonly prefix?: string;
+    /** Offer l to load the data again (default: yes). */
+    readonly refresh?: boolean;
+}
+/** The menu's rows, keys and Enter labels for a page. */
+export declare function menuView(page: Page, o?: MenuViewOptions): MenuView;

package/dist/cli/menu/render-view.js

@@ -0,0 +1,112 @@
+import { pageHasContent } from '../../app/kernel/index.js';
+import { safeText } from '../../core/util/index.js';
+import { Theme } from '../tui/index.js';
+/** The row that stands for the empty state. */
+export const EMPTY_ROW = '@empty';
+const FACT = 'fact:';
+const ACTION = 'action:';
+const REFRESH_KEY = 'l';
+const PAINT = {
+    ok: Theme.ok,
+    warn: Theme.warn,
+    danger: Theme.error,
+    muted: Theme.muted,
+    accent: Theme.accent,
+};
+const paint = (text, tone) => text === undefined ? undefined : tone ? PAINT[tone](safeText(text)) : safeText(text);
+/** The menu's rows, keys and Enter labels for a page. */
+export function menuView(page, o = {}) {
+    const category = o.category ? { category: o.category } : {};
+    const prefix = o.prefix ?? '';
+    const items = [];
+    /** The action Enter runs, by row. */
+    const enter = new Map();
+    /** Key actions that apply to one row, by row. */
+    const keyed = new Map();
+    /** Key actions that apply everywhere. */
+    const everywhere = [...(page.actions ?? [])];
+    if (!pageHasContent(page) && page.empty) {
+        const e = page.empty;
+        items.push({
+            value: prefix + EMPTY_ROW,
+            label: e.action?.label ?? e.text,
+            section: e.title,
+            description: e.text,
+            ...category,
+        });
+        if (e.action)
+            enter.set(prefix + EMPTY_ROW, e.action);
+    }
+    for (const section of page.sections) {
+        const heading = section.title ?? page.title;
+        for (const f of section.facts ?? [])
+            items.push({
+                value: prefix + FACT + f.id,
+                label: f.label,
+                hint: paint(f.value, f.tone),
+                description: f.description,
+                details: f.details?.map(safeText),
+                section: heading,
+                ...category,
+            });
+        for (const item of section.items ?? []) {
+            const id = prefix + item.id;
+            items.push({
+                value: id,
+                label: safeText(item.label),
+                hint: paint(item.hint, item.tone),
+                description: item.description,
+                details: item.details?.map(safeText),
+                section: item.group ?? heading,
+                keywords: item.keywords,
+                ...(item.disabled ? { disabled: item.disabled } : {}),
+                ...category,
+            });
+            if (item.primary && !item.disabled)
+                enter.set(id, item.primary);
+            if (item.actions?.length)
+                keyed.set(id, [...item.actions]);
+        }
+        (section.actions ?? []).forEach((a, i) => {
+            const id = prefix + ACTION + section.id + ':' + i;
+            items.push({ value: id, label: a.label, hint: '', description: a.description, section: 'Actions', ...category });
+            enter.set(id, a);
+            everywhere.push(a);
+        });
+    }
+    const keys = [];
+    const addKey = (a, applies) => {
+        if (!a.key || keys.some((k) => k.key === a.key && k.label === (a.verb ?? a.label)))
+            return;
+        keys.push({ key: a.key, label: a.verb ?? a.label, importance: a.importance ?? 2, ...(applies ? { applies } : {}) });
+    };
+    for (const a of everywhere)
+        addKey(a);
+    for (const list of keyed.values())
+        for (const a of list)
+            addKey(a, (row) => keyed.get(row)?.some((x) => x.key === a.key) ?? false);
+    if (o.refresh !== false)
+        keys.push({ key: REFRESH_KEY, label: 'refresh', importance: 3 });
+    return {
+        items,
+        actions: keys,
+        enterLabel: (_category, id) => {
+            const a = id === undefined ? undefined : enter.get(id);
+            return a ? (a.verb ?? a.label.toLowerCase()) : '';
+        },
+        resolve: (result) => {
+            if (result.kind === 'pick') {
+                const a = enter.get(result.value);
+                return a ? { kind: 'action', action: a } : undefined;
+            }
+            if (result.kind !== 'action')
+                return undefined;
+            if (result.key === REFRESH_KEY && o.refresh !== false)
+                return { kind: 'refresh' };
+            const own = result.value === undefined ? undefined : keyed.get(result.value)?.find((a) => a.key === result.key);
+            const shared = everywhere.find((a) => a.key === result.key);
+            const a = own ?? shared;
+            return a ? { kind: 'action', action: a } : undefined;
+        },
+    };
+}

package/dist/cli/menu/settings/{path-kind.d.ts → ask-path.d.ts}

@@ -1,11 +1,5 @@
+import type { PathKind } from '../../../app/kernel/index.js';
 import type { App } from '../../tui/index.js';
-import type { SchemaNode } from './schema-node.js';
-/** A folder or a file. */
-export type PathKind = 'dir' | 'file';
-/** The kind of path a setting holds (its key without list positions), or undefined when it is not a path. */
-export declare function pathKindOf(key: readonly string[]): PathKind | undefined;
-/** Words that are fine instead of a path ("auto"), read from the setting's description. */
-export declare function pathLiterals(node: SchemaNode): string[];
 export interface AskPathOptions {
     readonly path: string[];
     readonly title: string;

package/dist/cli/menu/settings/ask-path.js

@@ -0,0 +1,14 @@
+/** Picks a folder or file in the path picker; typing a path (or an allowed word) still works. */
+export function askPath(app, o) {
+    return app.pickPath({
+        path: o.path,
+        title: o.title,
+        about: o.about,
+        initial: o.initial,
+        files: o.kind === 'file',
+        use: o.kind === 'file' ? 'use this file' : 'use this folder',
+        literals: o.literals,
+        relative: true,
+        validate: o.validate,
+    });
+}

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

@@ -1,5 +1,5 @@
 import { type App, type ListItem } 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';
 /**
  * The shared shape of the list and map editors: a working copy shown as a list with "Add" at the top, Enter to change

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

@@ -1,7 +1,6 @@
 import type { App, ListItem } from '../../../tui/index.js';
 import { CollectionEditor } from './collection-editor.js';
-import { type PathKind } from '../path-kind.js';
-import type { SchemaNode } from '../schema-node.js';
+import type { PathKind, SchemaNode } from '../../../../app/kernel/index.js';
 import type { ValueEditor } from '../value-editor.js';
 /** A list of strings (project roots, scripts, extra packages ...). */
 export declare class StringListEditor extends CollectionEditor<string[]> {

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

@@ -1,6 +1,6 @@
 import { Theme } from '../../../tui/index.js';
 import { CollectionEditor } from './collection-editor.js';
-import { askPath } from '../path-kind.js';
+import { askPath } from '../ask-path.js';
 /** A list of strings (project roots, scripts, extra packages ...). */
 export class StringListEditor extends CollectionEditor {
     pathKind;

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

@@ -1,4 +1,4 @@
-import type { ConfigFile, SettingChange } from './config-file.js';
+import type { ConfigFile, SettingChange } from '../../../app/features/settings/index.js';
 /** What saving did: how many settings were written and why a file was refused. */
 export interface DraftResult {
     readonly saved: number;

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

@@ -1,5 +1,3 @@
+export { choiceLabel, summary } from '../../../app/kernel/index.js';
 /** A value in one short line, for the right-hand column. */
 export declare function formatValue(value: unknown, max?: number): string;
-/** A one-line name for an object in a list (a mapping's folders, an agent's package ...). */
-export declare function summary(value: unknown): string;
-export declare function choiceLabel(v: unknown): string;

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;
 }