windows-development-sandbox 1.9.0 → 1.11.3

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

@@ -1,18 +1,20 @@
 // Section 7: keeping things in shape. Updates (the program and your saved settings), Data & storage (the data folder,
 // what is stored, clean-up), Health (doctor, repair and this PC's setup together), the logs, and the less common
 // commands. Each is a category on the left and loads when you open it.
-import _ from 'lodash';
-import { humanBytes } from '../../../core/disk.js';
-import { userDir } from '../../../core/config/index.js';
-import { errMsg, fail } from '../../../core/util/index.js';
-import { cleanTargetOf } from '../../commands/data/collect.js';
+import { dataPage, showData } from '../../../app/features/data/index.js';
+import { readQuery } from '../../../app/registry.js';
+import { errMsg } from '../../../core/util/index.js';
+import { enginePage, engineLeftovers, engineStatus, } from '../../../app/features/engine/index.js';
+import { healthPage, lastHealth } from '../../../app/features/health/index.js';
+import { containedStatus, showStorage, storagePage, } from '../../../app/features/storage/index.js';
+import { CRASH, listLogs, logsPage } from '../../../app/features/logs/index.js';
+import { updatesPage, updatesStatus } from '../../../app/features/updates/updates.def.js';
+import { webPage, webStatus } from '../../../app/features/web/index.js';
 import { commandSpec } from '../../manifest.js';
-import { ago } from '../../output/index.js';
-import { DataService, HealthService, LogsService, MigrateService, NPM_UPDATE_COMMAND, UpdateService, } from '../../services/index.js';
-import { describeResult } from '../../commands/maintenance/update.js';
 import { Text, Theme, } from '../../tui/index.js';
 import { CommandForm } from '../command-form.js';
-import { DataFolderFlow, dataFolderRow } from '../data-folder.js';
+import { MenuOperations } from '../io-menu.js';
+import { menuView } from '../render-view.js';
 import { ListPage } from './list-page.js';
 const CATEGORIES = [
     {
@@ -31,9 +33,22 @@ const CATEGORIES = [
         description: 'Checks this PC and your settings, repairs problems, and sets up Windows Sandbox.',
     },
     { id: 'logs', label: 'Logs', description: "The sandbox's own logs." },
+    {
+        id: 'web',
+        label: 'Web UI',
+        description: 'The web UI server on this PC: start it, open it in your browser, stop it.',
+    },
+    {
+        id: 'engine',
+        label: 'Engine',
+        description: 'What runs your sandbox, and what each engine can do on this PC.',
+    },
     { id: 'more', label: 'More commands', description: 'Less common commands.' },
 ];
 const MORE_COMMANDS = ['sync', 'audit', 'config', 'generate', 'exec', 'agent-commands'];
+const NO_LOGS = { folder: '', files: [], crash: false };
+/** Until the status is read: the server counts as not running. */
+const NO_WEB = { running: false, port: null, address: null };
 /** Plain names for the commands under More commands. */
 const MORE_LABELS = {
     sync: 'Copy history back now',
@@ -43,33 +58,21 @@ const MORE_LABELS = {
     exec: 'Run a command in the sandbox',
     'agent-commands': 'Agent commands (Beta)',
 };
-const REPAIR_LABEL = {
-    ok: ['OK', Theme.ok],
-    fixed: ['FIXED', Theme.accent],
-    'needs-you': ['NEEDS YOU', Theme.error],
-    warn: ['WARNING', Theme.warn],
-    skipped: ['SKIPPED', Theme.muted],
-};
-const AREA_LABEL = {
-    tools: 'Toolchains',
-    databases: 'Databases',
-    state: 'Agent state',
-    logs: 'Logs',
-    data: 'Other',
-    host: 'On this PC',
-};
+/** The Data & storage category's rows and keys once measured: the data view (src/app/features/data) as menu rows. */
+function dataMenuView(data) {
+    return data ? menuView(dataPage(data), { category: 'data', prefix: 'data:', refresh: false }) : undefined;
+}
+/** The storage view (the data folder, contained storage) as menu rows, drawn above the data rows. */
+function storageMenu(s) {
+    return s
+        ? menuView(storagePage(s.show, s.contained), { category: 'data', prefix: 'storage:', refresh: false })
+        : undefined;
+}
 function dataItems(m) {
-    const folder = { value: 'data:folder', category: 'data', section: 'Data folder', ...m.dataFolder };
-    const clean = {
-        value: 'data:clean',
-        label: 'Clean up…',
-        category: 'data',
-        section: 'Clean up',
-        description: 'Delete caches, old sandboxes and other leftovers (the clean command, with its options).',
-    };
+    const storage = storageMenu(m.storage)?.items ?? [];
     if (!m.data)
         return [
-            folder,
+            ...storage,
             {
                 value: 'data:measure',
                 label: 'Measure what is stored',
@@ -77,157 +80,46 @@ function dataItems(m) {
                 section: 'Stored data',
                 description: 'Adds up the size of every folder. A big data folder takes a minute or more.',
             },
-            clean,
         ];
-    return [
-        folder,
-        ...m.data.disks.map((d) => ({
-            value: 'disk:' + d.drive,
-            label: d.drive,
-            category: 'data',
-            section: 'Disks',
-            hint: humanBytes(d.usedBytes) + ' used · ' + humanBytes(d.freeBytes) + ' free of ' + humanBytes(d.totalBytes),
-            description: d.holdsStorage ? 'The sandbox keeps its files on this drive.' : undefined,
-        })),
-        ...m.data.entries.map((e, i) => ({
-            value: 'entry:' + i,
-            label: e.name,
-            category: 'data',
-            section: AREA_LABEL[e.area],
-            hint: humanBytes(e.bytes),
-            description: cleanTargetOf(e) ? 'x deletes it.' : 'Kept on this PC on purpose; it is not deleted here.',
-            details: [Theme.muted('Folder  ') + e.path],
-        })),
-        clean,
-    ];
+    return [...storage, ...(dataMenuView(m.data)?.items ?? [])];
 }
-function updateItems(m) {
-    const row = (id, label, hint, description, details) => ({
-        value: 'updates:' + id,
-        label,
-        category: 'updates',
-        section: 'This program',
-        hint,
-        description,
-        details,
-    });
-    if ('error' in m.updates)
-        return [row('error', m.updates.error, '')];
-    const u = m.updates;
-    if (!u.managed)
-        return [
-            row('version', 'Version', u.version, 'Installed with npm, so npm updates it: ' + NPM_UPDATE_COMMAND),
-            row('npm', 'Update', Theme.muted('with npm'), 'Run ' + NPM_UPDATE_COMMAND + ' in a terminal.'),
-        ];
-    const scope = u.scope === 'machine' ? 'for everyone on this PC' : 'for you';
-    const rows = [
-        row('version', 'Version', u.version, 'Installed ' + scope + '.'),
-        row('latest', 'Newest version', m.latest ? Theme.warn(m.latest) : Theme.muted('not looked yet'), m.latest ? 'Enter installs it.' : 'Enter looks on GitHub for a newer version.'),
-        row('auto', 'Automatic updates', u.autoUpdate ? Theme.ok('on') : Theme.muted('off'), 'Enter switches them. ' +
-            (u.scope === 'machine'
-                ? 'For everyone: needs an admin terminal.'
-                : 'A new version installs when no sandbox runs.')),
-    ];
-    if (u.autoOffText)
-        rows.push(row('autooff', 'Automatic updates turned off', Theme.warn('off'), u.autoOffText, [u.autoOffText]));
-    if (u.state.previous)
-        rows.push(row('previous', 'Previous version', u.state.previous, 'Enter goes back to it.'));
-    if (u.state.failed)
-        rows.push(row('failed', 'Last failed update', Theme.error(u.state.failed.version), u.state.failed.reason, [
-            u.state.failed.reason,
-            'It is not tried again until a newer version is released.',
-        ]));
-    return rows;
+/** The Updates view (src/app/features/updates) as the menu's rows, keys and Enter labels, for the Updates category. */
+function updatesMenu(m) {
+    return menuView(updatesPage(m.updates.status, m.updates.latest), { category: 'updates', refresh: false });
+}
+/** A value the page shows before the first read (the status is read when the page loads). */
+const NO_UPDATES = {
+    managed: false,
+    version: '',
+    scope: null,
+    autoUpdate: false,
+    autoOffText: null,
+    previous: null,
+    failed: null,
+    npmCommand: '',
+    error: null,
+    settings: { pending: [], error: null },
+};
+/**
+ * The logs view's rows and keys for the Logs category (its own empty row is left out: the category shows the page's
+ * "Nothing here yet.").
+ */
+function logsMenu(files) {
+    return menuView({ ...logsPage(files), empty: undefined }, { category: 'logs', refresh: false });
+}
+/** The Web UI view (src/app/features/web) as the menu's rows, keys and Enter labels, for the Web UI category. */
+function webMenu(m) {
+    return menuView(webPage(m.web), { category: 'web', prefix: 'web:', refresh: false });
 }
 /** The list for the maintenance tab. Pure. */
 export function maintenanceOptions(m) {
-    const logs = m.logs.map((f) => ({
-        value: 'log:' + f.name,
-        label: f.name,
-        category: 'logs',
-        hint: humanBytes(f.bytes) + '  ' + ago(f.modified),
-        description: 'Enter shows the end of this log in the terminal.',
-    }));
-    // The checks take seconds (programs are run), so they are not made while you move through the categories.
-    const check = m.doctor === null && m.setup === null
-        ? [
-            {
-                value: 'health:check',
-                label: 'Check this PC',
-                category: 'health',
-                section: 'Doctor',
-                description: 'Looks at this PC: Windows features, the install, the folders and the sandbox. It takes a few seconds, so it only runs when you ask.',
-            },
-        ]
-        : [];
-    const doctor = (m.doctor ?? []).map(([name, detail], i) => ({
-        value: 'doctor:' + i,
-        label: name,
-        category: 'health',
-        section: 'Doctor',
-        hint: Text.truncate(detail, 50),
-        details: [detail],
-    }));
-    const repair = m.repair
-        ? m.repair.map((r, i) => {
-            const [text, paint] = REPAIR_LABEL[r.status];
-            return {
-                value: 'repair:' + i,
-                label: r.name,
-                category: 'health',
-                section: 'Repair',
-                hint: paint(text),
-                description: r.detail,
-            };
-        })
-        : [
-            {
-                value: 'repair:run',
-                label: 'Run the checks and fix what can be fixed',
-                category: 'health',
-                section: 'Repair',
-                description: 'Checks the install, data folder, settings and sandbox, lists what it would change, and asks before it fixes anything.',
-            },
-        ];
-    const setup = m.setup === null
-        ? []
-        : 'error' in m.setup
-            ? [{ value: 'setup:error', label: m.setup.error, category: 'health', section: 'Set up this PC' }]
-            : m.setup.checks.map((c, i) => ({
-                value: 'setup:' + i,
-                label: c.name,
-                category: 'health',
-                section: 'Set up this PC',
-                hint: c.status === 'ok'
-                    ? Theme.ok('OK')
-                    : c.status === 'warn'
-                        ? Theme.warn('WARNING')
-                        : Theme.error('ACTION NEEDED'),
-                description: c.detail,
-            }));
-    const settings = 'error' in m.settings
-        ? [{ value: 'settings:error', label: m.settings.error, category: 'updates', section: 'Saved settings' }]
-        : m.settings.pending.length
-            ? m.settings.pending.map((line, i) => ({
-                value: 'settings:' + i,
-                label: line.split(':')[0],
-                category: 'updates',
-                section: 'Saved settings',
-                hint: Theme.warn('to update'),
-                description: 'Enter updates your saved settings (a backup is kept first).',
-                details: [line],
-            }))
-            : [
-                {
-                    value: 'settings:none',
-                    label: 'Up to date',
-                    category: 'updates',
-                    section: 'Saved settings',
-                    hint: Theme.ok('OK'),
-                    description: 'Nothing to update.',
-                },
-            ];
-    const updates = updateItems(m);
+    // The logs rows have no section heading of their own: the category is their heading.
+    const logs = logsMenu(m.logs).items.map(({ section: _section, ...row }) => row);
+    // The checks take seconds (programs are run), so they only run when you ask: the page shows the saved results.
+    const health = healthMenu(m);
+    const updates = updatesMenu(m);
+    const engine = engineMenu(m);
+    const web = webMenu(m);
     const more = m.more.map((c) => ({
         value: 'more:' + c.name,
         label: MORE_LABELS[c.name] ?? Text.humanize(c.name),
@@ -237,32 +129,53 @@ export function maintenanceOptions(m) {
     return {
         path: [],
         categories: CATEGORIES,
-        items: [...updates, ...settings, ...dataItems(m), ...check, ...doctor, ...repair, ...setup, ...logs, ...more],
+        items: [...updates.items, ...dataItems(m), ...health.items, ...logs, ...web.items, ...engine.items, ...more],
         empty: 'Nothing here yet.',
         actions: maintenanceActions(m),
-        enterLabel: (_category, id) => enterLabel(id ?? '', m),
+        enterLabel: (category, id) => category === 'health'
+            ? health.enterLabel(category, id)
+            : category === 'updates'
+                ? updates.enterLabel(category, id)
+                : category === 'engine'
+                    ? engine.enterLabel(category, id)
+                    : category === 'web'
+                        ? web.enterLabel(category, id)
+                        : (category === 'data'
+                            ? storageMenu(m.storage)?.enterLabel(category, id) || dataMenuView(m.data)?.enterLabel(category, id)
+                            : undefined) || enterLabel(id ?? ''),
     };
 }
+/**
+ * The Engine category: before the first read, one row that reads the engines on Enter (the checks run programs, so
+ * they are not made just by opening the category); after it, the engine view's rows.
+ */
+function engineMenu(m) {
+    if (!m.engine) {
+        const load = {
+            value: 'engine:load',
+            label: 'Look at the engines',
+            category: 'engine',
+            section: 'Engines',
+            description: 'Checks what each engine needs on this PC. It runs a few Windows programs, so it only runs when asked.',
+        };
+        return { items: [load], actions: [], enterLabel: () => 'check', resolve: () => undefined };
+    }
+    return menuView(enginePage(m.engine, m.leftovers ?? undefined), {
+        category: 'engine',
+        prefix: 'engine:',
+        refresh: false,
+    });
+}
+/** The Health category: the health view's rows and keys, drawn only while that category is open. */
+function healthMenu(m) {
+    return menuView(healthPage({ last: m.health.last }), { category: 'health', refresh: false });
+}
 /** What Enter does on a row ("" = the row only shows information). */
-function enterLabel(id, m) {
-    if (id === 'data:folder')
-        return 'change';
+function enterLabel(id) {
     if (id === 'data:measure')
         return 'measure';
-    if (id === 'data:clean')
-        return 'choose what';
-    if (id === 'repair:run')
-        return 'check and fix';
-    if (id === 'health:check')
+    if (id === 'engine:load')
         return 'check';
-    if (id === 'updates:latest')
-        return m.latest ? 'install' : 'look';
-    if (id === 'updates:auto')
-        return 'switch';
-    if (id === 'updates:previous')
-        return 'go back';
-    if (id.startsWith('settings:') && id !== 'settings:none' && id !== 'settings:error')
-        return 'update';
     if (id.startsWith('log:'))
         return 'show';
     if (id.startsWith('more:'))
@@ -272,48 +185,22 @@ function enterLabel(id, m) {
 function maintenanceActions(m) {
     return (category) => {
         switch (category) {
-            case 'data': {
-                const deletable = new Set((m.data?.entries ?? []).flatMap((e, i) => (cleanTargetOf(e) ? ['entry:' + i] : [])));
+            case 'data':
                 return [
                     { key: 'm', label: 'measure again' },
-                    { key: 'x', label: 'delete', applies: (id) => deletable.has(id) },
+                    ...(storageMenu(m.storage)?.actions ?? []),
+                    ...(dataMenuView(m.data)?.actions ?? []),
                 ];
-            }
             case 'logs':
-                return [{ key: 'f', label: 'follow in the terminal' }];
-            case 'health': {
-                const canEnable = m.setup !== null && !('error' in m.setup) && m.setup.canEnable;
-                return [
-                    { key: 'f', label: 'check and fix' },
-                    { key: 'l', label: m.doctor ? 'check again' : 'check' },
-                    ...(canEnable ? [{ key: 'e', label: 'turn on Windows Sandbox' }] : []),
-                ];
-            }
-            case 'updates': {
-                const managed = !('error' in m.updates) && m.updates.managed;
-                const previous = !('error' in m.updates) && Boolean(m.updates.state.previous);
-                return [
-                    ...(managed
-                        ? [
-                            { key: 'c', label: 'check now' },
-                            { key: 'u', label: 'update now' },
-                            { key: 'a', label: 'automatic on/off', applies: (id) => id === 'updates:auto' },
-                            ...(previous
-                                ? [{ key: 'r', label: 'roll back', applies: (id) => id === 'updates:previous' }]
-                                : []),
-                        ]
-                        : []),
-                    ...('pending' in m.settings && m.settings.pending.length
-                        ? [
-                            {
-                                key: 's',
-                                label: 'update saved settings',
-                                applies: (id) => id.startsWith('settings:') && id !== 'settings:none',
-                            },
-                        ]
-                        : []),
-                ];
-            }
+                return logsMenu(m.logs).actions;
+            case 'health':
+                return healthMenu(m).actions;
+            case 'updates':
+                return updatesMenu(m).actions;
+            case 'engine':
+                return [{ key: 'l', label: m.engine ? 'check again' : 'check' }, ...engineMenu(m).actions];
+            case 'web':
+                return webMenu(m).actions;
             default:
                 return [];
         }
@@ -323,181 +210,122 @@ export class MaintenancePage extends ListPage {
     ctx;
     label = 'Maintenance';
     data = null;
-    logs = [];
-    doctorRows = null;
-    repairRows = null;
-    setupReport = null;
-    settings = { pending: [] };
-    migrate;
-    health;
-    dataService;
-    updateService;
+    storage = null;
+    logs = NO_LOGS;
+    last = null;
+    updates = NO_UPDATES;
+    engine = null;
+    leftovers = null;
+    web = NO_WEB;
+    operations;
+    /** The newer version the last check found (null: none, or not looked yet). */
     latest = null;
     constructor(app, ctx) {
         super(app);
         this.ctx = ctx;
-        this.updateService = UpdateService.forPackage(ctx.packageRoot, undefined, { userDir: userDir() });
-        this.health = new HealthService(ctx);
-        this.migrate = new MigrateService({
-            storageRoot: ctx.storageRoot,
-            userDir: userDir(),
-            configPath: ctx.loaded.configPath,
-        });
-        this.dataService = new DataService(ctx);
+        this.operations = new MenuOperations(app, ctx);
     }
     model() {
         return {
-            dataFolder: dataFolderRow(this.ctx),
+            storage: this.storage,
             data: this.data,
             logs: this.logs,
-            doctor: this.doctorRows,
-            repair: this.repairRows,
-            setup: this.setupReport,
-            settings: this.settings,
-            updates: this.updateStatus(),
-            latest: this.latest,
+            health: { last: this.last },
+            updates: { status: this.updates, latest: this.latest },
+            engine: this.engine,
+            leftovers: this.leftovers,
+            web: this.web,
             more: MORE_COMMANDS.flatMap((name) => {
                 const spec = commandSpec(name);
                 return spec ? [{ name, summary: spec.summary }] : [];
             }),
         };
     }
-    load() {
+    async load() {
         try {
-            this.logs = new LogsService(this.ctx).files();
+            this.storage = {
+                show: await readQuery(showStorage, this.ctx, { measure: false }),
+                contained: await readQuery(containedStatus, this.ctx),
+            };
         }
         catch {
-            this.logs = [];
+            this.storage = null;
         }
-        this.readSettings();
-        return Promise.resolve();
-    }
-    options() {
-        return maintenanceOptions(this.model());
-    }
-    readSettings() {
-        try {
-            this.settings = { pending: this.migrate.plan() };
-        }
-        catch (e) {
-            this.settings = { error: errMsg(e) };
-        }
-    }
-    updateStatus() {
         try {
-            return this.updateService.status();
+            this.logs = await readQuery(listLogs, this.ctx);
         }
-        catch (e) {
-            return { error: errMsg(e) };
-        }
-    }
-    /** The Updates category: look, install, go back, switch automatic updates. */
-    async updates(key) {
-        const service = this.updateService;
-        if (!service.managed)
-            return { notice: Theme.muted('Installed with npm: update it with ' + NPM_UPDATE_COMMAND + '.') };
-        if (key === 'a') {
-            const on = !service.status().autoUpdate;
-            this.busy(on ? 'Turning automatic updates on…' : 'Turning automatic updates off…');
-            service.setAuto(on);
-            return { notice: Theme.ok(Theme.glyph.ok + ' Automatic updates are ' + (on ? 'on.' : 'off.')) };
-        }
-        if (key === 'r') {
-            const target = service.status().state.previous;
-            if (!target)
-                return { notice: Theme.muted('There is no earlier version to go back to.') };
-            if (!(await this.app.ask('Go back to version ' + target + '?', ['Takes effect the next time you start it.'], 'Go back')))
-                return {};
-            return { notice: Theme.ok(Theme.glyph.ok + ' Went back to version ' + service.rollback() + '.') };
-        }
-        if (key === 'c') {
-            this.busy('Looking for a newer version…');
-            const found = await service.check();
-            this.latest = found.available && found.latest ? found.latest.version : null;
-            return {
-                notice: this.latest
-                    ? Theme.warn('Version ' + this.latest + ' is available.')
-                    : Theme.ok(Theme.glyph.ok + ' You have the newest version.'),
-            };
+        catch {
+            this.logs = NO_LOGS;
         }
-        if (key !== 'u')
-            return {};
-        this.busy('Installing the newest version…');
-        const done = describeResult(await service.run(), false);
-        this.latest = null;
-        return {
-            notice: done.code === 0 ? Theme.ok(Theme.glyph.ok + ' ' + done.line) : Theme.error(Theme.glyph.cross + ' ' + done.line),
-        };
-    }
-    async updateSettings() {
-        if (!('pending' in this.settings) || !this.settings.pending.length)
-            return { notice: Theme.muted('Your saved settings are up to date.') };
-        this.busy('Updating your saved settings…');
-        const notes = [];
-        const result = await this.migrate.run((line) => notes.push(line));
-        this.readSettings();
-        return {
-            notice: result.postponed.length
-                ? Theme.warn('Waiting until no sandbox runs: ' + result.postponed.join(', ') + '.')
-                : Theme.ok(Theme.glyph.ok + ' Saved settings updated.'),
-        };
-    }
-    async loadDoctor() {
-        this.busy('Checking this PC…');
+        this.last = (await readQuery(lastHealth, this.ctx)).last;
+        this.updates = await readQuery(updatesStatus, this.ctx);
         try {
-            this.doctorRows = this.health.doctor();
+            this.web = await readQuery(webStatus, this.ctx);
         }
-        catch (e) {
-            this.doctorRows = [['Doctor', errMsg(e)]];
+        catch {
+            // Not on this PC (a sandbox cannot start the web UI): the category shows it as not running.
+            this.web = NO_WEB;
         }
     }
-    loadSetup() {
-        this.busy('Looking at this PC…');
-        try {
-            this.health.assertWindows();
-            this.setupReport = this.health.setupReport();
-        }
-        catch (e) {
-            this.setupReport = { error: errMsg(e) };
-        }
-        return Promise.resolve();
+    options() {
+        return maintenanceOptions(this.model());
     }
     async act(result) {
         const id = result.kind === 'pick' || result.kind === 'action' ? result.value : undefined;
         const key = result.kind === 'action' ? result.key : undefined;
         try {
-            if (key === 'm' || id === 'data:measure')
-                return this.measure();
-            if (id === 'data:folder' && result.kind === 'pick') {
-                const exit = await new DataFolderFlow(this.app, this.ctx).run();
-                return exit ? { exit } : { reload: true };
+            // The open category's rows and keys only (a key of one category must not fire in another).
+            if (this.category === 'data') {
+                const stored = storageMenu(this.storage)?.resolve(result);
+                if (stored?.kind === 'action')
+                    return await this.dataAction(stored.action);
+                const chosen = dataMenuView(this.data)?.resolve(result);
+                if (chosen?.kind === 'action')
+                    return await this.dataAction(chosen.action);
             }
-            if (id === 'data:clean' && result.kind === 'pick') {
-                const argv = await new CommandForm(this.app, this.ctx, commandSpec('clean')).run();
-                return argv ? { exit: { kind: 'run', argv } } : {};
+            // The Engine category reads the engines on Enter on its row, or on l (check again) once they were read.
+            if (this.category === 'engine' && ((result.kind === 'pick' && id === 'engine:load') || key === 'l')) {
+                this.busy('Checking the engines…');
+                this.engine = await readQuery(engineStatus, this.ctx);
+                this.leftovers = await readQuery(engineLeftovers, this.ctx);
+                return {};
+            }
+            // Stopping the leftover HCS systems (x): the operation lists them and asks first, then they are looked up again.
+            if (this.category === 'engine') {
+                const chosen = engineMenu(this.model()).resolve(result);
+                if (chosen?.kind !== 'action')
+                    return {};
+                const done = await this.operations.perform(chosen.action, [this.label], (text) => this.busy(text));
+                this.leftovers = await readQuery(engineLeftovers, this.ctx);
+                return done;
             }
-            if (key === 'x')
-                return await this.remove(id);
-            if (key === 'f' && this.category === 'logs')
-                return { exit: { kind: 'run', argv: ['logs', '--follow'] } };
-            if (id?.startsWith('log:') && result.kind === 'pick') {
-                const file = this.logs.find((l) => l.name === id.slice(4));
-                return file ? { exit: { kind: 'view', file: file.path } } : {};
+            // The Web UI's keys (s, o, x) only in its category; the operation reports and the page reloads its facts.
+            if (this.category === 'web') {
+                const chosen = webMenu(this.model()).resolve(result);
+                if (chosen?.kind === 'action')
+                    return await this.operations.perform(chosen.action, [this.label], (text) => this.busy(text));
+                return {};
+            }
+            if (key === 'm' || id === 'data:measure')
+                return await this.measure();
+            // Only the open category's rows and keys: `f` and Enter mean something else in Health.
+            if (this.category === 'logs') {
+                const chosen = logsMenu(this.logs).resolve(result);
+                if (chosen?.kind === 'action')
+                    return this.showLog(chosen.action);
+            }
+            if (this.category === 'updates') {
+                const chosen = updatesMenu(this.model()).resolve(result);
+                if (chosen?.kind === 'action')
+                    return await this.runUpdates(chosen.action);
+                return {};
             }
-            if ((result.kind === 'pick' && id?.startsWith('settings:')) || (key === 's' && this.category === 'updates'))
-                return await this.updateSettings();
-            if (this.category === 'updates')
-                return await this.updates(key ?? this.updateKey(id));
+            // Only the open category's rows and keys: a key of one category must not fire in another.
             if (this.category === 'health') {
-                if (key === 'f' || id === 'repair:run')
-                    return this.repair();
-                if (key === 'l' || id === 'health:check') {
-                    await this.loadDoctor();
-                    await this.loadSetup();
-                    return {};
-                }
-                if (key === 'e')
-                    return await this.enable();
+                const chosen = healthMenu(this.model()).resolve(result);
+                if (chosen?.kind === 'action')
+                    return await this.operations.perform(chosen.action, [this.label], (text) => this.busy(text));
+                return {};
             }
             if (id?.startsWith('more:') && result.kind === 'pick') {
                 const spec = commandSpec(id.slice(5));
@@ -510,61 +338,52 @@ export class MaintenancePage extends ListPage {
         }
         return {};
     }
-    /** The key an Enter on an Updates row stands for. */
-    updateKey(id) {
-        if (id === 'updates:latest')
-            return this.latest ? 'u' : 'c';
-        if (id === 'updates:auto')
-            return 'a';
-        if (id === 'updates:previous')
-            return 'r';
-        return undefined;
-    }
-    measure() {
-        this.busy('Measuring what is stored… this can take a minute or more');
-        const report = this.dataService.report();
-        this.data = { entries: report.entries, disks: report.disks, total: report.totalBytes };
-        return { notice: Theme.ok(Theme.glyph.ok + ' Total stored: ' + humanBytes(report.totalBytes) + '.') };
-    }
-    async remove(id) {
-        const entry = id?.startsWith('entry:') ? this.data?.entries[Number(id.slice(6))] : undefined;
-        if (!entry || !this.data)
+    /**
+     * A Logs row or key: the crash report or the end of a log, on the normal screen (the menu's own view shows a log
+     * there). Only names from the listing are looked up, never a path of their own.
+     */
+    showLog(action) {
+        if (action.kind !== 'link')
             return {};
-        const target = cleanTargetOf(entry) ?? fail('"' + entry.name + '" is kept on this PC on purpose.', 'It is not deleted here.');
-        const plan = this.dataService.plan([target]);
-        if (!plan.present.length)
-            return { notice: Theme.muted(target + ' does not exist.') };
-        const ok = await this.app.ask('Delete ' + target + '?', [
-            humanBytes(plan.totalBytes) + ' in ' + entry.path + '.',
-            ...plan.present.flatMap((t) => (t.warning ? [t.target + ' ' + t.warning + '.'] : [])),
-            'This cannot be undone.',
-        ], 'Delete', true);
-        if (!ok)
+        const target = action.target;
+        if (target.kind === 'command')
+            return { exit: { kind: 'run', argv: [...target.argv] } };
+        if (target.kind !== 'view')
             return {};
-        const outcome = this.dataService.clean(plan);
-        if (outcome.failed.length)
-            return { notice: Theme.error(Theme.glyph.cross + ' Could not remove everything: ' + outcome.failed.join('; ')) };
-        const gone = this.data.entries.filter((e) => e !== entry);
-        this.data = { ...this.data, entries: gone, total: _.sumBy(gone, 'bytes') };
-        return { notice: Theme.ok(Theme.glyph.ok + ' Freed ' + humanBytes(outcome.freedBytes) + '.') };
+        const name = target.params?.name;
+        if (name === CRASH)
+            return { exit: { kind: 'run', argv: ['logs', '--crash'] } };
+        const file = this.logs.files.find((f) => f.name === name);
+        return file ? { exit: { kind: 'view', file: file.path } } : {};
     }
-    /** Repair shows what it does as it goes and asks before it changes anything, so it runs on the normal screen. */
-    repair() {
-        return { exit: { kind: 'run', argv: ['repair'] } };
+    /**
+     * An Updates row or key: runs its operation as the command line does (the operation asks what it must). A check and
+     * an install tell the page the newer version they found (or that none is left), the rest leave it alone.
+     */
+    runUpdates(action) {
+        const input = action.kind === 'operation' ? action.input : {};
+        const checks = input.check === true;
+        const installs = !checks && input.rollback === undefined && input.auto === undefined;
+        const remember = checks || installs
+            ? (output) => {
+                this.latest = output.latest;
+            }
+            : undefined;
+        return this.operations.perform(action, [this.label], (text) => this.busy(text), remember);
     }
-    async enable() {
-        const ok = await this.app.ask('Turn on Windows Sandbox?', ['Windows asks for admin permission, then you restart Windows to finish.'], 'Turn on');
-        if (!ok)
-            return {};
-        // The admin prompt and its output need the normal screen.
-        this.app.terminal.stop();
-        const worked = this.health.enableFeature();
-        this.app.terminal.start();
-        await this.loadSetup();
-        return {
-            notice: worked
-                ? Theme.ok(Theme.glyph.ok + ' Done. Restart Windows to finish.')
-                : Theme.error(Theme.glyph.cross + ' Windows Sandbox could not be turned on (or the admin prompt was declined).'),
-        };
+    async measure() {
+        this.busy('Measuring what is stored… this can take a minute or more');
+        this.data = await readQuery(showData, this.ctx);
+        return { notice: Theme.ok(Theme.glyph.ok + ' Total stored: ' + this.data.total + '.') };
+    }
+    /**
+     * Delete one stored folder, or clean up: the operation asks and reports as on the command line. After it ran, the
+     * sizes shown are out of date, so the list goes back to "Measure what is stored" (a declined question keeps it).
+     */
+    async dataAction(action) {
+        const outcome = await this.operations.perform(action, [this.label], (text) => this.busy(text));
+        if (outcome.reload)
+            this.data = null;
+        return outcome;
     }
 }