windows-development-sandbox 1.5.0 → 1.7.0

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

@@ -1,10 +1,14 @@
-// Tab 6: saved logins for every agent. Agents on the left (each with its logins), actions on the right: save the
+// Section 6: saved logins for every agent. Agents on the left (each with its logins), actions on the right: save the
 // sandbox's login or this PC's, use one, make one the default, rename, remove.
 import { errMsg, safeText } from '../../../core/util/index.js';
 import { AccountsService } from '../../services/index.js';
 import { Theme } from '../../tui/index.js';
 import { ListPage } from './list-page.js';
 const NAME = /^[A-Za-z0-9_-]{1,40}$/;
+const SAVE_SANDBOX = '@save-sandbox';
+const SAVE_PC = '@save-pc';
+/** A saved login (not a "save a login" row or a note). */
+const isLogin = (id) => !id.startsWith('@') && !id.startsWith('info:');
 /** The list for the accounts tab. Pure. */
 export function accountsOptions(m) {
     return {
@@ -19,6 +23,26 @@ export function accountsOptions(m) {
         })),
         items: m.agents.flatMap((a) => {
             const rows = m.rows[a.name] ?? [];
+            const save = [
+                {
+                    value: SAVE_SANDBOX,
+                    label: "+ Save the sandbox's login…",
+                    category: a.name,
+                    section: 'Save a login',
+                    description: 'Saves the ' + a.name + ' login you signed in with inside the sandbox, under a name you choose.',
+                },
+                ...(a.canSavePc
+                    ? [
+                        {
+                            value: SAVE_PC,
+                            label: "+ Save this PC's login…",
+                            category: a.name,
+                            section: 'Save a login',
+                            description: 'Saves the ' + a.name + ' login of this PC, under a name you choose.',
+                        },
+                    ]
+                    : []),
+            ];
             if (!a.kept)
                 return [
                     {
@@ -28,25 +52,28 @@ export function accountsOptions(m) {
                         description: 'Sign in again in each new sandbox, or use an API key in the agent’s environment.',
                     },
                 ];
-            return rows.map((r) => ({
-                value: a.name + ':' + r.name,
-                label: r.name,
-                category: a.name,
-                hint: (r.isActive ? Theme.ok('in the sandbox') : '') +
-                    (r.isActive && r.isDefault ? Theme.muted(' · ') : '') +
-                    (r.isDefault ? Theme.accent('default') : ''),
-                description: 'Enter makes the sandbox use this login.',
-                details: [
-                    Theme.muted('Agent  ') + a.name,
-                    Theme.muted('Email  ') + safeText(r.email ?? '-'),
-                    Theme.muted('Saved  ') + r.savedAt.slice(0, 16).replace('T', ' '),
-                ],
-            }));
+            return [
+                ...save,
+                ...rows.map((r) => ({
+                    value: a.name + ':' + r.name,
+                    label: r.name,
+                    category: a.name,
+                    section: 'Saved logins',
+                    hint: (r.isActive ? Theme.ok('in the sandbox') : '') +
+                        (r.isActive && r.isDefault ? Theme.muted(' · ') : '') +
+                        (r.isDefault ? Theme.accent('default') : ''),
+                    description: 'Enter makes the sandbox use this login.',
+                    details: [
+                        Theme.muted('Agent  ') + a.name,
+                        Theme.muted('Email  ') + safeText(r.email ?? '-'),
+                        Theme.muted('Saved  ') + r.savedAt.slice(0, 16).replace('T', ' '),
+                    ],
+                })),
+            ];
         }),
-        empty: "No saved logins. Sign in inside the sandbox, then press s to save that login (p saves this PC's).",
+        empty: 'No agents.',
         actions: accountActions(m.agents),
-        enterLabel: 'use',
-        escapeLabel: 'quit',
+        enterLabel: (_category, id) => (id === SAVE_SANDBOX || id === SAVE_PC ? 'save' : id && isLogin(id) ? 'use' : ''),
     };
 }
 function accountActions(agents) {
@@ -55,11 +82,11 @@ function accountActions(agents) {
         if (!agent?.kept)
             return [];
         return [
-            { key: 's', label: 'save sandbox', importance: 1 },
-            ...(agent.canSavePc ? [{ key: 'p', label: 'save PC', importance: 1 }] : []),
-            { key: 'd', label: 'default', importance: 1 },
-            { key: 'r', label: 'rename', importance: 2 },
-            { key: 'x', label: 'remove', importance: 1 },
+            { key: 's', label: 'save sandbox login', importance: 3 },
+            ...(agent.canSavePc ? [{ key: 'p', label: 'save PC login', importance: 3 }] : []),
+            { key: 'd', label: 'make default', importance: 1, applies: isLogin },
+            { key: 'r', label: 'rename', importance: 2, applies: isLogin },
+            { key: 'x', label: 'remove', importance: 1, applies: isLogin },
         ];
     };
 }
@@ -94,7 +121,7 @@ export class AccountsPage extends ListPage {
     }
     static nameOf(value) {
         const i = value?.indexOf(':') ?? -1;
-        return value && i >= 0 && !value.startsWith('info:') ? value.slice(i + 1) : undefined;
+        return value && i >= 0 && isLogin(value) ? value.slice(i + 1) : undefined;
     }
     async act(result) {
         const agent = this.agentNow();
@@ -102,6 +129,8 @@ export class AccountsPage extends ListPage {
         try {
             if (result.kind === 'action' && (result.key === 's' || result.key === 'p'))
                 return await this.save(agent, result.key === 'p');
+            if (result.kind === 'pick' && (result.value === SAVE_SANDBOX || result.value === SAVE_PC))
+                return await this.save(agent, result.value === SAVE_PC);
             if (result.kind === 'pick' && name)
                 return await this.use(agent, name);
             if (result.kind === 'action' && name) {
@@ -154,6 +183,8 @@ export class AccountsPage extends ListPage {
     async use(agent, name) {
         const account = this.service.activate(name, agent);
         let note = Theme.ok(Theme.glyph.ok + ' The sandbox now uses "' + account.name + '" for ' + agent + '.');
+        if (account.note)
+            note += ' ' + safeText(account.note);
         if (this.service.hasRunningSessions(agent) &&
             (await this.app.ask('Restart the running ' + agent + ' sessions?', ['They restart and continue their conversation where the agent can, now under the new login.'], 'Restart')))
             note += ' ' + safeText(await this.service.restart(agent));

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

@@ -0,0 +1,66 @@
+import type { Context } from '../../commands/context.js';
+import { type App, type Category, type ListAction, type ListOptions, type ListResult } from '../../tui/index.js';
+import type { ConfigFile } from '../settings/config-file.js';
+import type { Draft } from '../settings/draft.js';
+import { ListPage, type Outcome } from './list-page.js';
+export type WindowChoice = 'config' | 'hide' | 'show';
+export interface AgentsModel {
+    readonly folder: string;
+    readonly defaultAgent: string;
+    readonly agents: readonly {
+        readonly name: string;
+        readonly ready: boolean;
+    }[];
+    readonly last: string[] | undefined;
+    readonly attach: boolean;
+    readonly window: WindowChoice;
+    /** Agents that can be run on this PC without the sandbox (see hostAgentsToShow). */
+    readonly hostAgents: readonly string[];
+    /** 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 "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.
+ */
+export declare function hostAgentsToShow(enabled: boolean, found: readonly {
+    harness: string;
+}[]): string[];
+/** The command line a start stands for. Pure. */
+export declare function startArgv(m: AgentsModel, agent: string, cwd: string): string[];
+/** 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. */
+    private readonly file;
+    private readonly draft;
+    readonly label = "Agents";
+    private attach;
+    private window;
+    private folder;
+    private model;
+    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;
+    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;
+}

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

@@ -0,0 +1,338 @@
+// 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.
+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 { 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 { askPath } from '../settings/path-kind.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;
+    };
+    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 "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.
+ */
+export function hostAgentsToShow(enabled, found) {
+    return enabled ? found.map((a) => a.harness) : [];
+}
+const WINDOW_TEXT = { config: 'as configured', hide: 'hidden', show: 'shown' };
+/** The command line a start stands for. Pure. */
+export function startArgv(m, agent, cwd) {
+    return [
+        'launch',
+        '--harness',
+        agent,
+        ...(m.attach ? ['--terminal'] : []),
+        ...(m.window === 'hide' ? ['--headless'] : m.window === 'show' ? ['--window'] : []),
+        ...(path.resolve(m.folder).toLowerCase() === path.resolve(cwd).toLowerCase() ? [] : ['--workspace', m.folder]),
+    ];
+}
+/** The categories of the agents section; "On this PC" only when there is something in it. Pure. */
+export function agentCategories(m) {
+    return [
+        {
+            id: 'start',
+            label: 'Start',
+            description: 'Agents you can start in ' + m.folder + '. Add an agent at the end of the list.',
+        },
+        { id: 'options', label: 'Options', description: 'How a start goes, and the other ways to start.' },
+        ...(m.hostAgents.length
+            ? [
+                {
+                    id: 'host',
+                    label: 'On this PC',
+                    description: 'The real agents on this PC, with no sandbox around them.',
+                },
+            ]
+            : []),
+    ];
+}
+/** 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));
+    return {
+        path: [],
+        categories: agentCategories(m),
+        items: [
+            ...(m.last
+                ? [
+                    {
+                        value: 'repeat',
+                        label: 'Repeat last',
+                        category: 'start',
+                        section: 'Quick start',
+                        hint: Theme.muted(Text.truncate(commandLine(m.last), 50)),
+                        description: 'Runs the last command again.',
+                    },
+                ]
+                : []),
+            ...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.',
+            },
+            {
+                value: 'opt:attach',
+                label: 'Attach this terminal',
+                category: 'options',
+                section: 'This start',
+                hint: m.attach ? Theme.ok('yes') : Theme.muted('no'),
+                flip: true,
+                description: 'Shows the agent in this terminal (Ctrl+] detaches). Without it the agent runs in the sandbox.',
+            },
+            {
+                value: 'opt:window',
+                label: 'Sandbox window',
+                category: 'options',
+                section: 'This start',
+                hint: WINDOW_TEXT[m.window],
+                description: 'Hide or show the Windows Sandbox window (sbx-show brings a hidden one back).',
+            },
+            {
+                value: 'opt:folder',
+                label: 'Folder',
+                category: 'options',
+                section: 'This start',
+                hint: Text.middle(m.folder, 40),
+                description: 'The project folder to work on.',
+            },
+            {
+                value: 'more',
+                label: 'More start options…',
+                category: 'options',
+                section: 'Start differently',
+                description: 'Node and Python versions, databases, scripts and the rest of the start form.',
+            },
+            {
+                value: 'several',
+                label: 'Start several agents…',
+                category: 'options',
+                section: 'Start differently',
+                description: 'One or more projects, one or more agents each, all in one sandbox.',
+            },
+            {
+                value: 'noagent',
+                label: 'Sandbox without an agent…',
+                category: 'options',
+                section: 'Start differently',
+                description: 'Tools and databases only.',
+            },
+            ...m.hostAgents.map((agent) => ({
+                value: 'host:' + agent,
+                label: agent + ' (not sandboxed)',
+                category: 'host',
+                description: 'Runs the real ' + agent + ' on this PC, with no sandbox around it.',
+            })),
+        ],
+        enterLabel: (_category, id) => ENTER[id ?? ''] ?? (id?.startsWith('agent:') ? 'start' : id?.startsWith('host:') ? 'run' : 'open'),
+        actions: (category) => (category === 'start' ? agentActions(m) : []),
+    };
+}
+/** What Enter does on the rows that are not an agent. */
+const ENTER = {
+    repeat: 'run again',
+    add: 'add',
+    'opt:attach': 'switch',
+    'opt:window': 'change',
+    'opt:folder': 'choose',
+};
+export class AgentsPage extends ListPage {
+    ctx;
+    file;
+    draft;
+    label = 'Agents';
+    attach = false;
+    window = 'config';
+    folder = process.cwd();
+    model;
+    constructor(app, ctx, 
+    /** Your own config file and its unsaved changes: where "Add an agent" writes to. */
+    file, 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))));
+    }
+    current() {
+        const harnesses = this.harnesses();
+        const commands = new AgentCommandsService(this.ctx).status();
+        return {
+            folder: this.folder,
+            defaultAgent: this.file.userConfig().defaultHarness,
+            agents: Object.keys(harnesses).map((name) => ({ name, ready: this.installed(name, harnesses) })),
+            last: readHistory()[0]?.argv,
+            attach: this.attach,
+            window: this.window,
+            hostAgents: hostAgentsToShow(commands.enabled, commands.found),
+            removable: addedAgents(Object.keys(harnesses)),
+        };
+    }
+    /** The cursor starts on the default agent. */
+    initialFocus() {
+        return 'agent:' + this.file.userConfig().defaultHarness;
+    }
+    load() {
+        this.model = this.current();
+        return Promise.resolve();
+    }
+    options() {
+        this.model = this.current();
+        return agentsOptions(this.model);
+    }
+    async act(result) {
+        if (result.kind === 'action')
+            return this.action(result.key, result.value);
+        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 {};
+            case 'opt:window':
+                this.window = this.window === 'config' ? 'hide' : this.window === 'hide' ? 'show' : 'config';
+                return {};
+            case 'opt:folder': {
+                const picked = await askPath(this.app, {
+                    path: ['Agents', 'Folder'],
+                    title: 'Choose the project folder',
+                    kind: 'dir',
+                    initial: this.folder,
+                    validate: (v) => (fs.existsSync(path.resolve(v)) ? true : 'That folder does not exist.'),
+                });
+                if (picked)
+                    this.folder = path.resolve(picked);
+                return {};
+            }
+            case 'more': {
+                const argv = await new CommandForm(this.app, this.ctx, commandSpec('launch'), startArgv(model, model.defaultAgent, process.cwd()).slice(1)).run();
+                return argv ? { exit: { kind: 'run', argv } } : {};
+            }
+            case 'several': {
+                const argv = await new SeveralAgents(this.app, this.ctx).run();
+                return argv ? { exit: { kind: 'run', argv } } : {};
+            }
+            case 'noagent': {
+                const argv = await new CommandForm(this.app, this.ctx, commandSpec('start')).run();
+                return argv ? { exit: { kind: 'run', argv } } : {};
+            }
+            default:
+                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)) };
+        }
+    }
+}

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

@@ -1,4 +1,4 @@
-// Tab 4: the apps catalogue. Groups on the left, space ticks, and the ticks are staged until Ctrl+S saves them. Two
+// 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.
 import { errMsg } from '../../../core/util/index.js';
 import { Theme } from '../../tui/index.js';
@@ -18,7 +18,6 @@ export function appsOptions(model, file, draft, scope) {
         categories: model.categories(),
         items: model.items(draft),
         actions: file.isProject ? [] : [{ key: 'c', label: 'your own programs' }],
-        escapeLabel: 'quit',
     };
 }
 export class AppsPage extends ListPage {

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

@@ -1,4 +1,4 @@
-import { type App, type FrameParts, type Key, type ListOptions, type ListResult } from '../../tui/index.js';
+import { type App, type Category, type FrameParts, type Key, type ListOptions, type ListResult } from '../../tui/index.js';
 import type { Size, Step } from '../../tui/index.js';
 import type { Page, ShellExit } from '../shell.js';
 /** What an action did: leave the shell, and/or what the rebuilt list shows. */
@@ -16,16 +16,29 @@ export declare abstract class ListPage<T> implements Page {
     readonly stages: boolean;
     private list;
     private notice;
+    /** The list has the keyboard (the menu's navigation does not). */
+    private focused;
+    /** The entry that was last acted on: the cursor returns to it when the section opens again. */
+    private lastFocus;
     constructor(app: App);
     /** Loads the data the list shows (called when the tab opens and after actions that change it). */
     protected abstract load(): Promise<void>;
     /** The list for the data loaded (pure: no I/O). */
     protected abstract options(): ListOptions<T>;
+    /** The entry the cursor starts on the first time the section opens (default: the first). */
+    protected initialFocus(): T | undefined;
     /** Does what the list returned. */
     protected abstract act(result: ListResult<T>): Promise<Outcome<T>>;
     get capturing(): boolean;
-    /** The id of the open sidebar category, if the list has one. */
-    protected get category(): string | undefined;
+    /** The id of the open category, if the list has any. */
+    get category(): string | undefined;
+    categories(): readonly Category[];
+    selectCategory(id: string): Promise<void>;
+    setFocus(list: boolean): void;
+    /** The list on screen, built when there is none yet. */
+    private screen;
+    /** A list from the current data; its categories are shown by the menu's navigation. */
+    private build;
     /** The entries ticked in a multi-select list. */
     protected ticked(): T[];
     open(): Promise<void>;