windows-development-sandbox 1.9.0 → 1.11.3

package/dist/app/features/updates/update-lines.d.ts

@@ -0,0 +1,13 @@
+import type { Context } from '../../../cli/commands/context.js';
+import type { MigrateContext } from '../../../cli/services/index.js';
+import type { UpdateResult } from '../../../host/update/index.js';
+/** One sentence for what an update run did, and whether it counts as done (1: it failed, or is waiting by hand). */
+export declare function describeResult(result: UpdateResult | null, unattended: boolean): {
+    line: string;
+    code: number;
+};
+/**
+ * Where this context keeps the saved settings. Backups go where the data is: an upgrade that has not pinned the old
+ * folder yet would otherwise fill the new, empty default folder with them.
+ */
+export declare function whereOf(ctx: Context): MigrateContext;

package/dist/app/features/updates/update-lines.js

@@ -0,0 +1,61 @@
+// The sentences an update run can end with, and where a settings backup goes. Node-side (UpdateResult comes from
+// host/update), used by updates.run.ts and by the startup migration of the command line (cli/commands/maintenance).
+import { userDir } from '../../../core/config/index.js';
+import { holdsData, oldDefaultRoot } from '../../../host/storage/index.js';
+/** One sentence for what an update run did, and whether it counts as done (1: it failed, or is waiting by hand). */
+export function describeResult(result, unattended) {
+    if (!result)
+        return { line: 'Another update is running right now.', code: 0 };
+    if (result.kind === 'installed')
+        return {
+            line: 'Updated ' +
+                (result.previous ? 'from ' + result.previous + ' ' : '') +
+                'to ' +
+                result.version +
+                '. Open a new terminal to use it.',
+            code: 0,
+        };
+    if (result.kind === 'failed')
+        return {
+            line: 'Update to ' +
+                result.version +
+                ' failed: ' +
+                result.reason.replace(/\.?\s*$/, '.') +
+                (result.rolledBack
+                    ? ' The change was undone: you are on the version you had.'
+                    : ' Going back to your previous version did not fully work: run sandbox update --rollback or the installer.') +
+                (result.autoUpdateOff
+                    ? ' Automatic updates are off; turn them back on in Maintenance > Updates or with sandbox update --auto on.'
+                    : result.blocked
+                        ? ' It is not tried again; the next release is.'
+                        : ' It is tried again later.'),
+            code: 1,
+        };
+    switch (result.reason) {
+        case 'up-to-date':
+            return { line: 'You have the newest version (' + result.current + ').', code: 0 };
+        case 'sandbox-running':
+            return {
+                line: 'A Windows Sandbox is running, so nothing was installed. Close it (sandbox stop), then update again.',
+                code: unattended ? 0 : 1,
+            };
+        case 'failed-before':
+            return {
+                line: 'The newest version failed to install before. It is not tried again until a newer one is released.',
+                code: 0,
+            };
+        case 'no-release':
+            return { line: 'No release was found.', code: 0 };
+        case 'too-soon':
+            return { line: 'Looked a short while ago; nothing to do yet.', code: 0 };
+    }
+}
+/**
+ * Where this context keeps the saved settings. Backups go where the data is: an upgrade that has not pinned the old
+ * folder yet would otherwise fill the new, empty default folder with them.
+ */
+export function whereOf(ctx) {
+    const old = oldDefaultRoot();
+    const unpinned = old !== null && !holdsData(ctx.storageRoot) && holdsData(old) && !ctx.loaded.layers?.machine;
+    return { storageRoot: unpinned ? old : ctx.storageRoot, userDir: userDir(), configPath: ctx.loaded.configPath };
+}

package/dist/app/features/updates/updates.def.d.ts

@@ -0,0 +1,89 @@
+import { z } from 'zod';
+import { type Page } from '../../kernel/index.js';
+export declare const UpdatesStatusSchema: z.ZodObject<{
+    managed: z.ZodBoolean;
+    version: z.ZodString;
+    scope: z.ZodNullable<z.ZodEnum<{
+        user: "user";
+        machine: "machine";
+    }>>;
+    autoUpdate: z.ZodBoolean;
+    autoOffText: z.ZodNullable<z.ZodString>;
+    previous: z.ZodNullable<z.ZodString>;
+    failed: z.ZodNullable<z.ZodObject<{
+        version: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strip>>;
+    npmCommand: z.ZodString;
+    error: z.ZodNullable<z.ZodString>;
+    settings: z.ZodObject<{
+        pending: z.ZodArray<z.ZodString>;
+        error: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type UpdatesStatus = z.output<typeof UpdatesStatusSchema>;
+export declare const updatesStatus: import("../../kernel/define.js").QueryDef<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+    managed: z.ZodBoolean;
+    version: z.ZodString;
+    scope: z.ZodNullable<z.ZodEnum<{
+        user: "user";
+        machine: "machine";
+    }>>;
+    autoUpdate: z.ZodBoolean;
+    autoOffText: z.ZodNullable<z.ZodString>;
+    previous: z.ZodNullable<z.ZodString>;
+    failed: z.ZodNullable<z.ZodObject<{
+        version: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strip>>;
+    npmCommand: z.ZodString;
+    error: z.ZodNullable<z.ZodString>;
+    settings: z.ZodObject<{
+        pending: z.ZodArray<z.ZodString>;
+        error: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>, "updates.status">;
+export declare const runUpdate: import("../../kernel/define.js").OperationDef<z.ZodObject<{
+    check: z.ZodDefault<z.ZodBoolean>;
+    rollback: z.ZodDefault<z.ZodBoolean>;
+    auto: z.ZodOptional<z.ZodEnum<{
+        off: "off";
+        on: "on";
+    }>>;
+    unattended: z.ZodDefault<z.ZodBoolean>;
+    feed: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    line: z.ZodString;
+    latest: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>, "updates.update">;
+export declare const migrateSettings: import("../../kernel/define.js").OperationDef<z.ZodObject<{
+    dryRun: z.ZodDefault<z.ZodBoolean>;
+    restore: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    line: z.ZodString;
+}, z.core.$strip>, "updates.migrate">;
+/** The Updates page: "This program" (version, newest, automatic updates, previous, last failure) and saved settings. */
+export declare function updatesPage(s: UpdatesStatus, latest: string | null): Page;
+export declare const updatesView: import("../../kernel/define.js").ViewDef<{
+    status: import("../../kernel/define.js").QueryDef<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+        managed: z.ZodBoolean;
+        version: z.ZodString;
+        scope: z.ZodNullable<z.ZodEnum<{
+            user: "user";
+            machine: "machine";
+        }>>;
+        autoUpdate: z.ZodBoolean;
+        autoOffText: z.ZodNullable<z.ZodString>;
+        previous: z.ZodNullable<z.ZodString>;
+        failed: z.ZodNullable<z.ZodObject<{
+            version: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$strip>>;
+        npmCommand: z.ZodString;
+        error: z.ZodNullable<z.ZodString>;
+        settings: z.ZodObject<{
+            pending: z.ZodArray<z.ZodString>;
+            error: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, "updates.status">;
+}, Record<string, never>, "updates">;

package/dist/app/features/updates/updates.def.js

@@ -0,0 +1,225 @@
+// The program's own updates (install, check, go back, automatic on/off) and your saved settings brought up to date.
+// Pure: schemas, labels, CLI hints and the page builder; updates.run.ts does the work through UpdateService and
+// MigrateService.
+import { z } from 'zod';
+import { action, defineOperation, defineQuery, defineView, } from '../../kernel/index.js';
+const FailedSchema = z.object({
+    version: z.string().describe('The version that failed'),
+    reason: z.string().describe('Why it failed, in one sentence'),
+});
+export const UpdatesStatusSchema = z.object({
+    managed: z.boolean().describe('Installed by the installer, so it can update itself'),
+    version: z.string().describe('The version installed'),
+    scope: z.enum(['user', 'machine']).nullable().describe('Installed for you, or for everyone on this PC'),
+    autoUpdate: z.boolean().describe('New versions install by themselves'),
+    autoOffText: z.string().nullable().describe('Why automatic updates were turned off, if they were'),
+    previous: z.string().nullable().describe('The version an update replaced (roll back goes there)'),
+    failed: FailedSchema.nullable().describe('The last update that failed'),
+    npmCommand: z.string().describe('How an npm install is updated'),
+    error: z.string().nullable().describe('Why the status could not be read'),
+    settings: z
+        .object({
+        pending: z.array(z.string()).describe('Each change still to make, as "name: what it does"'),
+        error: z.string().nullable().describe('Why your saved settings could not be read'),
+    })
+        .describe('Changes still to make to your saved settings'),
+});
+export const updatesStatus = defineQuery({
+    id: 'updates.status',
+    title: 'Updates',
+    summary: 'which version is installed and what your saved settings still need',
+    input: z.object({}),
+    output: UpdatesStatusSchema,
+    surfaces: {
+        except: { cli: 'no command shows this page; sandbox update --check and --version cover the command line' },
+    },
+});
+const LineSchema = z.object({ line: z.string().describe('What happened, in one sentence') });
+export const runUpdate = defineOperation({
+    id: 'updates.update',
+    title: 'Update now',
+    summary: 'install the newest version, or check, go back, or switch automatic updates',
+    input: z.object({
+        check: z.boolean().default(false).describe('only look whether a newer version exists'),
+        rollback: z.boolean().default(false).describe('go back to the version before the last update'),
+        auto: z
+            .enum(['on', 'off'])
+            .optional()
+            .describe('install new versions by themselves (for everyone on this PC: needs an admin terminal)'),
+        unattended: z.boolean().default(false).describe('used by automatic updates: no questions, short output'),
+        feed: z
+            .string()
+            .optional()
+            .describe('take the release from this folder (a feed.json and the package) instead of GitHub'),
+    }),
+    output: LineSchema.extend({ latest: z.string().nullable().describe('The newer version a check found') }),
+    danger: true,
+    text: (o) => o.line,
+    cli: {
+        name: 'update',
+        group: 'Health',
+        flags: {
+            check: { flag: '--check' },
+            rollback: { flag: '--rollback' },
+            auto: { flag: '--auto', value: 'on|off' },
+            unattended: { flag: '--unattended', noMenu: true, advanced: true },
+            feed: { flag: '--feed', value: 'folder', noMenu: true, advanced: true },
+        },
+        yes: '(--rollback) do not ask first',
+    },
+});
+export const migrateSettings = defineOperation({
+    id: 'updates.migrate',
+    title: 'Update saved settings',
+    summary: 'bring your saved settings up to date with this version',
+    input: z.object({
+        dryRun: z.boolean().default(false).describe('only list what would change'),
+        restore: z
+            .string()
+            .optional()
+            .describe('put back the files saved before an update (a folder under <storage>\\backups)'),
+    }),
+    output: LineSchema,
+    text: (o) => o.line,
+    cli: {
+        name: 'migrate',
+        group: 'Health',
+        flags: { dryRun: { flag: '--dry-run' }, restore: { flag: '--restore', value: 'backup', advanced: true } },
+        yes: '(--restore) do not ask first',
+    },
+});
+const row = (id, label, extra = {}) => ({ id: 'updates:' + id, label, ...extra });
+/** The Updates page: "This program" (version, newest, automatic updates, previous, last failure) and saved settings. */
+export function updatesPage(s, latest) {
+    const managed = s.managed && !s.error;
+    const machine = s.scope === 'machine';
+    const nextAuto = s.autoUpdate ? 'off' : 'on';
+    const rollback = action(runUpdate, { rollback: true }, { label: 'Roll back', verb: 'go back' });
+    const program = {
+        id: 'program',
+        title: 'This program',
+        notes: [
+            {
+                text: 'After an update this page still runs the version it started with; sandbox web open (or the next sandbox start) starts the new one.',
+                tone: 'muted',
+                only: 'web',
+            },
+        ],
+        items: s.error
+            ? [{ id: 'updates:error', label: s.error, tone: 'danger' }]
+            : !s.managed
+                ? [
+                    row('version', 'Version', {
+                        hint: s.version,
+                        description: 'Installed with npm, so npm updates it: ' + s.npmCommand,
+                    }),
+                    row('npm', 'Update', {
+                        hint: 'with npm',
+                        tone: 'muted',
+                        description: 'Run ' + s.npmCommand + ' in a terminal.',
+                    }),
+                ]
+                : [
+                    row('version', 'Version', {
+                        hint: s.version,
+                        description: 'Installed ' + (machine ? 'for everyone on this PC' : 'for you') + '.',
+                    }),
+                    row('latest', 'Newest version', {
+                        hint: latest ?? 'not looked yet',
+                        tone: latest ? 'warn' : 'muted',
+                        keys: latest ? 'Enter installs it.' : 'Enter looks on GitHub for a newer version.',
+                        primary: latest
+                            ? action(runUpdate, {}, { label: 'Install ' + latest, verb: 'install' })
+                            : action(runUpdate, { check: true }, { label: 'Check now', verb: 'look', danger: false }),
+                    }),
+                    row('auto', 'Automatic updates', {
+                        hint: s.autoUpdate ? 'on' : 'off',
+                        tone: s.autoUpdate ? 'ok' : 'muted',
+                        description: machine
+                            ? 'For everyone: needs an admin terminal.'
+                            : 'A new version installs when no sandbox runs.',
+                        keys: 'Enter switches them.',
+                        primary: action(runUpdate, { auto: nextAuto }, {
+                            label: 'Automatic updates ' + nextAuto,
+                            verb: 'switch',
+                            danger: false,
+                        }),
+                        actions: [
+                            action(runUpdate, { auto: nextAuto }, {
+                                key: 'a',
+                                label: 'Automatic updates ' + nextAuto,
+                                verb: 'automatic on/off',
+                                danger: false,
+                            }),
+                        ],
+                    }),
+                    ...(s.autoOffText
+                        ? [
+                            row('autooff', 'Automatic updates turned off', {
+                                hint: 'off',
+                                tone: 'warn',
+                                description: s.autoOffText,
+                                details: [s.autoOffText],
+                            }),
+                        ]
+                        : []),
+                    ...(s.previous
+                        ? [
+                            row('previous', 'Previous version', {
+                                hint: s.previous,
+                                keys: 'Enter goes back to it.',
+                                primary: rollback,
+                                actions: [{ ...rollback, key: 'r', verb: 'roll back' }],
+                            }),
+                        ]
+                        : []),
+                    ...(s.failed
+                        ? [
+                            row('failed', 'Last failed update', {
+                                hint: s.failed.version,
+                                tone: 'danger',
+                                description: s.failed.reason,
+                                details: [s.failed.reason, 'It is not tried again until a newer version is released.'],
+                            }),
+                        ]
+                        : []),
+                ],
+    };
+    const pending = s.settings.pending;
+    const settingsItems = s.settings.error
+        ? [{ id: 'settings:error', label: s.settings.error, tone: 'danger' }]
+        : pending.length
+            ? pending.map((line, i) => ({
+                id: 'settings:' + i,
+                label: line.split(':')[0],
+                hint: 'to update',
+                tone: 'warn',
+                description: 'A backup is kept first.',
+                keys: 'Enter updates your saved settings.',
+                details: [line],
+                primary: action(migrateSettings, {}, { label: 'Update saved settings', verb: 'update' }),
+                actions: [
+                    action(migrateSettings, {}, { key: 's', label: 'Update saved settings', verb: 'update saved settings' }),
+                ],
+            }))
+            : [{ id: 'settings:none', label: 'Up to date', hint: 'OK', tone: 'ok', description: 'Nothing to update.' }];
+    const settings = { id: 'settings', title: 'Saved settings', items: settingsItems };
+    return {
+        title: 'Updates',
+        sections: [program, settings],
+        actions: managed
+            ? [
+                action(runUpdate, { check: true }, { key: 'c', label: 'Check now', verb: 'check now', danger: false }),
+                action(runUpdate, {}, { key: 'u', label: 'Update now', verb: 'update now' }),
+            ]
+            : [],
+    };
+}
+export const updatesView = defineView({
+    id: 'updates',
+    title: 'Updates',
+    summary: 'Which version is installed, installing a newer one, and bringing your saved settings up to date.',
+    queries: { status: updatesStatus },
+    operations: [runUpdate, migrateSettings],
+    build: ({ status }) => updatesPage(status, null),
+});

package/dist/app/features/updates/updates.run.d.ts

@@ -0,0 +1,48 @@
+import { MigrateService, UpdateService } from '../../../cli/services/index.js';
+import { type InputOf, type OperationIO, type OutputOf } from '../../kernel/index.js';
+import { migrateSettings, runUpdate } from './updates.def.js';
+/** sandbox update's work, given the service (tests pass their own). */
+export declare function updateWith(service: UpdateService, input: InputOf<typeof runUpdate>, io: OperationIO): Promise<OutputOf<typeof runUpdate>>;
+export declare const runUpdateRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{
+    check: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    rollback: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    auto: import("zod").ZodOptional<import("zod").ZodEnum<{
+        off: "off";
+        on: "on";
+    }>>;
+    unattended: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    feed: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    line: import("zod").ZodString;
+    latest: import("zod").ZodNullable<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, "updates.update">, import("../../../cli/commands/context.js").Context>;
+/** sandbox migrate's work, given the service (tests pass their own). */
+export declare function migrateWith(service: MigrateService, input: InputOf<typeof migrateSettings>, io: OperationIO): Promise<OutputOf<typeof migrateSettings>>;
+export declare const migrateSettingsRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{
+    dryRun: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    restore: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    line: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, "updates.migrate">, import("../../../cli/commands/context.js").Context>;
+/** What the page shows: the program's state and saved settings, each read on its own (one failure keeps the rest). */
+export declare const updatesStatusRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").QueryDef<import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    managed: import("zod").ZodBoolean;
+    version: import("zod").ZodString;
+    scope: import("zod").ZodNullable<import("zod").ZodEnum<{
+        user: "user";
+        machine: "machine";
+    }>>;
+    autoUpdate: import("zod").ZodBoolean;
+    autoOffText: import("zod").ZodNullable<import("zod").ZodString>;
+    previous: import("zod").ZodNullable<import("zod").ZodString>;
+    failed: import("zod").ZodNullable<import("zod").ZodObject<{
+        version: import("zod").ZodString;
+        reason: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>;
+    npmCommand: import("zod").ZodString;
+    error: import("zod").ZodNullable<import("zod").ZodString>;
+    settings: import("zod").ZodObject<{
+        pending: import("zod").ZodArray<import("zod").ZodString>;
+        error: import("zod").ZodNullable<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>;
+}, import("zod/v4/core").$strip>, "updates.status">, import("../../../cli/commands/context.js").Context>;

package/dist/app/features/updates/updates.run.js

@@ -0,0 +1,154 @@
+// The updates area's work: checking, installing and going back for the program (UpdateService), automatic updates, and
+// your saved settings (MigrateService). Talks only through io. The installer's own safety (no install while a sandbox
+// runs, rollback on failure) stays in host/update.
+import { userDir } from '../../../core/config/index.js';
+import { errMsg, fail } from '../../../core/util/index.js';
+import { MigrateService, NPM_UPDATE_COMMAND, UpdateService } from '../../../cli/services/index.js';
+import { implement } from '../../context.js';
+import { cancelled } from '../../kernel/index.js';
+import { describeResult, whereOf } from './update-lines.js';
+import { migrateSettings, runUpdate, updatesStatus } from './updates.def.js';
+/** sandbox update's work, given the service (tests pass their own). */
+export async function updateWith(service, input, io) {
+    if (!service.managed)
+        return { line: 'This copy was installed with npm. Update it with: ' + NPM_UPDATE_COMMAND, latest: null };
+    // The scheduled task (it may outlive a removal that needed admin) and background starts only run when updates are on.
+    if (input.unattended && !input.auto && !service.status().autoUpdate)
+        return { line: '', latest: null };
+    if (input.auto) {
+        io.progress('Turning automatic updates ' + input.auto);
+        service.setAuto(input.auto === 'on');
+        return { line: 'Automatic updates are ' + input.auto + '.', latest: null };
+    }
+    if (input.rollback) {
+        const { version, state } = service.status();
+        const target = state.previous ? 'version ' + state.previous : 'the version before the last update';
+        const yes = await io.confirm({
+            title: 'Go back from version ' + version + ' to ' + target + '?',
+            lines: ['Takes effect the next time you start it.'],
+            yes: 'Go back',
+            danger: true,
+            noTerminal: { message: 'Cannot ask here (no terminal).', fix: 'Add --yes to go back without asking.' },
+        });
+        if (!yes)
+            cancelled('Nothing was changed.');
+        return { line: 'Went back to version ' + service.rollback() + '.', latest: null };
+    }
+    if (input.check) {
+        io.progress('Looking for a newer version');
+        const found = await service.check();
+        if (found.available && found.latest)
+            return {
+                line: 'Version ' + found.latest.version + ' is available (you have ' + found.current + '). Run: sandbox update',
+                latest: found.latest.version,
+            };
+        if (found.blocked)
+            return {
+                line: 'A newer version exists but failed to install before; you have ' + found.current + '.',
+                latest: null,
+            };
+        return { line: 'You have the newest version (' + found.current + ').', latest: null };
+    }
+    // Implied: the command line never asks (typing it was the decision, and --unattended runs from a task); the menu and
+    // the web ask, because they replace the program from a click.
+    const go = await io.confirm({
+        title: 'Install the newest version if there is one?',
+        lines: [
+            'The program files are replaced. Open a new terminal afterwards to use it.',
+            'Nothing is installed while a Windows Sandbox runs.',
+        ],
+        yes: 'Install',
+        danger: true,
+        implied: true,
+    });
+    if (!go)
+        cancelled();
+    io.progress('Installing the newest version');
+    const done = describeResult(await service.run(), input.unattended);
+    if (done.code !== 0)
+        fail(done.line);
+    return { line: done.line, latest: null };
+}
+export const runUpdateRun = implement(runUpdate, async (ctx, input, io) => {
+    // A folder of the user's choosing is installed from only on the command line (the web and the menu send no feed).
+    if (input.feed !== undefined && input.feed !== ctx.options.feed)
+        fail('--feed works only on the command line.');
+    return updateWith(UpdateService.forPackage(ctx.packageRoot, input.feed, { userDir: userDir() }), input, io);
+});
+/** sandbox migrate's work, given the service (tests pass their own). */
+export async function migrateWith(service, input, io) {
+    if (input.restore) {
+        const restore = input.restore;
+        const yes = await io.confirm({
+            title: 'Put back the files saved in ' + restore + '? Your current settings files are replaced.',
+            yes: 'Put back',
+            danger: true,
+            noTerminal: { message: 'Cannot ask here (no terminal).', fix: 'Add --yes to put them back without asking.' },
+        });
+        if (!yes)
+            cancelled('Nothing was changed.');
+        service.restore(restore);
+        return { line: 'Put back the files saved in ' + restore + '.' };
+    }
+    if (input.dryRun) {
+        const plan = service.plan();
+        if (!plan.length)
+            return { line: 'Nothing to update.' };
+        io.log('Would update:');
+        for (const line of plan)
+            io.log('  ' + line);
+        return { line: '' };
+    }
+    const result = await service.run((line) => io.log(line, 'muted'));
+    const sentences = [];
+    if (result.applied.length)
+        sentences.push('Updated: ' + result.applied.join(', ') + '.');
+    else if (!result.postponed.length)
+        sentences.push('Nothing to update.');
+    if (result.postponed.length)
+        sentences.push('Waiting for no sandbox to run: ' + result.postponed.join(', ') + '.');
+    const last = sentences.pop() ?? 'Nothing to update.';
+    for (const s of sentences)
+        io.log(s);
+    return { line: last };
+}
+export const migrateSettingsRun = implement(migrateSettings, (ctx, input, io) => migrateWith(new MigrateService(whereOf(ctx)), input, io));
+/** What the page shows: the program's state and saved settings, each read on its own (one failure keeps the rest). */
+export const updatesStatusRun = implement(updatesStatus, (ctx) => {
+    let program;
+    try {
+        const s = UpdateService.forPackage(ctx.packageRoot, undefined, { userDir: userDir() }).status();
+        program = {
+            managed: s.managed,
+            version: s.version,
+            scope: s.scope,
+            autoUpdate: s.autoUpdate,
+            autoOffText: s.autoOffText ?? null,
+            previous: s.state.previous ?? null,
+            failed: s.state.failed ? { version: s.state.failed.version, reason: s.state.failed.reason } : null,
+            npmCommand: NPM_UPDATE_COMMAND,
+            error: null,
+        };
+    }
+    catch (e) {
+        program = {
+            managed: false,
+            version: '',
+            scope: null,
+            autoUpdate: false,
+            autoOffText: null,
+            previous: null,
+            failed: null,
+            npmCommand: NPM_UPDATE_COMMAND,
+            error: errMsg(e),
+        };
+    }
+    let settings;
+    try {
+        settings = { pending: new MigrateService(whereOf(ctx)).plan(), error: null };
+    }
+    catch (e) {
+        settings = { pending: [], error: errMsg(e) };
+    }
+    return { ...program, settings };
+});

package/dist/app/features/vpn/index.d.ts

@@ -0,0 +1,2 @@
+export * from './vpn.def.js';
+export * from './vpn.run.js';

package/dist/app/features/vpn/index.js

@@ -0,0 +1,3 @@
+// The VPN feature: its status, saving and deleting the login.
+export * from './vpn.def.js';
+export * from './vpn.run.js';