windows-development-sandbox 1.5.0 → 1.9.0

package/dist/cli/menu/command-form.js

@@ -1,18 +1,26 @@
-// One command as a form: its arguments and options listed with their current values, each changed in place, and the
-// exact command line it will run shown live (the same line you could type yourself). Built from manifest.ts, so a new
-// command or option appears here on its own.
+// One command as a form: its arguments and options listed with their current values, each changed in place with the
+// input that fits it (a switch flips, a choice is picked, a number is typed within its limits, a folder or file is
+// picked in the path picker, a list is edited item by item), and the exact command line it will run shown live (the
+// same line you could type yourself). Built from manifest.ts, so a new command or option appears here on its own.
+import { z } from 'zod';
 import { humanBytes } from '../../core/disk.js';
-import { fail, plainText } from '../../core/util/index.js';
+import { plainText } from '../../core/util/index.js';
 import { SandboxChannel } from '../../host/channel/index.js';
 import { isSandboxRunning } from '../../host/sandbox/index.js';
+import { moveProblem } from '../../host/storage/index.js';
 import { splitArgs } from '../args.js';
 import { cleanTargetOf } from '../commands/data/collect.js';
-import { AccountsService, DataService } from '../services/index.js';
+import { AccountsService, DataService, ProjectsService } from '../services/index.js';
 import { commandLine } from '../history.js';
 import { askedWhen } from '../manifest.js';
 import { Text, Theme } from '../tui/index.js';
-import { optionProblem } from './command-fields.js';
+import { actionOf, argLabel, argPathKind, optionLabel, optionPathKind, optionProblem, plainDescription, plainSummary, } from './command-fields.js';
+import { StringListEditor } from './settings/collections/string-list-editor.js';
+import { askPath } from './settings/ask-path.js';
+import { SchemaNode } from '../../app/kernel/index.js';
+import { ValueEditor } from './settings/value-editor.js';
 const MORE = '@more';
+const OTHER = '@other';
 export class CommandForm {
     app;
     ctx;
@@ -36,6 +44,11 @@ export class CommandForm {
                 ]);
         }
     }
+    /** The actions the command's first argument offers (account: save, use, rename ...). */
+    actions() {
+        const choices = this.spec.args[0]?.choices;
+        return Array.isArray(choices) ? choices : [];
+    }
     /** Values a choices list names, filled in from config and the running sandbox. */
     choices(choices) {
         if (Array.isArray(choices))
@@ -53,10 +66,21 @@ export class CommandForm {
     first() {
         return this.values.get('arg:' + this.spec.args[0]?.name)?.[0] ?? '';
     }
+    valueOf(name) {
+        return this.values.get('arg:' + name)?.[0] ?? '';
+    }
     /** Options the form may ask for at all (advanced ones included). */
     askable() {
         const first = this.first();
-        return this.spec.options.filter((o) => !o.noMenu && askedWhen(o.when, first) && !(typeof o.choices === 'string' && !this.choices(o.choices).length));
+        return this.spec.options.filter((o) => {
+            if (o.noMenu || !askedWhen(o.when, first))
+                return false;
+            if (typeof o.choices === 'string' && !this.choices(o.choices).length)
+                return false;
+            // "(check) the folder": asked only for that action.
+            const action = actionOf(o.description, this.actions());
+            return !action || action === first;
+        });
     }
     hiddenCount() {
         return this.showAdvanced ? 0 : this.askable().filter((o) => o.advanced && !this.values.has('opt:' + o.flag)).length;
@@ -102,7 +126,7 @@ export class CommandForm {
     /** The name of a required argument that has no value yet. */
     missing() {
         const field = this.fields().find((f) => f.kind === 'arg' && f.spec.required && !this.values.get(this.id(f))?.length);
-        return field?.kind === 'arg' ? Text.humanize(field.spec.name) : undefined;
+        return field?.kind === 'arg' ? argLabel(field.spec) : undefined;
     }
     item(f) {
         const v = this.values.get(this.id(f));
@@ -119,12 +143,13 @@ export class CommandForm {
                 : Array.isArray(v) && v.length
                     ? v.join(' ')
                     : Theme.muted('not set');
+        const actions = this.actions();
         if (f.kind === 'arg')
             return {
                 value: this.id(f),
-                label: Text.humanize(f.spec.name),
+                label: argLabel(f.spec),
                 hint: shown,
-                description: f.spec.description,
+                description: plainDescription(f.spec.description, actions),
                 section: 'What',
                 keywords: f.spec.name,
             };
@@ -133,8 +158,9 @@ export class CommandForm {
                 value: 'json',
                 label: 'Machine-readable output',
                 hint: shown,
-                description: 'Print JSON instead of a table (--json).',
+                description: 'Print JSON instead of a table.',
                 section: 'Output',
+                flip: true,
             };
         if (f.kind === 'extra')
             return {
@@ -148,15 +174,12 @@ export class CommandForm {
             };
         return {
             value: this.id(f),
-            label: f.spec.label ??
-                f.spec.flag
-                    .replace(/^--/, '')
-                    .replace(/-/g, ' ')
-                    .replace(/^./, (c) => c.toUpperCase()),
+            label: optionLabel(f.spec),
             hint: shown,
-            description: f.spec.description,
+            description: plainDescription(f.spec.description, actions),
             section: f.spec.advanced ? 'Advanced' : 'Options',
             keywords: f.spec.flag,
+            flip: f.spec.type === 'boolean',
         };
     }
     /** Shows the form until you run the command (its argv) or go back (null). */
@@ -170,7 +193,7 @@ export class CommandForm {
             const line = commandLine(this.argv());
             const picked = await this.app.list({
                 path,
-                intro: this.spec.summary.replace(/^./, (c) => c.toUpperCase()) + '.',
+                intro: plainSummary(this.spec.summary),
                 status: Theme.muted('$ ') + Theme.accent(line),
                 items: [
                     ...fields.map((f) => this.item(f)),
@@ -181,8 +204,9 @@ export class CommandForm {
                 startAt: focus,
                 actions: [
                     { key: 'r', label: 'start', ctrl: true },
-                    { key: 'r', label: 'clear' },
+                    { key: 'r', label: 'clear', applies: (id) => this.values.has(id) },
                 ],
+                enterLabel: (_category, id) => (id === MORE ? 'show' : this.isSwitch(id) ? 'flip' : 'change'),
                 notice,
             });
             notice = undefined;
@@ -210,64 +234,124 @@ export class CommandForm {
                 this.values.delete(this.id(field));
                 continue;
             }
-            await this.edit(field, path);
+            notice = await this.edit(field, path);
             // Enter on the last field starts it (a switch only flips).
             const isSwitch = field.kind === 'json' || (field.kind === 'option' && field.spec.type === 'boolean');
             if (field === fields[fields.length - 1] && !isSwitch && !hidden && !this.missing())
                 return this.argv();
         }
     }
+    isSwitch(id) {
+        const f = this.fields().find((x) => this.id(x) === id);
+        return f?.kind === 'json' || (f?.kind === 'option' && f.spec.type === 'boolean');
+    }
+    /** Sets (or, with no value, clears) a field's answer. */
+    set(id, value) {
+        if (value.length)
+            this.values.set(id, value);
+        else
+            this.values.delete(id);
+    }
+    /** The kind of path a field takes (a folder or a file), if it is one. */
+    pathKind(f) {
+        if (f.kind === 'option')
+            return optionPathKind(f.spec);
+        return f.kind === 'arg' ? argPathKind(f.spec, this.spec.name, this.first()) : undefined;
+    }
+    /** A name that does not exist yet (the new login's name): typed, not picked. */
+    freeText(f) {
+        return f.kind === 'arg' && this.spec.name === 'account' && f.spec.name === 'name' && this.first() === 'save';
+    }
+    /** The values to pick from for a field with a fixed or looked-up set of answers. */
+    options(f) {
+        if (f.kind === 'extra' || f.kind === 'json' || this.freeText(f))
+            return [];
+        const fixed = this.choices(f.spec.choices);
+        if (fixed.length || f.kind !== 'arg' || this.spec.name !== 'projects')
+            return fixed;
+        const first = this.first();
+        if (f.spec.name === 'value' && first === 'all')
+            return ['on', 'off'];
+        if (f.spec.name === 'value' && first === 'roots')
+            return ['list', 'add', 'remove'];
+        if (f.spec.name === 'folder' && this.valueOf('value') === 'remove')
+            return new ProjectsService(this.ctx).list().roots;
+        return [];
+    }
+    /** Changes one field with the input that fits it. Returns a notice to show (when there is something to say). */
     async edit(f, path) {
         const id = this.id(f);
         const current = this.values.get(id);
         if (f.kind === 'json' || (f.kind === 'option' && f.spec.type === 'boolean')) {
             this.values.set(id, current !== true);
-            return;
+            return undefined;
         }
-        const label = f.kind === 'extra' ? 'Arguments' : f.kind === 'arg' ? Text.humanize(f.spec.name) : f.spec.flag;
-        const about = f.kind === 'extra' ? [] : [f.spec.description];
+        const label = f.kind === 'extra' ? 'Arguments' : f.kind === 'arg' ? argLabel(f.spec) : optionLabel(f.spec);
+        const about = f.kind === 'extra' ? [] : [plainDescription(f.spec.description, this.actions())];
+        const here = [...path, label];
         if (f.kind === 'arg' && this.spec.name === 'data' && f.spec.name === 'targets') {
             const picked = await this.dataTargets(path);
             if (picked)
                 this.values.set(id, picked);
-            return;
+            return undefined;
         }
-        const list = f.kind === 'extra' ? [] : this.choices(f.spec.choices);
         const many = (f.kind === 'option' && f.spec.type === 'list') || (f.kind === 'arg' && f.spec.variadic);
+        const list = this.options(f);
         if (list.length && many) {
             const picked = await this.app.list({
-                path: [...path, label],
+                path: here,
                 intro: about,
                 multi: true,
                 items: list.map((v) => ({ value: v, label: v, checked: Array.isArray(current) && current.includes(v) })),
             });
             if (picked.kind === 'multi')
-                this.values.set(id, picked.values);
-            return;
+                this.set(id, picked.values);
+            return undefined;
+        }
+        if (f.kind === 'arg' && this.spec.name === 'projects' && f.spec.name === 'value' && this.projectAction()) {
+            await this.projectFolder(id, here, about);
+            return undefined;
         }
         if (list.length) {
             const optional = !(f.kind === 'arg' && f.spec.required);
-            const picked = await this.app.choose([...path, label], about.join(' '), [
+            const picked = await this.app.choose(here, about.join(' '), [
                 ...list.map((v) => ({ value: v, label: v })),
                 ...(optional ? [{ value: '', label: Theme.muted('(not set)') }] : []),
             ], Array.isArray(current) ? current[0] : undefined);
-            if (picked !== undefined) {
-                if (picked === '')
-                    this.values.delete(id);
-                else
-                    this.values.set(id, [picked]);
-            }
-            return;
+            if (picked !== undefined)
+                this.set(id, picked === '' ? [] : [picked]);
+            return undefined;
         }
-        if (f.kind === 'arg' && typeof f.spec.choices === 'string')
-            fail('There is nothing to choose from: no ' + f.spec.choices + ' yet.', f.spec.choices === 'accounts'
-                ? 'Sign in inside the sandbox, then run: sandbox account save <name>'
-                : 'Start one first (sandbox claude).');
+        if (f.kind !== 'extra' && typeof f.spec.choices === 'string' && !this.freeText(f))
+            return this.nothingToChoose(f.spec.choices);
+        const kind = this.pathKind(f);
+        if (kind && f.kind !== 'extra') {
+            if (many)
+                return this.pathList(id, here, about, kind);
+            const picked = await askPath(this.app, {
+                path: here,
+                title: kind === 'file' ? 'Choose the file' : 'Choose the folder',
+                about,
+                kind,
+                initial: Array.isArray(current) ? current[0] : '',
+                validate: (v) => this.pathProblem(f, v),
+            });
+            if (picked !== undefined)
+                this.set(id, [picked]);
+            return undefined;
+        }
+        if (f.kind === 'option' && f.spec.type === 'list')
+            return this.pathList(id, here, about, undefined);
+        const number = f.kind === 'option' && f.spec.type === 'number' ? f.spec : undefined;
         const typed = await this.app.text({
-            path: [...path, label],
+            path: here,
             label,
             about,
             allowEmpty: true,
+            accept: number ? /[0-9]/ : undefined,
+            hint: number
+                ? 'A whole number greater than 0' + (number.default !== undefined ? '. Default: ' + number.default : '') + '.'
+                : undefined,
             initial: Array.isArray(current)
                 ? many || f.kind === 'extra'
                     ? current.map((x) => (/\s/.test(x) ? '"' + x + '"' : x)).join(' ')
@@ -276,12 +360,51 @@ export class CommandForm {
             validate: (v) => (f.kind === 'option' ? (optionProblem(f.spec, v) ?? true) : true),
         });
         if (typed === undefined)
+            return undefined;
+        this.set(id, many || f.kind === 'extra' ? splitArgs(typed) : typed.trim() ? [typed.trim()] : []);
+        return undefined;
+    }
+    /** Is the problem with a picked path (true = fine)? Moving or switching the data folder has its own rules. */
+    pathProblem(f, picked) {
+        if (this.spec.name === 'storage' && f.kind === 'arg') {
+            const problem = moveProblem(this.ctx.storageRoot, picked, true);
+            return problem ? problem.message : true;
+        }
+        return f.kind === 'option' ? (optionProblem(f.spec, picked) ?? true) : true;
+    }
+    /** Several folders or files (--script ...): a list to add to, change and remove from. */
+    async pathList(id, path, about, kind) {
+        const node = new SchemaNode(z.array(z.string()).describe(about.join(' ')));
+        const edited = await new StringListEditor(this.app, path, node, new ValueEditor(this.app), [], kind, 'Esc keeps it for the command').run(Array.isArray(this.values.get(id)) ? [...this.values.get(id)] : []);
+        if (edited)
+            this.set(id, edited.value);
+        return undefined;
+    }
+    /** projects remove / include / exclude pick from the known projects (or any folder); add takes a folder. */
+    projectAction() {
+        return ['remove', 'include', 'exclude'].includes(this.first());
+    }
+    async projectFolder(id, path, about) {
+        const known = new ProjectsService(this.ctx).list().projects.map((p) => p.folder);
+        const current = this.values.get(id);
+        const picked = await this.app.choose(path, about.join(' '), [...known.map((v) => ({ value: v, label: v })), { value: OTHER, label: 'Another folder…' }], Array.isArray(current) ? current[0] : undefined);
+        if (picked === undefined)
             return;
-        const value = many || f.kind === 'extra' ? splitArgs(typed) : typed.trim() ? [typed.trim()] : [];
-        if (value.length)
-            this.values.set(id, value);
-        else
-            this.values.delete(id);
+        if (picked !== OTHER) {
+            this.set(id, [picked]);
+            return;
+        }
+        const folder = await askPath(this.app, { path, title: 'Choose the folder', about, kind: 'dir' });
+        if (folder !== undefined)
+            this.set(id, [folder]);
+    }
+    /** Nothing to pick from (no saved logins, no running session): say what to do, in the form, without an error. */
+    nothingToChoose(what) {
+        return Theme.warn(what === 'accounts'
+            ? 'No saved logins yet: sign in inside the sandbox, then save it in Accounts.'
+            : what === 'sessions'
+                ? 'No session is running: start an agent first.'
+                : 'There is nothing to choose from yet.');
     }
     /** `data clean` targets, ticked from a list with their sizes (never "all": that is typed on purpose). */
     async dataTargets(path) {

package/dist/cli/menu/data-folder.d.ts

@@ -0,0 +1,18 @@
+import type { Context } from '../commands/context.js';
+import type { App } from '../tui/index.js';
+import type { ShellExit } from './shell.js';
+/** The row in Settings and Maintenance. */
+export declare function dataFolderRow(ctx: Context): {
+    label: string;
+    hint: string;
+    description: string;
+};
+export declare class DataFolderFlow {
+    private readonly app;
+    private readonly ctx;
+    constructor(app: App, ctx: Context);
+    /** The command to run (move or use), or undefined when nothing was chosen. */
+    run(): Promise<ShellExit | undefined>;
+    private measure;
+    private decide;
+}

package/dist/cli/menu/data-folder.js

@@ -0,0 +1,99 @@
+// The "Data folder" row and its flow: shows where the saved data is, lets you pick another folder in the path picker,
+// asks whether to move the data or only switch, and hands the command to run on the normal screen (the move prints its
+// progress there).
+import fs from 'node:fs';
+import { humanBytes } from '../../core/disk.js';
+import { describeDuration, describeSize, estimate, holdsData, measureFolder, moveProblem, moveWarning, } from '../../host/storage/index.js';
+/** Measuring for the dialog stops after this long (the size then reads "at least"). */
+const MEASURE_MS = 8000;
+/** The row in Settings and Maintenance. */
+export function dataFolderRow(ctx) {
+    return {
+        label: 'Data folder',
+        hint: ctx.storageRoot,
+        description: 'Where your tools, logins, history and logs are kept between sandboxes. Press Enter to move them to another folder or drive, or to use a different folder.',
+    };
+}
+export class DataFolderFlow {
+    app;
+    ctx;
+    constructor(app, ctx) {
+        this.app = app;
+        this.ctx = ctx;
+    }
+    /** The command to run (move or use), or undefined when nothing was chosen. */
+    async run() {
+        const from = this.ctx.storageRoot;
+        const exists = fs.existsSync(from);
+        const measured = exists ? this.measure(from) : { bytes: 0, files: 0, partial: false };
+        const size = exists && holdsData(from) ? describeSize(measured) : 'nothing in it yet';
+        const to = await this.app.pickPath({
+            path: ['Data folder'],
+            title: 'Choose the folder for your saved data',
+            about: [
+                'Now: ' + from + ' (' + size + ').',
+                'Pick a new or empty folder to move your data there, or a folder that already holds data to use it.',
+            ],
+            initial: from.replace(/[\\/][^\\/]*$/, '\\'),
+            use: 'use this folder',
+            validate: (picked) => {
+                const problem = moveProblem(from, picked, true);
+                return problem ? problem.message : true;
+            },
+        });
+        if (!to)
+            return undefined;
+        return this.decide(from, to, measured, exists);
+    }
+    measure(from) {
+        const before = this.app.status;
+        this.app.status = () => 'Measuring your saved data…';
+        this.app.redraw();
+        try {
+            return measureFolder(from, MEASURE_MS);
+        }
+        finally {
+            this.app.status = before;
+        }
+    }
+    async decide(from, to, measured, exists) {
+        if (to.toLowerCase() === from.toLowerCase())
+            return undefined;
+        const target = holdsData(to);
+        const lines = [];
+        let canMove = exists && holdsData(from) && !target;
+        if (canMove) {
+            const est = estimate(from, to, measured);
+            lines.push('From: ' + from, 'To:   ' + to, 'Size: ' + describeSize(measured));
+            lines.push(est.sameVolume
+                ? 'Time: a few seconds (same drive, nothing is copied)'
+                : 'Time: ' + describeDuration(est.seconds) + ' (copied to another drive)');
+            if (est.freeBytes !== null)
+                lines.push('Free space on the target drive: ' + humanBytes(est.freeBytes));
+            const warning = moveWarning(measured, est);
+            if (warning)
+                lines.push('', warning);
+            if (!est.fits)
+                canMove = false;
+        }
+        else {
+            lines.push(target ? to + ' already holds data, so it is used as it is.' : 'There is nothing in ' + from + ' to move.', 'Your data stays where it is.');
+        }
+        const choice = await this.app.dialog({
+            title: canMove ? 'Move your data to ' + to + '?' : 'Use ' + to + '?',
+            lines: [...lines, '', 'Use without moving: the new folder is used from now on and your old data is left behind.'],
+            choices: [
+                ...(canMove ? [{ value: 'move', label: 'Move data', key: 'm' }] : []),
+                { value: 'use', label: 'Switch without moving', key: 's' },
+                { value: 'cancel', label: 'Cancel', key: 'c' },
+            ],
+            initial: 0,
+            escape: 'cancel',
+        });
+        if (choice === 'move')
+            return { kind: 'run', argv: ['storage', 'move', to, '--yes'] };
+        if (choice === 'use')
+            return { kind: 'run', argv: ['storage', 'use', to, '--yes'] };
+        return undefined;
+    }
+}

package/dist/cli/menu/io-menu.d.ts

@@ -0,0 +1,29 @@
+import { type Action, type AnyDefinition } from '../../app/kernel/index.js';
+import type { Context } from '../commands/context.js';
+import { type App } from '../tui/index.js';
+import type { ShellExit } from './shell.js';
+/** Where the dialogs say they are (the menu's path line). */
+type Where = readonly string[];
+/** How a page shows progress while an operation runs (ListPage.busy). */
+export type ShowBusy = (text: string) => void;
+/** What an action did: leave the menu to run a command, and/or a notice after the page loads again. */
+export interface Performed {
+    readonly exit?: ShellExit;
+    readonly notice?: string;
+    readonly reload?: boolean;
+}
+export declare class MenuOperations {
+    private readonly app;
+    private readonly ctx;
+    constructor(app: App, ctx: Context);
+    /** Does what an action of a page says: follows a link, or asks for its fields and runs its operation. */
+    perform(action: Action, where: Where, busy?: ShowBusy): Promise<Performed>;
+    /** The values of an action's fields, from the editors that fit them (undefined: one was backed out of). */
+    private fields;
+    /**
+     * Runs a definition with this input and returns the notice to show: its text (✓), the problem and its fix (✘), or
+     * undefined when a question was declined (nothing changed, nothing to say).
+     */
+    run(def: AnyDefinition, input: unknown, where: Where, busy?: ShowBusy): Promise<string | undefined>;
+}
+export {};

package/dist/cli/menu/io-menu.js

@@ -0,0 +1,126 @@
+// Running the shared core's actions inside the menu: an operation's questions become the menu's dialogs (yes/no over
+// the screen, a text field, the path picker, a list), its fields the settings editors, its progress the page's notice,
+// and what it said so far is shown above its next question. The result is one notice line: what it did, or what went
+// wrong and how to fix it. A link leaves the menu for what needs the terminal (attach, a start).
+import { operationById } from '../../app/features/defs.js';
+import { runDefinition } from '../../app/registry.js';
+import { Cancelled, ioFromAsker, SchemaNode, toWireError, } from '../../app/kernel/index.js';
+import { errMsg } from '../../core/util/index.js';
+import { Theme } from '../tui/index.js';
+import { askPath } from './settings/ask-path.js';
+import { ValueEditor } from './settings/value-editor.js';
+async function ask(app, where, q, said) {
+    const lines = [...said, ...(q.lines ?? []), ...('problem' in q && q.problem ? [Theme.warn(q.problem)] : [])];
+    const path = [...where];
+    switch (q.kind) {
+        case 'confirm': {
+            if (!q.typed)
+                return app.ask(q.title, lines, q.yes ?? 'Yes', q.danger ?? false);
+            const typed = await app.text({ path, label: 'Type "' + q.typed + '" to confirm', about: [q.title, ...lines] });
+            return typed?.trim().toLowerCase() === q.typed;
+        }
+        case 'choose':
+            return app.choose(path, [q.title, ...lines].join(' '), q.choices, q.initial);
+        case 'checklist': {
+            const picked = await app.list({
+                path,
+                intro: [q.title, ...lines],
+                multi: true,
+                items: q.choices.map((ch) => ({ ...ch, checked: q.checked?.includes(ch.value) ?? false })),
+            });
+            return picked.kind === 'multi' ? picked.values : undefined;
+        }
+        case 'path':
+            return askPath(app, {
+                path,
+                title: q.title,
+                about: lines,
+                kind: q.pathKind,
+                initial: q.initial,
+                literals: q.literals,
+            });
+        case 'text':
+        case 'secret':
+            return app.text({
+                path,
+                label: q.title,
+                about: lines,
+                initial: q.kind === 'text' ? q.initial : undefined,
+                allowEmpty: q.kind === 'text' ? q.allowEmpty : false,
+                masked: q.kind === 'secret',
+            });
+    }
+}
+/** Where a link goes in the menu: what needs the terminal is run on the normal screen. */
+function follow(target) {
+    switch (target.kind) {
+        case 'terminal':
+            return { exit: { kind: 'run', argv: ['attach', target.session] } };
+        case 'start-agent':
+            return { exit: { kind: 'run', argv: ['launch', '--harness', target.agent] } };
+        case 'command':
+            return { exit: { kind: 'run', argv: [...target.argv] } };
+        case 'view':
+            return {};
+    }
+}
+export class MenuOperations {
+    app;
+    ctx;
+    constructor(app, ctx) {
+        this.app = app;
+        this.ctx = ctx;
+    }
+    /** Does what an action of a page says: follows a link, or asks for its fields and runs its operation. */
+    async perform(action, where, busy) {
+        if (action.kind === 'link')
+            return follow(action.target);
+        const def = operationById(action.op);
+        if (!def)
+            return { notice: Theme.error(Theme.glyph.cross + ' Unknown operation ' + action.op + '.') };
+        const answers = await this.fields(action, def, where);
+        if (!answers)
+            return {};
+        return { reload: true, notice: await this.run(def, { ...action.input, ...answers }, where, busy) };
+    }
+    /** The values of an action's fields, from the editors that fit them (undefined: one was backed out of). */
+    async fields(action, def, where) {
+        const answers = {};
+        const editor = new ValueEditor(this.app);
+        for (const field of action.fields ?? []) {
+            const node = new SchemaNode(def.input).child(field.name);
+            if (!node)
+                continue;
+            const edited = await editor.edit([...where, field.label], [...field.key], node, action.initial?.[field.name]);
+            if (!edited)
+                return undefined;
+            answers[field.name] = edited.value;
+        }
+        return answers;
+    }
+    /**
+     * Runs a definition with this input and returns the notice to show: its text (✓), the problem and its fix (✘), or
+     * undefined when a question was declined (nothing changed, nothing to say).
+     */
+    async run(def, input, where, busy = () => undefined) {
+        const said = [];
+        const asker = async (q) => (await ask(this.app, where, q, said.splice(0)));
+        const io = ioFromAsker(asker, {
+            progress: (text) => busy(Theme.muted(text + '…')),
+            log: (text, tone) => said.push(tone === 'warn' || tone === 'danger' ? Theme.warn(text) : text),
+        });
+        try {
+            const output = await runDefinition(def.id, this.ctx, input, io);
+            const text = def.text?.(output);
+            return text ? Theme.ok(Theme.glyph.ok + ' ' + text) : undefined;
+        }
+        catch (e) {
+            if (e instanceof Cancelled)
+                return undefined;
+            const problem = toWireError(e);
+            if (problem.kind === 'bug')
+                return Theme.error(Theme.glyph.cross + ' ' + errMsg(e));
+            return (Theme.error(Theme.glyph.cross + ' ' + problem.message) + (problem.fix ? Theme.muted('  ' + problem.fix) : ''));
+        }
+    }
+}

package/dist/cli/menu/live.d.ts

@@ -0,0 +1,27 @@
+export interface LiveOptions {
+    /** Fetches the process list (default: tasklist, run without blocking). */
+    readonly fetch?: () => Promise<string>;
+    /** The status line from the facts now (reads the cached process list and small files; never runs a program). */
+    readonly derive: () => string;
+    /** The line changed: draw again. */
+    readonly onChange: () => void;
+    readonly intervalMs?: number;
+}
+export declare class LiveStatus {
+    private readonly o;
+    private tasklist;
+    private text;
+    private timer;
+    private pending;
+    private running;
+    constructor(o: LiveOptions);
+    /** The status line as of the last refresh. */
+    line(): string;
+    /** Reads the process list now and derives the line (one fetch at a time; a caller during one waits for it). */
+    refresh(): Promise<void>;
+    private derive;
+    /** Starts keeping the line fresh and answers the host's process questions from it (until stop). */
+    start(): Promise<void>;
+    /** Stops; the host's questions run their own programs again (a command that runs after the menu needs the truth). */
+    stop(): void;
+}