windows-development-sandbox 1.5.0 → 1.9.0

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

@@ -4,10 +4,14 @@ import { type DataEntry } from '../../commands/data/collect.js';
 import type { RepairResult } from '../../commands/repair/types.js';
 import { type LogFile, type SetupReport, type UpdateStatus } from '../../services/index.js';
 import { type App, type ListOptions, type ListResult } from '../../tui/index.js';
-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[];
@@ -48,7 +52,6 @@ export declare class MaintenancePage extends ListPage<string> {
     private doctorRows;
     private repairRows;
     private setupReport;
-    private seen;
     private settings;
     private readonly migrate;
     private readonly health;
@@ -59,8 +62,6 @@ export declare class MaintenancePage extends ListPage<string> {
     private model;
     protected load(): Promise<void>;
     protected options(): ListOptions<string>;
-    /** Opening a category loads what it shows (the cheap ones; data is measured on request). */
-    protected afterKey(): Promise<Step<ShellExit>>;
     private readSettings;
     private updateStatus;
     /** The Updates category: look, install, go back, switch automatic updates. */
@@ -69,8 +70,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,
@@ -113,10 +148,23 @@ export function maintenanceOptions(m) {
         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: 'doctor',
+        category: 'health',
+        section: 'Doctor',
         hint: Text.truncate(detail, 50),
         details: [detail],
     }));
@@ -126,7 +174,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 +184,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 +206,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 +221,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 +230,90 @@ 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), ...check, ...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 === 'health:check')
+        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:'))
+        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: 'l', label: 'check again' },
+                    { 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',
+                            },
+                        ]
+                        : []),
+                ];
+            }
             default:
                 return [];
         }
@@ -234,7 +327,6 @@ export class MaintenancePage extends ListPage {
     doctorRows = null;
     repairRows = null;
     setupReport = null;
-    seen;
     settings = { pending: [] };
     migrate;
     health;
@@ -255,6 +347,7 @@ export class MaintenancePage extends ListPage {
     }
     model() {
         return {
+            dataFolder: dataFolderRow(this.ctx),
             data: this.data,
             logs: this.logs,
             doctor: this.doctorRows,
@@ -282,21 +375,6 @@ export class MaintenancePage extends ListPage {
     options() {
         return maintenanceOptions(this.model());
     }
-    /** Opening a category loads what it shows (the cheap ones; data is measured on request). */
-    async afterKey() {
-        const category = this.category;
-        if (category === this.seen)
-            return;
-        this.seen = category;
-        if (category === 'doctor' && !this.doctorRows)
-            await this.loadDoctor();
-        else if (category === 'setup' && !this.setupReport)
-            await this.loadSetup();
-        else
-            return;
-        this.rebuild(undefined);
-        return;
-    }
     readSettings() {
         try {
             this.settings = { pending: this.migrate.plan() };
@@ -390,6 +468,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 +484,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' || id === 'health:check') {
+                    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 +510,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 +548,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

@@ -1,12 +1,15 @@
+import { type SandboxStatus } from '../../../app/features/sandbox/index.js';
 import type { Context } from '../../commands/context.js';
-import { type DatabaseRow, type ProjectsListing, type SandboxReport } from '../../services/index.js';
+import { type DatabaseRow, type ProjectsListing } from '../../services/index.js';
 import { type App, type ListOptions, type ListResult } from '../../tui/index.js';
 import { ListPage, type Outcome } from './list-page.js';
 export interface SandboxModel {
-    readonly report: SandboxReport;
+    readonly report: SandboxStatus;
     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>;
@@ -14,18 +17,16 @@ export declare class SandboxPage extends ListPage<string> {
     private readonly ctx;
     readonly label = "Sandbox";
     private model;
-    private readonly sandbox;
     private readonly projects;
+    private readonly operations;
     constructor(app: App, ctx: Context);
     protected load(): Promise<void>;
     /** The folder `sbx-db` runs in: the sandbox's own workspace. */
     private guestWorkspace;
     protected options(): ListOptions<string>;
     protected act(result: ListResult<string>): Promise<Outcome<string>>;
+    private defaultAgent;
     private noSandbox;
-    private show;
-    private hide;
-    private stop;
     private addRoot;
     private forget;
     private toggleDatabase;