windows-development-sandbox 1.10.0 → 1.11.4

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

@@ -0,0 +1,220 @@
+// Storage: where the saved data (tools, logins, history, logs) lives, moving it to another folder or switching to one
+// without moving, and contained storage (beta: a disk image). Pure: schemas, labels and the view; storage.run.ts does
+// the work. Sizes come as bytes and as words (the run measures; bytesText formats).
+import { z } from 'zod';
+import { action, bytesText, defineOperation, defineQuery, defineView, } from '../../kernel/index.js';
+import { browseFolder } from '../files/files.def.js';
+const MeasuredSchema = z.object({
+    bytes: z.number().describe('Bytes counted'),
+    files: z.number().describe('Files counted'),
+    partial: z.boolean().describe('The count stopped at its limit: there is at least this much'),
+});
+export const StorageShowSchema = z.object({
+    root: z.string().describe('The folder your saved data is in'),
+    exists: z.boolean().describe('It exists'),
+    holdsData: z.boolean().describe('Something is in it'),
+    measured: MeasuredSchema.nullable().describe('Its size; null when not measured'),
+    size: z.string().describe('Its size in words; "nothing in it yet" when empty; "not measured yet" when not counted'),
+    defaultRoot: z.string().describe('The default folder'),
+    defaultInUse: z.boolean().describe('The default folder is the one in use'),
+    otherFoldersWithData: z.array(z.string()).describe('Other folders that hold data'),
+});
+export const showStorage = defineQuery({
+    id: 'storage.show',
+    title: 'Data folder',
+    summary: 'where your saved data lives',
+    input: z.object({ measure: z.boolean().default(true).describe('add up its size (big folders take a moment)') }),
+    output: StorageShowSchema,
+    text: (o) => [
+        'Your saved data is in: ' + o.root,
+        '  ' + o.size,
+        'The default folder is: ' + o.defaultRoot + (o.defaultInUse ? ' (in use)' : ''),
+        ...o.otherFoldersWithData.map((f) => 'Another folder with data: ' + f),
+        '',
+        'Move it with: sandbox storage move <folder>  (or switch without moving: sandbox storage use <folder>)',
+        'What takes the space: sandbox data',
+    ].join('\n'),
+    cli: {
+        name: 'storage',
+        action: 'show',
+        json: true,
+        // The --json shape `sandbox storage` has always printed.
+        shapeJson: (o) => ({
+            root: o.root,
+            exists: o.exists,
+            ...(o.measured ?? { bytes: 0, files: 0, partial: false }),
+            defaultRoot: o.defaultRoot,
+            otherFoldersWithData: o.otherFoldersWithData,
+        }),
+    },
+});
+const MoveOutputSchema = z.object({
+    from: z.string().describe('The old folder'),
+    to: z.string().describe('The new folder'),
+    copied: z.boolean().describe('It was copied (another drive)'),
+    files: z.number().describe('Files moved'),
+    bytes: z.number().describe('Bytes moved'),
+    pinned: z.string().describe('What storage.root now says'),
+    removedOld: z.boolean().describe('The old folder is gone'),
+    notes: z.array(z.string()).describe('Extra notes'),
+    message: z.string().describe('What happened'),
+});
+export const moveStorage = defineOperation({
+    id: 'storage.move',
+    title: 'Move the data…',
+    summary: 'move your saved data to another folder',
+    input: z.object({
+        folder: z.string().optional().describe('the folder to move to'),
+        keepOld: z.boolean().default(false).describe('copy instead of moving: the old folder stays (needs room for both)'),
+    }),
+    output: MoveOutputSchema,
+    text: (o) => o.message,
+    cli: {
+        name: 'storage',
+        action: 'move',
+        positional: ['folder'],
+        flags: { keepOld: { flag: '--keep-old' } },
+        json: true,
+        shapeJson: ({ message: _message, ...result }) => result,
+    },
+});
+export const useStorage = defineOperation({
+    id: 'storage.use',
+    title: 'Use another folder…',
+    summary: 'use another folder for your saved data, without moving it',
+    input: z.object({ folder: z.string().optional().describe('the folder to use') }),
+    output: z.object({ message: z.string().describe('What happened') }),
+    text: (o) => o.message,
+    cli: { name: 'storage', action: 'use', positional: ['folder'] },
+});
+export const changeDataFolder = defineOperation({
+    id: 'storage.change',
+    title: 'Data folder',
+    summary: 'pick another folder for your saved data, then move it there or switch to it',
+    input: z.object({}),
+    output: z.object({ message: z.string().describe('What happened') }),
+    text: (o) => o.message,
+    surfaces: { except: { cli: 'the command line has storage move <folder> and storage use <folder>' } },
+});
+export const ContainedStatusSchema = z.object({
+    setting: z.enum(['off', 'vhdx']).describe('storage.contained'),
+    maxGb: z.number().describe('storage.containedMaxGb'),
+    available: z.boolean().describe('This PC can use it'),
+    reasons: z.array(z.string()).describe('Why not'),
+    fixes: z.array(z.string()).describe('What would fix it'),
+    image: z.string().describe('The disk image file'),
+    imageExists: z.boolean().describe('It exists'),
+    imageBytes: z.number().nullable().describe('Its size on disk'),
+    mountFolder: z.string().describe('Where it is mounted'),
+    recordedMounted: z.boolean().describe('The record says it is mounted'),
+    holders: z.number().describe('Sandboxes using it'),
+    mountedNow: z.boolean().nullable().describe('It is mounted now (null: not checked)'),
+});
+export const containedStatus = defineQuery({
+    id: 'storage.containedStatus',
+    title: 'Contained storage (beta)',
+    summary: '(beta) the disk image for tools, state and logs',
+    input: z.object({}),
+    output: ContainedStatusSchema,
+    text: (o) => [
+        'Contained storage (beta, untested on a real PC)',
+        '  setting:      storage.contained = ' + o.setting + ' (limit ' + o.maxGb + ' GB)',
+        '  this PC:      ' +
+            (o.available ? 'can use it' : 'cannot use it: ' + o.reasons.join(' ') + ' ' + o.fixes.join(' ')),
+        '  image:        ' +
+            o.image +
+            (o.imageExists ? ' (' + bytesText(o.imageBytes ?? 0) + ' on disk)' : ' (not made yet)'),
+        '  mount folder: ' + o.mountFolder,
+        ...(o.mountedNow === null
+            ? []
+            : [
+                '  mounted now:  ' +
+                    (o.mountedNow ? 'yes' : 'no') +
+                    (o.recordedMounted !== o.mountedNow
+                        ? ' (the record says ' + (o.recordedMounted ? 'yes' : 'no') + '; sandbox doctor looks into it)'
+                        : ''),
+            ]),
+        '',
+        'Turn it on with: sandbox storage contained on   Turn it off with: sandbox storage contained off',
+    ].join('\n'),
+    cli: { name: 'storage', action: 'contained status', json: true, shapeJson: ({ fixes: _fixes, ...rest }) => rest },
+});
+export const containedOn = defineOperation({
+    id: 'storage.containedOn',
+    title: 'Turn contained storage on…',
+    summary: '(beta) keep tools, state and logs in a disk image',
+    input: z.object({}),
+    output: z.object({ message: z.string().describe('What happened') }),
+    text: (o) => o.message,
+    cli: { name: 'storage', action: 'contained on' },
+});
+export const containedOff = defineOperation({
+    id: 'storage.containedOff',
+    title: 'Turn contained storage off…',
+    summary: '(beta) move tools, state and logs back into plain folders',
+    danger: true,
+    input: z.object({}),
+    output: z.object({ message: z.string().describe('What happened') }),
+    text: (o) => o.message,
+    cli: { name: 'storage', action: 'contained off' },
+});
+/** The Storage page: the data folder (change, move, use another), then contained storage (beta). */
+export function storagePage(o, c) {
+    // Move and use another folder are the two ways to change it (the same choice as the Data folder setting).
+    const data = {
+        id: 'folder',
+        title: 'Data folder',
+        description: 'Where your tools, logins, history and logs are kept between sandboxes.',
+        facts: [
+            { id: 'folder', label: 'Folder', value: o.root },
+            { id: 'size', label: 'Size', value: o.size },
+            { id: 'default', label: 'Default folder', value: o.defaultRoot + (o.defaultInUse ? ' (in use)' : '') },
+            ...o.otherFoldersWithData.map((f, i) => ({ id: 'other:' + i, label: 'Other folder with data', value: f })),
+        ],
+        actions: [action(moveStorage, {}), action(useStorage, {})],
+    };
+    const contained = {
+        id: 'contained',
+        title: 'Contained storage (beta)',
+        description: 'Beta, and not yet tested on a real PC: keeps the sandbox tools, state and logs in one disk image file.',
+        facts: [
+            {
+                id: 'setting',
+                label: 'Turned on',
+                value: c.setting === 'vhdx' ? 'yes' : 'no',
+                tone: c.setting === 'vhdx' ? 'ok' : 'muted',
+            },
+            {
+                id: 'pc',
+                label: 'This PC',
+                value: c.available ? 'can use it' : 'cannot use it',
+                tone: c.available ? 'ok' : 'warn',
+                ...(c.available ? {} : { description: [...c.reasons, ...c.fixes].join(' ') }),
+            },
+            {
+                id: 'image',
+                label: 'Image',
+                value: c.imageExists ? bytesText(c.imageBytes ?? 0) + ' on disk' : 'not made yet',
+                description: c.image,
+            },
+            { id: 'mount', label: 'Mount folder', value: c.mountFolder },
+            {
+                id: 'mounted',
+                label: 'Mounted now',
+                value: c.mountedNow === null ? 'not checked' : c.mountedNow ? 'yes' : 'no',
+            },
+        ],
+        actions: c.setting === 'off' ? [action(containedOn, {})] : [action(containedOff, {})],
+    };
+    return { title: 'Storage', sections: [data, contained] };
+}
+export const storageView = defineView({
+    id: 'storage',
+    title: 'Storage',
+    summary: 'Where your saved data lives: move it, switch folders, (beta) a disk image.',
+    queries: { storage: showStorage, contained: containedStatus },
+    operations: [changeDataFolder, moveStorage, useStorage, containedOn, containedOff],
+    pickers: [browseFolder],
+    inputs: () => ({ storage: { measure: true } }),
+    build: ({ storage, contained }) => storagePage(storage, contained),
+});

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

@@ -0,0 +1,62 @@
+import { type Context } from '../../../cli/commands/context.js';
+export declare const showStorageRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").QueryDef<import("zod").ZodObject<{
+    measure: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    root: import("zod").ZodString;
+    exists: import("zod").ZodBoolean;
+    holdsData: import("zod").ZodBoolean;
+    measured: import("zod").ZodNullable<import("zod").ZodObject<{
+        bytes: import("zod").ZodNumber;
+        files: import("zod").ZodNumber;
+        partial: import("zod").ZodBoolean;
+    }, import("zod/v4/core").$strip>>;
+    size: import("zod").ZodString;
+    defaultRoot: import("zod").ZodString;
+    defaultInUse: import("zod").ZodBoolean;
+    otherFoldersWithData: import("zod").ZodArray<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, "storage.show">, Context>;
+export declare const moveStorageRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{
+    folder: import("zod").ZodOptional<import("zod").ZodString>;
+    keepOld: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    from: import("zod").ZodString;
+    to: import("zod").ZodString;
+    copied: import("zod").ZodBoolean;
+    files: import("zod").ZodNumber;
+    bytes: import("zod").ZodNumber;
+    pinned: import("zod").ZodString;
+    removedOld: import("zod").ZodBoolean;
+    notes: import("zod").ZodArray<import("zod").ZodString>;
+    message: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, "storage.move">, Context>;
+export declare const useStorageRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{
+    folder: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    message: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, "storage.use">, Context>;
+export declare const changeDataFolderRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    message: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, "storage.change">, Context>;
+export declare const containedStatusRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").QueryDef<import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    setting: import("zod").ZodEnum<{
+        off: "off";
+        vhdx: "vhdx";
+    }>;
+    maxGb: import("zod").ZodNumber;
+    available: import("zod").ZodBoolean;
+    reasons: import("zod").ZodArray<import("zod").ZodString>;
+    fixes: import("zod").ZodArray<import("zod").ZodString>;
+    image: import("zod").ZodString;
+    imageExists: import("zod").ZodBoolean;
+    imageBytes: import("zod").ZodNullable<import("zod").ZodNumber>;
+    mountFolder: import("zod").ZodString;
+    recordedMounted: import("zod").ZodBoolean;
+    holders: import("zod").ZodNumber;
+    mountedNow: import("zod").ZodNullable<import("zod").ZodBoolean>;
+}, import("zod/v4/core").$strip>, "storage.containedStatus">, Context>;
+export declare const containedOnRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    message: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, "storage.containedOn">, Context>;
+export declare const containedOffRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    message: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, "storage.containedOff">, Context>;

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

@@ -0,0 +1,370 @@
+// The storage area's work: where the saved data is, moving it (size, time and a warning first) or switching folders,
+// and contained storage (beta: the disk image, which Windows asks permission to mount). Talks only through io.
+// Every run is on this PC only (requireOnPc). The web's folder picker gives full paths. A relative path typed on the
+// web is resolved against the web server's folder (as the command line does against the current folder); the move
+// and switch questions then show the full path before anything changes, so the person still sees where it goes.
+import fs from 'node:fs';
+import path from 'node:path';
+import { userConfigPath, userDir } from '../../../core/config/index.js';
+import { humanBytes } from '../../../core/disk.js';
+import { expandPath, fail } from '../../../core/util/index.js';
+import { requireOnPc } from '../../../cli/commands/context.js';
+import { StorageService } from '../../../cli/services/index.js';
+import { isSandboxRunning, realContainedDeps } from '../../../host/sandbox/index.js';
+import { assertTargetsFree, containedAvailability, ContainedStorage, describeDuration, describeSize, estimate, holdsData, measureFolder, moveProblem, moveWarning, otherDataFolders, planTransfer, runTransfer, setStateOf, sharedDefaultRoot, StateFile, StorageHistory, writeContainedSetting, } from '../../../host/storage/index.js';
+import { implement } from '../../context.js';
+import { cancelled } from '../../kernel/index.js';
+import { changeDataFolder, containedOff, containedOn, containedStatus, moveStorage, showStorage, useStorage, } from './storage.def.js';
+const BETA = 'Beta, and not yet tested on a real PC. ';
+/** The menu's change of folder measures for at most this long (the size then reads "at least"). */
+const MEASURE_MS = 8000;
+const NO_TERMINAL = 'Cannot ask here (no terminal).';
+function requireAvailable() {
+    const check = containedAvailability();
+    if (!check.available)
+        fail('Contained storage cannot be used: ' + check.reasons.join(' '), check.fixes.join(' '));
+}
+function requireNoSandbox() {
+    if (isSandboxRunning())
+        fail('A sandbox is running.', 'Close it (sandbox stop) first: the folders in the image are in use.');
+}
+function storageFor(ctx) {
+    const { config } = ctx.loaded;
+    return new ContainedStorage(realContainedDeps(ctx.storageRoot, config.storage.containedMaxGb), config.storage.dataName);
+}
+/** The folder a move or a switch goes to: picked from the known folders, or typed (expanded like the command line). */
+async function chooseFolder(io, service, what, cancelMessage) {
+    const typed = '@type';
+    const fix = 'Use: sandbox storage ' + what + ' <folder>';
+    const picked = await io.choose({
+        title: 'Which folder?',
+        choices: [
+            ...service.knownFolders().map((f) => ({ value: f, label: f })),
+            { value: typed, label: 'Type a path...' },
+        ],
+        noTerminal: { message: NO_TERMINAL, fix },
+    });
+    if (picked === undefined)
+        cancelled(cancelMessage);
+    if (picked !== typed)
+        return picked;
+    const answer = await io.path({
+        title: 'Folder:',
+        pathKind: 'dir',
+        validate: (v) => v.length > 0 || 'Type a folder path.',
+        noTerminal: { message: NO_TERMINAL, fix },
+    });
+    if (answer === undefined)
+        cancelled(cancelMessage);
+    return expandPath(answer, process.cwd());
+}
+/**
+ * Moves the data to `to`: the plan is written out first (size, time, a warning, room on the drive). Asks first when
+ * `ask` (the command asks, the menu has asked already). Returns the move's result with its message.
+ */
+async function moveData(io, service, from, to, keepOld, ask) {
+    service.validate(to);
+    io.progress('Measuring your saved data');
+    const measured = measureFolder(from);
+    const est = estimate(from, to, measured, keepOld);
+    const time = est.sameVolume
+        ? 'a few seconds (same drive, nothing is copied)'
+        : describeDuration(est.seconds) + ' (copied to another drive)';
+    io.log('Move from: ' + from);
+    io.log('       to: ' + to);
+    io.log('     size: ' + describeSize(measured));
+    io.log('     time: ' + time);
+    const warning = moveWarning(measured, est);
+    if (warning)
+        io.log('Warning: ' + warning, 'warn');
+    if (!est.fits)
+        fail('Not enough free space on the target drive.', 'Free some space or pick another drive.');
+    if (ask) {
+        const yes = await io.confirm({
+            title: 'Move your data to ' + to + '?',
+            yes: 'Move',
+            noTerminal: { message: NO_TERMINAL, fix: 'Add --yes to move without asking.' },
+        });
+        if (!yes)
+            cancelled('Nothing was moved.');
+    }
+    io.progress('Moving your data');
+    const result = await service.move(to, keepOld, (p) => io.progress('Copying: ' + p.files.toLocaleString('en-US') + ' files, ' + humanBytes(p.bytes)));
+    for (const note of result.notes)
+        io.log(note);
+    io.log('Your settings now point to ' + result.pinned + ', so older versions find the data too.');
+    const left = result.removedOld ? '' : '; the old folder is still at ' + result.from;
+    return {
+        ...result,
+        notes: [...result.notes],
+        message: 'Moved ' + result.files.toLocaleString('en-US') + ' files. Your data is now in ' + result.to + left + '.',
+    };
+}
+/** Looks for the data in `to` from now on, without moving it. Asks first when `ask`. Returns the message. */
+async function useData(io, service, from, to, ask) {
+    // A relative folder would be pinned as it is (and resolved against another folder later): refuse it.
+    if (!path.isAbsolute(to))
+        fail(to + ' is not a full path.', 'Give a path like D:\\Sandbox.');
+    const busy = service.busy();
+    if (busy)
+        fail(busy, 'Wait a minute, then try again.');
+    const state = holdsData(to)
+        ? to + ' is used as it is.'
+        : to + ' starts empty: tools, logins and history are set up again.';
+    io.log('Warning: your data stays in ' + from + '. ' + state, 'warn');
+    if (ask) {
+        const yes = await io.confirm({
+            title: 'Use ' + to + ' from now on, without moving your data?',
+            yes: 'Use',
+            noTerminal: { message: NO_TERMINAL, fix: 'Add --yes to switch without asking.' },
+        });
+        if (!yes)
+            cancelled('Nothing was changed.');
+    }
+    service.use(to);
+    return 'Your data is now looked for in ' + to + '. Move it later with: sandbox storage move <folder>';
+}
+export const showStorageRun = implement(showStorage, async (ctx, input, io) => {
+    requireOnPc('storage');
+    const root = ctx.storageRoot;
+    if (input.measure)
+        io.progress('Measuring your saved data (big folders take a moment)');
+    const measured = input.measure ? measureFolder(root) : null;
+    const has = holdsData(root);
+    const shared = sharedDefaultRoot();
+    const size = !has ? 'nothing in it yet' : measured ? describeSize(measured) : 'not measured yet';
+    const answer = {
+        root,
+        exists: fs.existsSync(root),
+        holdsData: has,
+        measured: measured ? { bytes: measured.bytes, files: measured.files, partial: measured.partial } : null,
+        size,
+        defaultRoot: shared,
+        defaultInUse: shared.toLowerCase() === root.toLowerCase(),
+        otherFoldersWithData: otherDataFolders(root, new StorageHistory(userDir())),
+    };
+    return answer;
+});
+export const moveStorageRun = implement(moveStorage, async (ctx, input, io) => {
+    requireOnPc('storage');
+    const service = new StorageService(ctx);
+    const from = ctx.storageRoot;
+    const to = input.folder
+        ? expandPath(input.folder, process.cwd())
+        : await chooseFolder(io, service, 'move', 'Nothing was moved.');
+    if (!fs.existsSync(from))
+        fail('There is nothing to move: ' + from + ' does not exist.', 'Use sandbox storage use ' + to + ' to switch.');
+    return moveData(io, service, from, to, input.keepOld, true);
+});
+export const useStorageRun = implement(useStorage, async (ctx, input, io) => {
+    requireOnPc('storage');
+    const service = new StorageService(ctx);
+    const to = input.folder
+        ? expandPath(input.folder, process.cwd())
+        : await chooseFolder(io, service, 'use', 'Nothing was changed.');
+    if (to.toLowerCase() === ctx.storageRoot.toLowerCase())
+        return { message: 'That folder is in use already.' };
+    return { message: await useData(io, service, ctx.storageRoot, to, true) };
+});
+export const changeDataFolderRun = implement(changeDataFolder, async (ctx, _input, io) => {
+    requireOnPc('storage');
+    const service = new StorageService(ctx);
+    const from = ctx.storageRoot;
+    const exists = fs.existsSync(from);
+    if (exists)
+        io.progress('Measuring your saved data');
+    const measured = exists ? measureFolder(from, MEASURE_MS) : { bytes: 0, files: 0, partial: false };
+    const size = exists && holdsData(from) ? describeSize(measured) : 'nothing in it yet';
+    const to = await io.path({
+        title: 'Choose the folder for your saved data',
+        lines: [
+            'Now: ' + from + ' (' + size + ').',
+            'Pick a new or empty folder to move your data there, or a folder that already holds data to use it.',
+        ],
+        pathKind: 'dir',
+        initial: from.replace(/[\\/][^\\/]*$/, '\\'),
+        validate: (picked) => moveProblem(from, picked, true)?.message ?? true,
+    });
+    if (to === undefined || path.resolve(to).toLowerCase() === path.resolve(from).toLowerCase())
+        cancelled();
+    // The folder is stored as a full, normalised path (no trailing separator or `..` left in storage.root).
+    const dest = path.resolve(to);
+    const target = holdsData(dest);
+    const lines = [];
+    let canMove = exists && holdsData(from) && !target;
+    if (canMove) {
+        const est = estimate(from, dest, measured);
+        lines.push('From: ' + from, 'To:   ' + dest, 'Size: ' + describeSize(measured));
+        lines.push(est.sameVolume
+            ? 'Time: a few seconds (same drive, nothing is copied)'
+            : 'Time: ' + describeDuration(est.seconds) + ' (copied to another drive)');
+        if (est.freeBytes !== null)
+            lines.push('Free space on the target drive: ' + humanBytes(est.freeBytes));
+        const warning = moveWarning(measured, est);
+        if (warning)
+            lines.push('', warning);
+        if (!est.fits)
+            canMove = false;
+    }
+    else
+        lines.push(target ? dest + ' already holds data, so it is used as it is.' : 'There is nothing in ' + from + ' to move.', 'Your data stays where it is.');
+    lines.push('', 'Use without moving: the new folder is used from now on and your old data is left behind.');
+    const choice = await io.choose({
+        title: canMove ? 'Move your data to ' + dest + '?' : 'Use ' + dest + '?',
+        lines,
+        choices: [
+            ...(canMove ? [{ value: 'move', label: 'Move data' }] : []),
+            { value: 'use', label: 'Switch without moving' },
+            { value: 'cancel', label: 'Cancel' },
+        ],
+    });
+    if (choice === 'move')
+        return { message: (await moveData(io, service, from, dest, false, false)).message };
+    if (choice === 'use')
+        return { message: await useData(io, service, from, dest, false) };
+    return cancelled();
+});
+export const containedStatusRun = implement(containedStatus, async (ctx) => {
+    requireOnPc('storage');
+    const storage = storageFor(ctx);
+    const check = containedAvailability();
+    const record = setStateOf(new StateFile(storage.paths).read(), storage.set);
+    const reality = check.available && storage.imageExists() ? await storage.reality() : null;
+    return {
+        setting: ctx.loaded.config.storage.contained,
+        maxGb: ctx.loaded.config.storage.containedMaxGb,
+        available: check.available,
+        reasons: [...check.reasons],
+        fixes: [...check.fixes],
+        image: storage.paths.image,
+        imageExists: storage.imageExists(),
+        imageBytes: reality?.imageBytes ?? null,
+        mountFolder: storage.paths.mount,
+        recordedMounted: record.mounted,
+        holders: record.holders.length,
+        mountedNow: reality?.mountIsMountPoint ?? null,
+    };
+});
+/** Writes the plan's sizes and time as lines; a plan that does not fit stops here. */
+function planLines(io, plan, to) {
+    for (const f of plan.folders)
+        io.log('  ' + f.name + ': ' + describeSize(f.measured));
+    io.log('  total: ' + describeSize(plan.total) + ' to ' + to);
+    io.log('  time:  about ' + describeDuration(plan.estimate.seconds) + ' (copied, then the originals are removed)');
+    if (!plan.estimate.fits)
+        fail('Not enough free space for the copy.', 'Free some space on that drive and try again.');
+}
+export const containedOnRun = implement(containedOn, async (ctx, _input, io) => {
+    requireOnPc('storage');
+    requireAvailable();
+    requireNoSandbox();
+    const storage = storageFor(ctx);
+    const { config } = ctx.loaded;
+    const configFile = ctx.loaded.configPath ?? userConfigPath();
+    io.log(BETA + 'Contained storage keeps the sandbox tools, state and logs in one disk image file.', 'warn');
+    io.log('  image:  ' + storage.paths.image + (storage.imageExists() ? ' (exists, it is used as it is)' : ''));
+    io.log('  limit:  ' + config.storage.containedMaxGb + ' GB (storage.containedMaxGb; the file grows only as it fills)');
+    io.log('  Windows asks for permission to mount it each time a sandbox starts (and once when it closes).');
+    const turnOn = await io.confirm({
+        title: 'Turn contained storage on?',
+        yes: 'Turn on',
+        noTerminal: { message: NO_TERMINAL, fix: 'Add --yes to turn it on without asking.' },
+    });
+    if (!turnOn)
+        fail('Nothing was changed.', 'Run sandbox storage contained on when you want it.');
+    io.progress('Making and mounting the image (Windows asks for permission)');
+    const mount = await storage.acquire({ id: 'cli', pid: process.pid }, { create: true });
+    try {
+        const plan = planTransfer(ctx.dataPath, mount, ctx.storageRoot);
+        if (plan.folders.length > 0) {
+            io.log('These folders hold your tools, state and logs now:');
+            planLines(io, plan, 'the image');
+            assertTargetsFree(plan);
+            const move = await io.confirm({
+                title: 'Move them into the image?',
+                yes: 'Move',
+                noTerminal: { message: NO_TERMINAL, fix: 'Add --yes to move without asking.' },
+            });
+            if (move) {
+                io.progress('Copying');
+                const result = await runTransfer(plan, ctx.dataPath, (p) => io.progress('Copying: ' + p.files.toLocaleString('en-US') + ' files, ' + humanBytes(p.bytes)));
+                io.log('Moved ' + result.files.toLocaleString('en-US') + ' files into the image.');
+                for (const note of result.notes)
+                    io.log(note, 'warn');
+            }
+            else
+                io.log('They stay where they are and are not used: tools are downloaded again into the image. Delete them later with sandbox data clean.');
+        }
+        writeContainedSetting(configFile, 'vhdx');
+    }
+    finally {
+        io.progress('Dismounting the image (Windows asks for permission)');
+        const done = await storage.release('cli');
+        if (!done.dismounted)
+            io.log('The image stays mounted (' + (done.note ?? '') + '). sandbox repair dismounts it.', 'warn');
+    }
+    return { message: 'Contained storage is on. sandbox launch mounts the image first.' };
+});
+export const containedOffRun = implement(containedOff, async (ctx, _input, io) => {
+    requireOnPc('storage');
+    requireAvailable();
+    requireNoSandbox();
+    const storage = storageFor(ctx);
+    const configFile = ctx.loaded.configPath ?? userConfigPath();
+    io.log(BETA + 'Turning contained storage off moves the files back into plain folders.', 'warn');
+    if (!storage.imageExists()) {
+        writeContainedSetting(configFile, 'off');
+        return { message: 'There is no image, so there was nothing to move. Contained storage is off.' };
+    }
+    io.progress('Mounting the image (Windows asks for permission)');
+    const mount = await storage.acquire({ id: 'cli', pid: process.pid });
+    let moved = false;
+    try {
+        const plan = planTransfer(mount, ctx.dataPath, ctx.dataPath);
+        if (plan.folders.length > 0) {
+            io.log('In the image:');
+            planLines(io, plan, ctx.dataPath);
+            assertTargetsFree(plan);
+            const back = await io.confirm({
+                title: 'Move them back out of the image?',
+                yes: 'Move',
+                noTerminal: { message: NO_TERMINAL, fix: 'Add --yes to move without asking.' },
+            });
+            if (!back)
+                fail('Nothing was moved.', 'Contained storage is still on.');
+            io.progress('Copying');
+            const result = await runTransfer(plan, mount, (p) => io.progress('Copying: ' + p.files.toLocaleString('en-US') + ' files, ' + humanBytes(p.bytes)));
+            io.log('Moved ' + result.files.toLocaleString('en-US') + ' files back.');
+            for (const note of result.notes)
+                io.log(note, 'warn');
+        }
+        writeContainedSetting(configFile, 'off');
+        moved = true;
+    }
+    finally {
+        io.progress('Dismounting the image (Windows asks for permission)');
+        const done = await storage.release('cli');
+        if (!done.dismounted)
+            io.log('The image stays mounted (' + (done.note ?? '') + '). sandbox repair dismounts it.', 'warn');
+        else if (!moved)
+            io.log('The image was dismounted; contained storage is still on.');
+    }
+    // The image is removed only when the person says so; a command line with --yes keeps it (skipWithYes).
+    const bytes = fs.statSync(storage.paths.image).size;
+    const remove = await io.confirm({
+        title: 'Delete the image file now (' + humanBytes(bytes) + ')? Everything in it was moved out.',
+        yes: 'Delete',
+        danger: true,
+        skipWithYes: true,
+        noTerminal: { message: NO_TERMINAL, fix: 'Answer no to keep it.' },
+    });
+    if (remove) {
+        await storage.deleteImage();
+        io.log('Deleted ' + storage.paths.image + '.');
+    }
+    else
+        io.log('The image file is kept: ' + storage.paths.image + ' (delete it yourself when you are sure).');
+    return {
+        message: 'Contained storage is off: tools, state and logs are plain folders in ' + ctx.dataPath + '.',
+    };
+});

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

@@ -0,0 +1,3 @@
+export * from './updates.def.js';
+export * from './updates.run.js';
+export * from './update-lines.js';

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

@@ -0,0 +1,4 @@
+// The updates area: the program's own updates and your saved settings brought up to date.
+export * from './updates.def.js';
+export * from './updates.run.js';
+export * from './update-lines.js';