windows-development-sandbox 1.5.0 → 1.7.0

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

@@ -1,33 +1,66 @@
 // The common shape of a tab that is a list: it loads its data, builds a list screen from it, and acts on what the list
 // returns. After every action the list is built again from fresh data, on the same entry.
-import { ListScreen } from '../../tui/index.js';
+import { ListScreen, } from '../../tui/index.js';
 export class ListPage {
     app;
     stages = false;
     list;
     notice;
+    /** The list has the keyboard (the menu's navigation does not). */
+    focused = true;
+    /** The entry that was last acted on: the cursor returns to it when the section opens again. */
+    lastFocus;
     constructor(app) {
         this.app = app;
     }
+    /** The entry the cursor starts on the first time the section opens (default: the first). */
+    initialFocus() {
+        return undefined;
+    }
     get capturing() {
         return this.list?.isSearching ?? false;
     }
-    /** The id of the open sidebar category, if the list has one. */
+    /** The id of the open category, if the list has any. */
     get category() {
         return this.list?.currentCategory;
     }
+    categories() {
+        return this.screen().categories;
+    }
+    async selectCategory(id) {
+        this.screen().setCategory(id);
+        await this.afterKey();
+    }
+    setFocus(list) {
+        this.focused = list;
+        this.list?.setActive(list);
+    }
+    /** The list on screen, built when there is none yet. */
+    screen() {
+        return (this.list ??= this.build({}));
+    }
+    /** A list from the current data; its categories are shown by the menu's navigation. */
+    build(extra) {
+        const list = new ListScreen({ ...this.options(), ...extra, categoryNav: 'external', escapeLabel: 'sections' });
+        list.setActive(this.focused);
+        return list;
+    }
     /** The entries ticked in a multi-select list. */
     ticked() {
         return this.list?.ticked() ?? [];
     }
     async open() {
         await this.load();
-        this.rebuild(undefined);
+        // Back on the entry used last, when it is still in the category that is open.
+        const wanted = this.lastFocus ?? this.initialFocus();
+        const open = this.list?.currentCategory;
+        const item = wanted === undefined ? undefined : this.options().items.find((i) => i.value === wanted);
+        this.rebuild(item && (!open || !item.category || item.category === open) ? wanted : undefined);
     }
     /** Builds the list again, on `focus` when it is still there. */
     rebuild(focus, notice) {
         const startCategory = this.list?.currentCategory;
-        this.list = new ListScreen({ ...this.options(), startAt: focus, startCategory, notice: notice ?? this.notice });
+        this.list = this.build({ startAt: focus, startCategory, notice: notice ?? this.notice });
         this.notice = undefined;
     }
     /** Shows `text` now, before slow work starts. */
@@ -40,12 +73,10 @@ export class ListPage {
         this.notice = text;
     }
     render(size) {
-        this.list ??= new ListScreen(this.options());
-        return this.list.render(size);
+        return this.screen().render(size);
     }
     async handle(key) {
-        this.list ??= new ListScreen(this.options());
-        const step = this.list.handle(key);
+        const step = this.screen().handle(key);
         if (!step)
             return this.afterKey();
         const result = step.done;
@@ -55,6 +86,7 @@ export class ListPage {
         if (outcome.reload)
             await this.load();
         const here = result.kind === 'pick' || result.kind === 'action' ? result.value : undefined;
+        this.lastFocus = outcome.focus ?? here ?? this.lastFocus;
         this.rebuild(outcome.focus ?? here, outcome.notice);
         return;
     }

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

@@ -8,6 +8,12 @@ import type { Step } from '../../tui/index.js';
 import type { ShellExit } from '../shell.js';
 import { ListPage, type Outcome } from './list-page.js';
 export interface MaintenanceModel {
+    /** The data folder row (where the sandbox keeps its data). */
+    readonly dataFolder: {
+        label: string;
+        hint: string;
+        description: string;
+    };
     /** Null until measured (measuring a big data folder takes a while). */
     readonly data: {
         entries: DataEntry[];
@@ -69,8 +75,11 @@ export declare class MaintenancePage extends ListPage<string> {
     private loadDoctor;
     private loadSetup;
     protected act(result: ListResult<string>): Promise<Outcome<string>>;
+    /** The key an Enter on an Updates row stands for. */
+    private updateKey;
     private measure;
     private remove;
+    /** Repair shows what it does as it goes and asks before it changes anything, so it runs on the normal screen. */
     private repair;
     private enable;
 }

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

@@ -1,5 +1,6 @@
-// Tab 7: keeping things in shape. What is stored (with clean-up), the logs, the doctor, repair, this PC's setup, and
-// the less common commands. Each is a category on the left and loads when you open it.
+// 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';
@@ -11,18 +12,37 @@ import { DataService, HealthService, LogsService, MigrateService, NPM_UPDATE_COM
 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 { ListPage } from './list-page.js';
 const CATEGORIES = [
-    { id: 'data', label: 'Stored data', description: 'What is kept between sandboxes, and deleting parts of it.' },
+    {
+        id: 'updates',
+        label: 'Updates',
+        description: 'Which version is installed, installing a newer one, and bringing your saved settings up to date.',
+    },
+    {
+        id: 'data',
+        label: 'Data & storage',
+        description: 'Where the sandbox keeps its data, what is stored, and deleting parts of it.',
+    },
+    {
+        id: 'health',
+        label: 'Health',
+        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: 'doctor', label: 'Doctor', description: 'Checks this PC and your settings.' },
-    { id: 'repair', label: 'Repair', description: 'Finds common problems and fixes what it can.' },
-    { id: 'settings', label: 'Saved settings', description: 'Brings your saved settings up to date with this version.' },
-    { id: 'updates', label: 'Updates', description: 'Which version is installed, and installing a newer one.' },
-    { id: 'setup', label: 'Set up this PC', description: 'Can this PC run Windows Sandbox?' },
     { id: 'more', label: 'More commands', description: 'Less common commands.' },
 ];
 const MORE_COMMANDS = ['sync', 'audit', 'config', 'generate', 'exec', 'agent-commands'];
+/** Plain names for the commands under More commands. */
+const MORE_LABELS = {
+    sync: 'Copy history back now',
+    audit: 'What happened in the sandbox',
+    config: 'Your settings file',
+    generate: 'Preview a start',
+    exec: 'Run a command in the sandbox',
+    'agent-commands': 'Agent commands (Beta)',
+};
 const REPAIR_LABEL = {
     ok: ['OK', Theme.ok],
     fixed: ['FIXED', Theme.accent],
@@ -39,17 +59,28 @@ const AREA_LABEL = {
     host: 'On this PC',
 };
 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).',
+    };
     if (!m.data)
         return [
+            folder,
             {
                 value: 'data:measure',
                 label: 'Measure what is stored',
                 category: 'data',
-                hint: Theme.muted('press 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,
@@ -67,6 +98,7 @@ function dataItems(m) {
             description: cleanTargetOf(e) ? 'x deletes it.' : 'Kept on this PC on purpose; it is not deleted here.',
             details: [Theme.muted('Folder  ') + e.path],
         })),
+        clean,
     ];
 }
 function updateItems(m) {
@@ -74,6 +106,7 @@ function updateItems(m) {
         value: 'updates:' + id,
         label,
         category: 'updates',
+        section: 'This program',
         hint,
         description,
         details,
@@ -89,14 +122,16 @@ function updateItems(m) {
     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('press c to look'), m.latest ? 'Enter or u installs it.' : 'c looks on GitHub for a newer version.'),
-        row('auto', 'Automatic updates', u.autoUpdate ? Theme.ok('on') : Theme.muted('off'), 'a switches them. ' +
+        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, 'r goes back to it.'));
+        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,
@@ -116,7 +151,8 @@ export function maintenanceOptions(m) {
     const doctor = (m.doctor ?? []).map(([name, detail], i) => ({
         value: 'doctor:' + i,
         label: name,
-        category: 'doctor',
+        category: 'health',
+        section: 'Doctor',
         hint: Text.truncate(detail, 50),
         details: [detail],
     }));
@@ -126,7 +162,8 @@ export function maintenanceOptions(m) {
             return {
                 value: 'repair:' + i,
                 label: r.name,
-                category: 'repair',
+                category: 'health',
+                section: 'Repair',
                 hint: paint(text),
                 description: r.detail,
             };
@@ -135,19 +172,20 @@ export function maintenanceOptions(m) {
             {
                 value: 'repair:run',
                 label: 'Run the checks and fix what can be fixed',
-                category: 'repair',
-                hint: Theme.muted('press f'),
-                description: 'Each check confirms all is well, fixes the problem itself, or says what you need to do.',
+                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: '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: 'setup',
+                category: 'health',
+                section: 'Set up this PC',
                 hint: c.status === 'ok'
                     ? Theme.ok('OK')
                     : c.status === 'warn'
@@ -156,12 +194,13 @@ export function maintenanceOptions(m) {
                 description: c.detail,
             }));
     const settings = 'error' in m.settings
-        ? [{ value: 'settings:error', label: m.settings.error, category: '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: 'settings',
+                category: 'updates',
+                section: 'Saved settings',
                 hint: Theme.warn('to update'),
                 description: 'Enter updates your saved settings (a backup is kept first).',
                 details: [line],
@@ -170,7 +209,8 @@ export function maintenanceOptions(m) {
                 {
                     value: 'settings:none',
                     label: 'Up to date',
-                    category: 'settings',
+                    category: 'updates',
+                    section: 'Saved settings',
                     hint: Theme.ok('OK'),
                     description: 'Nothing to update.',
                 },
@@ -178,49 +218,88 @@ export function maintenanceOptions(m) {
     const updates = updateItems(m);
     const more = m.more.map((c) => ({
         value: 'more:' + c.name,
-        label: Text.humanize(c.name),
+        label: MORE_LABELS[c.name] ?? Text.humanize(c.name),
         category: 'more',
-        hint: Theme.muted('sandbox ' + c.name),
         description: c.summary.replace(/^./, (x) => x.toUpperCase()) + '.',
     }));
     return {
         path: [],
         categories: CATEGORIES,
-        items: [...dataItems(m), ...logs, ...doctor, ...repair, ...settings, ...updates, ...setup, ...more],
+        items: [...updates, ...settings, ...dataItems(m), ...doctor, ...repair, ...setup, ...logs, ...more],
         empty: 'Nothing here yet.',
         actions: maintenanceActions(m),
-        escapeLabel: 'quit',
+        enterLabel: (_category, id) => enterLabel(id ?? '', m),
     };
 }
+/** What Enter does on a row ("" = the row only shows information). */
+function enterLabel(id, m) {
+    if (id === 'data:folder')
+        return 'change';
+    if (id === 'data:measure')
+        return 'measure';
+    if (id === 'data:clean')
+        return 'choose what';
+    if (id === 'repair:run')
+        return 'check and fix';
+    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:'))
+        return 'open';
+    return '';
+}
 function maintenanceActions(m) {
     return (category) => {
         switch (category) {
-            case 'data':
-                return [{ key: 'm', label: 'measure' }, ...(m.data ? [{ key: 'x', label: 'delete' }] : [])];
+            case 'data': {
+                const deletable = new Set((m.data?.entries ?? []).flatMap((e, i) => (cleanTargetOf(e) ? ['entry:' + i] : [])));
+                return [
+                    { key: 'm', label: 'measure again' },
+                    { key: 'x', label: 'delete', applies: (id) => deletable.has(id) },
+                ];
+            }
             case 'logs':
                 return [{ key: 'f', label: 'follow in the terminal' }];
-            case 'doctor':
-                return [{ key: 'l', label: 'check again' }];
-            case 'repair':
-                return [{ key: 'f', label: 'check and fix' }];
-            case 'settings':
-                return [{ key: 'u', label: 'update now' }];
-            case 'updates':
-                return 'error' in m.updates || !m.updates.managed
-                    ? []
-                    : [
-                        { key: 'c', label: 'check now' },
-                        { key: 'u', label: 'update now' },
-                        { key: 'r', label: 'roll back' },
-                        { key: 'a', label: 'automatic on/off' },
-                    ];
-            case 'setup': {
+            case 'health': {
                 const canEnable = m.setup !== null && !('error' in m.setup) && m.setup.canEnable;
                 return [
+                    { key: 'f', label: 'check and fix' },
                     { key: 'l', label: 'check again' },
                     ...(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',
+                            },
+                        ]
+                        : []),
+                ];
+            }
             default:
                 return [];
         }
@@ -255,6 +334,7 @@ export class MaintenancePage extends ListPage {
     }
     model() {
         return {
+            dataFolder: dataFolderRow(this.ctx),
             data: this.data,
             logs: this.logs,
             doctor: this.doctorRows,
@@ -288,12 +368,12 @@ export class MaintenancePage extends ListPage {
         if (category === this.seen)
             return;
         this.seen = category;
-        if (category === 'doctor' && !this.doctorRows)
+        if (category !== 'health' || (this.doctorRows && this.setupReport))
+            return;
+        if (!this.doctorRows)
             await this.loadDoctor();
-        else if (category === 'setup' && !this.setupReport)
+        if (!this.setupReport)
             await this.loadSetup();
-        else
-            return;
         this.rebuild(undefined);
         return;
     }
@@ -390,6 +470,14 @@ export class MaintenancePage extends ListPage {
         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 };
+            }
+            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 } } : {};
+            }
             if (key === 'x')
                 return await this.remove(id);
             if (key === 'f' && this.category === 'logs')
@@ -398,22 +486,21 @@ export class MaintenancePage extends ListPage {
                 const file = this.logs.find((l) => l.name === id.slice(4));
                 return file ? { exit: { kind: 'view', file: file.path } } : {};
             }
-            if (this.category === 'updates')
-                return await this.updates(key ?? (id === 'updates:latest' ? 'u' : undefined));
-            if (key === 'u' || (result.kind === 'pick' && id?.startsWith('settings:')))
+            if ((result.kind === 'pick' && id?.startsWith('settings:')) || (key === 's' && this.category === 'updates'))
                 return await this.updateSettings();
-            if (key === 'f' || id === 'repair:run')
-                return this.repair();
-            if (key === 'l' && this.category === 'doctor') {
-                await this.loadDoctor();
-                return {};
-            }
-            if (key === 'l') {
-                await this.loadSetup();
-                return {};
+            if (this.category === 'updates')
+                return await this.updates(key ?? this.updateKey(id));
+            if (this.category === 'health') {
+                if (key === 'f' || id === 'repair:run')
+                    return this.repair();
+                if (key === 'l') {
+                    await this.loadDoctor();
+                    await this.loadSetup();
+                    return {};
+                }
+                if (key === 'e')
+                    return await this.enable();
             }
-            if (key === 'e')
-                return await this.enable();
             if (id?.startsWith('more:') && result.kind === 'pick') {
                 const spec = commandSpec(id.slice(5));
                 const argv = await new CommandForm(this.app, this.ctx, spec).run();
@@ -425,6 +512,16 @@ 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();
@@ -453,17 +550,9 @@ export class MaintenancePage extends ListPage {
         this.data = { ...this.data, entries: gone, total: _.sumBy(gone, 'bytes') };
         return { notice: Theme.ok(Theme.glyph.ok + ' Freed ' + humanBytes(outcome.freedBytes) + '.') };
     }
+    /** Repair shows what it does as it goes and asks before it changes anything, so it runs on the normal screen. */
     repair() {
-        this.busy('Checking and fixing…');
-        this.repairRows = this.health.repair();
-        const needs = this.repairRows.filter((r) => r.status === 'needs-you').length;
-        return {
-            notice: needs
-                ? Theme.warn(needs + ' thing(s) need you (see NEEDS YOU).')
-                : Theme.ok(Theme.glyph.ok +
-                    ' All good' +
-                    (this.repairRows.some((r) => r.status === 'fixed') ? ': problems were fixed.' : '.')),
-        };
+        return { exit: { kind: 'run', argv: ['repair'] } };
     }
     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');

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

@@ -7,6 +7,8 @@ export interface SandboxModel {
     readonly projects: ProjectsListing;
     /** Null: the sandbox is not running or did not answer. */
     readonly databases: DatabaseRow[] | null;
+    /** The agent "Start the sandbox" offers while nothing runs. */
+    readonly defaultAgent: string;
 }
 /** The list for the sandbox tab. Pure. */
 export declare function sandboxOptions(m: SandboxModel): ListOptions<string>;
@@ -22,6 +24,7 @@ export declare class SandboxPage extends ListPage<string> {
     private guestWorkspace;
     protected options(): ListOptions<string>;
     protected act(result: ListResult<string>): Promise<Outcome<string>>;
+    private defaultAgent;
     private noSandbox;
     private show;
     private hide;