windows-development-sandbox 1.10.0 → 1.11.4

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

@@ -1,6 +1,7 @@
-import type { Context } from '../../commands/context.js';
-import { type App, type Category, type ListAction, type ListOptions, type ListResult } from '../../tui/index.js';
+import { type AgentsList } from '../../../app/features/agents/index.js';
 import type { ConfigFile } from '../../../app/features/settings/index.js';
+import type { Context } from '../../commands/context.js';
+import { type App, type Category, type ListOptions, type ListResult } from '../../tui/index.js';
 import type { Draft } from '../settings/draft.js';
 import { ListPage, type Outcome } from './list-page.js';
 export type WindowChoice = 'config' | 'hide' | 'show';
@@ -19,10 +20,8 @@ export interface AgentsModel {
     /** The agents you added yourself: only these can be removed (the built-in ones stay). */
     readonly removable?: readonly string[];
 }
-/** The agents of `harnesses` that are not built in. Pure. */
-export declare function addedAgents(names: readonly string[]): string[];
-/** The keys of the Start category: make an agent the default, remove one you added. Pure. */
-export declare function agentActions(m: Pick<AgentsModel, 'defaultAgent' | 'removable'>): ListAction<string>[];
+/** The agents page's data as the agents view takes it. Pure. */
+export declare function agentsList(m: AgentsModel): AgentsList;
 /**
  * The "not sandboxed" entries: only while agent commands are on (typing the agent then starts the sandbox, so a way to
  * run the real one is needed), one per agent found installed on this PC.
@@ -32,37 +31,37 @@ export declare function hostAgentsToShow(enabled: boolean, found: readonly {
 }[]): string[];
 /** The command line a start stands for. Pure. */
 export declare function startArgv(m: AgentsModel, agent: string, cwd: string): string[];
+/** Settings has unsaved changes to the agents (their list or the default): the agent operations wait for them. */
+export declare function agentsHaveStagedChanges(file: ConfigFile, draft: Draft): boolean;
 /** The categories of the agents section; "On this PC" only when there is something in it. Pure. */
 export declare function agentCategories(m: Pick<AgentsModel, 'folder' | 'hostAgents'>): Category[];
 /** The list for the agents section. Pure. */
 export declare function agentsOptions(m: AgentsModel, cwd?: string): ListOptions<string>;
 export declare class AgentsPage extends ListPage<string> {
     private readonly ctx;
-    /** Your own config file and its unsaved changes: where "Add an agent" writes to. */
+    /** Your own config file: the default agent's name for where the cursor starts. */
     private readonly file;
+    /** Unsaved changes in Settings: while there are some to the agents, the agent operations wait for them. */
     private readonly draft;
     readonly label = "Agents";
     private attach;
     private window;
     private folder;
     private model;
-    /** What load() looked up (programs on PATH, the history file): not asked again for every list that is built. */
+    private readonly operations;
+    /** What load() looked up: the agents view, programs on PATH, the history file. */
     private facts;
     constructor(app: App, ctx: Context, 
-    /** Your own config file and its unsaved changes: where "Add an agent" writes to. */
-    file: ConfigFile, draft: Draft);
-    /** Every agent: the configured ones, and any added in Settings that is not saved yet. */
-    private harnesses;
-    /** Is this agent already in the sandbox's persistent storage (so starting it needs no install)? */
-    private installed;
+    /** Your own config file: the default agent's name for where the cursor starts. */
+    file: ConfigFile, 
+    /** Unsaved changes in Settings: while there are some to the agents, the agent operations wait for them. */
+    draft: Draft);
     private current;
     /** The cursor starts on the default agent. */
     protected initialFocus(): string;
     protected load(): Promise<void>;
     protected options(): ListOptions<string>;
     protected act(result: ListResult<string>): Promise<Outcome<string>>;
-    /** Make default (d) and Remove (x) on the highlighted agent. */
-    private action;
-    /** "Add an agent…": the new agent shows in the list, with the cursor on it. */
-    private add;
+    /** Add, make default and remove run through the menu's dialogs, unless Settings has unsaved changes to the agents. */
+    private operate;
 }

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

@@ -1,39 +1,38 @@
 // Section 1: the agents. "Start" lists the agents you can start here (Enter starts one) after "Repeat last", and ends
-// with "Add an agent…" (the new one appears in the list); "Options" holds how a start goes (attach, window, folder) and
-// the other ways to start; "On this PC" has the not-sandboxed entries while agent commands are on.
+// with "Add an agent…" (the agents view's rows and keys: src/app/features/agents); "Options" holds how a start goes
+// (attach, window, folder) and the other ways to start; "On this PC" has the not-sandboxed entries while agent commands
+// are on.
 import fs from 'node:fs';
 import path from 'node:path';
-import { DEFAULTS } from '../../../core/config/index.js';
-import { errMsg } from '../../../core/util/index.js';
+import { agentsPage, listAgents } from '../../../app/features/agents/index.js';
+import { readQuery } from '../../../app/registry.js';
 import { commandLine, readHistory } from '../../history.js';
 import { AgentCommandsService } from '../../services/index.js';
 import { commandSpec } from '../../manifest.js';
 import { Text, Theme, } from '../../tui/index.js';
-import { AddAgent, makeDefaultAgent, removeAgent } from '../add-agent.js';
 import { CommandForm } from '../command-form.js';
+import { MenuOperations } from '../io-menu.js';
+import { menuView } from '../render-view.js';
 import { askPath } from '../settings/ask-path.js';
 import { SeveralAgents } from '../several.js';
 import { ListPage } from './list-page.js';
-/** The agents of `harnesses` that are not built in. Pure. */
-export function addedAgents(names) {
-    return names.filter((n) => !(n in DEFAULTS.harnesses));
-}
-const agentOf = (id) => (id.startsWith('agent:') ? id.slice(6) : undefined);
-/** The keys of the Start category: make an agent the default, remove one you added. Pure. */
-export function agentActions(m) {
-    const isOther = (id) => {
-        const name = agentOf(id);
-        return name !== undefined && name !== m.defaultAgent;
+/** The agents page's data as the agents view takes it. Pure. */
+export function agentsList(m) {
+    const removable = m.removable ?? [];
+    return {
+        folder: m.folder,
+        defaultAgent: m.defaultAgent,
+        agents: m.agents.map((a) => ({
+            name: a.name,
+            ready: a.ready,
+            isDefault: a.name === m.defaultAgent,
+            removable: removable.includes(a.name),
+        })),
     };
-    return [
-        { key: 'd', label: 'make default', importance: 1, applies: isOther },
-        {
-            key: 'x',
-            label: 'remove',
-            importance: 1,
-            applies: (id) => isOther(id) && (m.removable ?? []).includes(agentOf(id) ?? ''),
-        },
-    ];
+}
+/** The Start category: the agents view's rows and keys, as the menu draws them. Pure. */
+function startView(m) {
+    return menuView(agentsPage(agentsList(m)), { category: 'start', refresh: false });
 }
 /**
  * The "not sandboxed" entries: only while agent commands are on (typing the agent then starts the sandbox, so a way to
@@ -54,6 +53,10 @@ export function startArgv(m, agent, cwd) {
         ...(path.resolve(m.folder).toLowerCase() === path.resolve(cwd).toLowerCase() ? [] : ['--workspace', m.folder]),
     ];
 }
+/** Settings has unsaved changes to the agents (their list or the default): the agent operations wait for them. */
+export function agentsHaveStagedChanges(file, draft) {
+    return draft.has(file, ['harnesses']) || draft.has(file, ['defaultHarness']);
+}
 /** The categories of the agents section; "On this PC" only when there is something in it. Pure. */
 export function agentCategories(m) {
     return [
@@ -74,10 +77,20 @@ export function agentCategories(m) {
             : []),
     ];
 }
+/** A Start row of the view with the menu's own lines: the default's accent and the command a start runs. Pure. */
+function startRow(item, m, cwd) {
+    const name = item.value.startsWith('agent:') ? item.value.slice(6) : undefined;
+    if (name === undefined)
+        return item;
+    return {
+        ...item,
+        hint: (name === m.defaultAgent ? Theme.accent('default  ') : '') + (item.hint ?? ''),
+        details: [Theme.muted('Command  ') + commandLine(startArgv(m, name, cwd))],
+    };
+}
 /** The list for the agents section. Pure. */
 export function agentsOptions(m, cwd = process.cwd()) {
-    const section = 'Start in ' + path.basename(m.folder);
-    const agents = [...m.agents].sort((a, b) => Number(b.name === m.defaultAgent) - Number(a.name === m.defaultAgent));
+    const view = startView(m);
     return {
         path: [],
         categories: agentCategories(m),
@@ -94,33 +107,7 @@ export function agentsOptions(m, cwd = process.cwd()) {
                     },
                 ]
                 : []),
-            ...agents.map((a) => ({
-                value: 'agent:' + a.name,
-                label: a.name,
-                category: 'start',
-                section,
-                hint: (a.name === m.defaultAgent ? Theme.accent('default  ') : '') +
-                    (a.ready ? Theme.ok('ready') : Theme.muted('installs on first start')),
-                description: 'Starts ' +
-                    a.name +
-                    ' in ' +
-                    path.basename(m.folder) +
-                    '.' +
-                    (a.name === m.defaultAgent ? ' It is the default agent.' : '') +
-                    ((m.removable ?? []).includes(a.name) && a.name !== m.defaultAgent
-                        ? ' You added it: x removes it.'
-                        : (m.removable ?? []).includes(a.name)
-                            ? ' You added it. Make another agent the default to remove it.'
-                            : ''),
-                details: [Theme.muted('Command  ') + commandLine(startArgv(m, a.name, cwd))],
-            })),
-            {
-                value: 'add',
-                label: 'Add an agent…',
-                category: 'start',
-                section,
-                description: 'Add another agent by its npm or Python package, or a program on this PC. It is saved in your settings and appears in this list.',
-            },
+            ...view.items.map((item) => startRow(item, m, cwd)),
             {
                 value: 'opt:attach',
                 label: 'Attach this terminal',
@@ -175,7 +162,7 @@ export function agentsOptions(m, cwd = process.cwd()) {
             })),
         ],
         enterLabel: (_category, id) => ENTER[id ?? ''] ?? (id?.startsWith('agent:') ? 'start' : id?.startsWith('host:') ? 'run' : 'open'),
-        actions: (category) => (category === 'start' ? agentActions(m) : []),
+        actions: (category) => (category === 'start' ? view.actions : []),
     };
 }
 /** What Enter does on the rows that are not an agent. */
@@ -195,45 +182,33 @@ export class AgentsPage extends ListPage {
     window = 'config';
     folder = process.cwd();
     model;
-    /** What load() looked up (programs on PATH, the history file): not asked again for every list that is built. */
+    operations;
+    /** What load() looked up: the agents view, programs on PATH, the history file. */
     facts;
     constructor(app, ctx, 
-    /** Your own config file and its unsaved changes: where "Add an agent" writes to. */
-    file, draft) {
+    /** Your own config file: the default agent's name for where the cursor starts. */
+    file, 
+    /** Unsaved changes in Settings: while there are some to the agents, the agent operations wait for them. */
+    draft) {
         super(app);
         this.ctx = ctx;
         this.file = file;
         this.draft = draft;
-    }
-    /** Every agent: the configured ones, and any added in Settings that is not saved yet. */
-    harnesses() {
-        const config = this.file.userConfig();
-        const staged = this.draft.has(this.file, ['harnesses'])
-            ? this.draft.value(this.file, ['harnesses'])
-            : undefined;
-        return { ...config.harnesses, ...staged };
-    }
-    /** Is this agent already in the sandbox's persistent storage (so starting it needs no install)? */
-    installed(name, harnesses) {
-        const h = harnesses[name];
-        const dir = path.join(this.ctx.dataPath, 'tools', 'agents', name);
-        return (Boolean(h) &&
-            [h.hostExecutable, h.npmBin && h.npmBin + '.cmd', h.uvBin && h.uvBin + '.exe'].some((f) => f && fs.existsSync(path.join(dir, f))));
+        this.operations = new MenuOperations(app, ctx);
     }
     current() {
-        const harnesses = this.harnesses();
         if (!this.facts)
             throw new Error('The agents tab was not loaded');
-        const { commands, last } = this.facts;
+        const { agents, commands, last } = this.facts;
         return {
             folder: this.folder,
-            defaultAgent: this.file.userConfig().defaultHarness,
-            agents: Object.keys(harnesses).map((name) => ({ name, ready: this.installed(name, harnesses) })),
+            defaultAgent: agents.defaultAgent,
+            agents: agents.agents.map((a) => ({ name: a.name, ready: a.ready })),
             last,
             attach: this.attach,
             window: this.window,
             hostAgents: hostAgentsToShow(commands.enabled, commands.found),
-            removable: addedAgents(Object.keys(harnesses)),
+            removable: agents.agents.filter((a) => a.removable).map((a) => a.name),
         };
     }
     /** The cursor starts on the default agent. */
@@ -242,6 +217,7 @@ export class AgentsPage extends ListPage {
     }
     async load() {
         this.facts = {
+            agents: await readQuery(listAgents, this.ctx),
             commands: await new AgentCommandsService(this.ctx).statusAsync(),
             last: readHistory()[0]?.argv,
         };
@@ -252,21 +228,23 @@ export class AgentsPage extends ListPage {
         return agentsOptions(this.model);
     }
     async act(result) {
-        if (result.kind === 'action')
-            return this.action(result.key, result.value);
+        const model = this.current();
+        const chosen = startView(model).resolve(result);
+        if (chosen?.kind === 'action') {
+            const { action } = chosen;
+            // A start keeps the options of this page (attach, window, folder), which the plain link does not know.
+            if (action.kind === 'link' && action.target.kind === 'start-agent')
+                return { exit: { kind: 'run', argv: startArgv(model, action.target.agent, process.cwd()) } };
+            return this.operate(action);
+        }
         if (result.kind !== 'pick')
             return {};
         const id = result.value;
-        const model = this.current();
         if (id.startsWith('host:'))
             return { exit: { kind: 'run', argv: ['host', id.slice(5)] } };
-        if (id.startsWith('agent:'))
-            return { exit: { kind: 'run', argv: startArgv(model, id.slice(6), process.cwd()) } };
         switch (id) {
             case 'repeat':
                 return model.last ? { exit: { kind: 'run', argv: model.last } } : {};
-            case 'add':
-                return this.add(model);
             case 'opt:attach':
                 this.attach = !this.attach;
                 return {};
@@ -301,45 +279,10 @@ export class AgentsPage extends ListPage {
                 return {};
         }
     }
-    /** Make default (d) and Remove (x) on the highlighted agent. */
-    async action(key, id) {
-        const name = id?.startsWith('agent:') ? id.slice(6) : undefined;
-        if (!name)
-            return {};
-        try {
-            if (key === 'd') {
-                makeDefaultAgent(this.file, this.draft, name);
-                return { focus: id, notice: Theme.ok(Theme.glyph.ok + ' ' + name + ' is the default agent.') };
-            }
-            if (key !== 'x')
-                return {};
-            const ok = await this.app.ask('Remove ' + name + '?', ['It is taken out of your settings. Its files in the sandbox stay until you clean them up.'], 'Remove', true);
-            if (!ok)
-                return {};
-            removeAgent(this.file, this.draft, name);
-            return {
-                focus: 'agent:' + this.file.userConfig().defaultHarness,
-                notice: Theme.ok(Theme.glyph.ok + ' Removed ' + name + '.'),
-            };
-        }
-        catch (e) {
-            return { notice: Theme.error(Theme.glyph.cross + ' ' + errMsg(e)) };
-        }
-    }
-    /** "Add an agent…": the new agent shows in the list, with the cursor on it. */
-    async add(model) {
-        try {
-            const added = await new AddAgent(this.app, this.file, this.draft, model.agents.map((a) => a.name)).run();
-            if (!added)
-                return {};
-            return {
-                focus: 'agent:' + added.name,
-                notice: Theme.ok(Theme.glyph.ok + ' Added ' + added.name + '.') +
-                    Theme.muted(added.saved ? ' Enter starts it.' : ' Ctrl+S saves it.'),
-            };
-        }
-        catch (e) {
-            return { notice: Theme.error(Theme.glyph.cross + ' ' + errMsg(e)) };
-        }
+    /** Add, make default and remove run through the menu's dialogs, unless Settings has unsaved changes to the agents. */
+    async operate(action) {
+        if (agentsHaveStagedChanges(this.file, this.draft))
+            return { notice: Theme.warn('Agents have unsaved changes in Settings: save them (Ctrl+S) or undo them first.') };
+        return this.operations.perform(action, [this.label], (text) => this.busy(text));
     }
 }

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

@@ -1,28 +1,35 @@
-import { type App, type ListOptions, type ListResult } from '../../tui/index.js';
-import { AppsModel } from '../apps.js';
+import { type AppsSource } from '../../../app/features/apps/index.js';
 import type { ConfigFile } from '../../../app/features/settings/index.js';
+import { type App, type Category, type ListItem, type ListOptions, type ListResult } from '../../tui/index.js';
+import type { Context } from '../../commands/context.js';
 import type { Draft } from '../settings/draft.js';
 import { type Scope } from './scopes.js';
 import { ListPage, type Outcome } from './list-page.js';
 import type { ShellExit } from '../shell.js';
 import type { Step } from '../../tui/index.js';
+/** The apps as the menu shows them: the saved files with this page's staged ticks laid over them. */
+export declare function draftSource(draft: Draft): AppsSource;
+/** The menu's groups: the feature's groups, and in your own scope "Your own programs". */
+export declare function appsCategories(file: ConfigFile): Category[];
+/** The menu's rows for a scope, with the staged ticks. */
+export declare function appsItems(file: ConfigFile, dataPath: string, draft: Draft): ListItem<string>[];
 /** The list for the apps tab. Pure. */
-export declare function appsOptions(model: AppsModel, file: ConfigFile, draft: Draft, scope: Scope): ListOptions<string>;
+export declare function appsOptions(file: ConfigFile, dataPath: string, draft: Draft, scope: Scope): ListOptions<string>;
+/** Stages the ticks of the list: only what differs from the saved file is kept in the draft. */
+export declare function stageTicks(file: ConfigFile, draft: Draft, ticked: readonly string[]): void;
 export declare class AppsPage extends ListPage<string> {
+    private readonly ctx;
     private readonly files;
     private readonly draft;
-    private readonly dataPath;
     readonly label = "Apps";
     readonly stages = true;
     private scope;
-    constructor(app: App, files: Record<Scope, ConfigFile>, draft: Draft, dataPath: string);
+    private readonly operations;
+    constructor(app: App, ctx: Context, files: Record<Scope, ConfigFile>, draft: Draft);
     private get file();
-    private get model();
     protected load(): Promise<void>;
     protected options(): ListOptions<string>;
     /** Every tick is staged as it happens, so leaving or saving always sees it. */
     protected afterKey(): Step<ShellExit>;
-    /** Opens the GitHub request form in the browser and says where it is. */
-    private request;
     protected act(result: ListResult<string>): Promise<Outcome<string>>;
 }

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

@@ -1,14 +1,100 @@
 // Section 4: the apps catalogue. Groups on the left, space ticks, and the ticks are staged until Ctrl+S saves them. Two
-// scopes like Settings: apps for every project, or for this project only.
+// scopes like Settings: apps for every project, or for this project only. The rows come from the apps feature
+// (features/apps/apps-rows.ts); the menu only lays its staged ticks over them. The web and the feature write at once
+// (apps.toggle), so the staging stays here: "r" runs the feature's request operation, "c" stages your own programs.
+import _ from 'lodash';
 import { errMsg } from '../../../core/util/index.js';
+import { APP_GROUPS, appIsOn, appRows, customRows, CUSTOM_KEY, entriesOf, INSTALL, ISSUES_URL, requestApp, REQUEST_APP, SAVED, } from '../../../app/features/apps/index.js';
+import { action } from '../../../app/kernel/index.js';
 import { Theme } from '../../tui/index.js';
-import { openIssuePage } from '../../../host/web/index.js';
-import { AppsModel, requestAppUrl } from '../apps.js';
 import { ValueEditor } from '../settings/value-editor.js';
+import { MenuOperations } from '../io-menu.js';
 import { SCOPES, scopeStatus } from './scopes.js';
 import { ListPage } from './list-page.js';
+/** The apps as the menu shows them: the saved files with this page's staged ticks laid over them. */
+export function draftSource(draft) {
+    return {
+        install: (file) => draft.has(file, INSTALL) ? draft.value(file, INSTALL) : SAVED.install(file),
+        setting: (file, key) => (draft.has(file, key) ? draft.value(file, key) : SAVED.setting(file, key)),
+        custom: (file) => draft.has(file, CUSTOM_KEY)
+            ? draft.value(file, CUSTOM_KEY)
+            : SAVED.custom(file),
+    };
+}
+/** The menu's groups: the feature's groups, and in your own scope "Your own programs". */
+export function appsCategories(file) {
+    return [
+        ...APP_GROUPS.map(({ id, label, description }) => ({ id, label, description })),
+        ...(file.isProject
+            ? []
+            : [
+                {
+                    id: 'custom',
+                    label: 'Your own programs',
+                    description: 'Programs you added yourself (c to add or change them).',
+                },
+            ]),
+    ];
+}
+function appItem(row) {
+    const notes = [
+        Theme.muted('Download  ') +
+            '~' +
+            row.size +
+            ' once, kept in C:\\AgentData\\tools\\' +
+            (row.setting ? '' : 'apps\\') +
+            row.id,
+        Theme.muted('Starts    ') + (row.cli ? 'from a terminal (on PATH)' : 'from the desktop or Start > Sandbox apps'),
+        ...(row.mesa ? [Theme.muted('Graphics  ') + 'OpenGL on the CPU (Mesa) is added for it'] : []),
+        ...(row.fullGitOnly
+            ? [Theme.warn('Needs full git access (Settings > Projects & setup > Git): it pushes with its own git.')]
+            : []),
+        ...(row.setting ? [Theme.muted('Setting   ') + row.setting] : []),
+    ];
+    return {
+        value: row.id,
+        label: row.name,
+        category: row.group,
+        description: row.about,
+        details: notes,
+        keywords: row.id,
+        hint: (row.installed ? Theme.ok('installed ') : '') + Theme.muted(row.size),
+        checked: row.on,
+    };
+}
+function customItem(row) {
+    return {
+        value: '@custom:' + row.id,
+        label: row.name,
+        category: 'custom',
+        description: row.from,
+        hint: Theme.muted(row.cli ? 'command line' : 'desktop'),
+        checked: true,
+        disabled: 'Your own programs are always installed; c to change or remove them.',
+    };
+}
+/** The menu's rows for a scope, with the staged ticks. */
+export function appsItems(file, dataPath, draft) {
+    const source = draftSource(draft);
+    return [
+        ...appRows(file, dataPath, source).map(appItem),
+        ...(file.isProject
+            ? []
+            : [
+                {
+                    value: REQUEST_APP,
+                    label: 'Request an app…',
+                    category: 'custom',
+                    description: 'Not in the list? Press r: your browser opens a prefilled request on GitHub (' + ISSUES_URL + ').',
+                    hint: Theme.muted('press r'),
+                    disabled: 'Press r to open the request form on GitHub.',
+                },
+            ]),
+        ...customRows(file, source).map(customItem),
+    ];
+}
 /** The list for the apps tab. Pure. */
-export function appsOptions(model, file, draft, scope) {
+export function appsOptions(file, dataPath, draft, scope) {
     return {
         path: [],
         status: scopeStatus(file),
@@ -16,72 +102,78 @@ export function appsOptions(model, file, draft, scope) {
         tabs: { items: SCOPES.map((s) => s.tab), active: SCOPES.findIndex((s) => s.scope === scope) },
         multi: true,
         enterTicks: true,
-        categories: model.categories(),
-        items: model.items(draft),
+        categories: appsCategories(file),
+        items: appsItems(file, dataPath, draft),
         actions: [
             ...(file.isProject ? [] : [{ key: 'c', label: 'your own programs' }]),
             { key: 'r', label: 'request an app' },
         ],
     };
 }
+/** Stages the ticks of the list: only what differs from the saved file is kept in the draft. */
+export function stageTicks(file, draft, ticked) {
+    const entries = entriesOf(file);
+    for (const entry of entries.filter((a) => a.setting)) {
+        const key = entry.setting.split('.');
+        const on = ticked.includes(entry.id);
+        if (on === appIsOn(entry, file, SAVED))
+            draft.unstage(file, key);
+        else
+            draft.stage(file, key, on);
+    }
+    const wanted = entries.filter((a) => !a.setting && ticked.includes(a.id)).map((a) => a.id);
+    const savedInstall = SAVED.install(file) ?? [];
+    if (_.isEqual([...wanted].sort(), [...savedInstall].sort()))
+        draft.unstage(file, INSTALL);
+    else
+        draft.stage(file, INSTALL, wanted.length || file.isProject ? wanted : undefined);
+}
 export class AppsPage extends ListPage {
+    ctx;
     files;
     draft;
-    dataPath;
     label = 'Apps';
     stages = true;
     scope = 'user';
-    constructor(app, files, draft, dataPath) {
+    operations;
+    constructor(app, ctx, files, draft) {
         super(app);
+        this.ctx = ctx;
         this.files = files;
         this.draft = draft;
-        this.dataPath = dataPath;
+        this.operations = new MenuOperations(app, ctx);
     }
     get file() {
         return this.files[this.scope];
     }
-    get model() {
-        return new AppsModel(this.file, this.dataPath);
-    }
     load() {
         return Promise.resolve();
     }
     options() {
-        return appsOptions(this.model, this.file, this.draft, this.scope);
+        return appsOptions(this.file, this.ctx.dataPath, this.draft, this.scope);
     }
     /** Every tick is staged as it happens, so leaving or saving always sees it. */
     afterKey() {
-        this.model.stageTicks(this.draft, this.ticked());
+        stageTicks(this.file, this.draft, this.ticked());
         return;
     }
-    /** Opens the GitHub request form in the browser and says where it is. */
-    request() {
-        const url = requestAppUrl();
-        try {
-            openIssuePage(url);
-            return Theme.ok(Theme.glyph.ok + ' Opened the request form in your browser: ') + Theme.muted(url);
-        }
-        catch (e) {
-            return Theme.error(Theme.glyph.cross + ' ' + errMsg(e)) + Theme.muted('  Open it yourself: ' + url);
-        }
-    }
     async act(result) {
-        this.model.stageTicks(this.draft, this.ticked());
+        stageTicks(this.file, this.draft, this.ticked());
         if (result.kind === 'tab') {
             this.scope = SCOPES[result.index].scope;
             return {};
         }
         if (result.kind === 'action' && result.key === 'r')
-            return { notice: this.request() };
+            return this.operations.perform(action(requestApp, {}), [this.label]);
         if (result.kind !== 'action' || result.key !== 'c')
             return {};
         const node = this.file.schema.child('apps')?.child('custom');
         if (!node)
             return {};
         try {
-            const edited = await new ValueEditor(this.app).edit(['Apps', 'Your own programs'], ['apps', 'custom'], node, this.model.custom(this.draft));
+            const edited = await new ValueEditor(this.app).edit(['Apps', 'Your own programs'], CUSTOM_KEY, node, draftSource(this.draft).custom(this.file));
             if (edited)
-                this.draft.stage(this.file, ['apps', 'custom'], edited.value);
+                this.draft.stage(this.file, CUSTOM_KEY, edited.value);
         }
         catch (e) {
             return { notice: Theme.error(Theme.glyph.cross + ' ' + errMsg(e)) };

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

@@ -178,7 +178,16 @@ export class ListPage {
         if (!step)
             return this.afterKey();
         const result = step.done;
-        const outcome = result.kind === 'back' ? { exit: { kind: 'quit' } } : await this.act(result);
+        let outcome;
+        try {
+            outcome = result.kind === 'back' ? { exit: { kind: 'quit' } } : await this.act(result);
+        }
+        catch (e) {
+            // Whatever an action does wrong, the menu stays: the problem is shown where the action was chosen.
+            if (e instanceof Error && (e.name === 'ExitRequested' || e.name === 'ExitPromptError'))
+                throw e;
+            outcome = { notice: Theme.error(Theme.glyph.cross + ' ' + errMsg(e)) };
+        }
         if (outcome.exit)
             return { done: outcome.exit };
         // What the action changed (a stop, a restart) is known to the menu before the page loads again. An action that