windows-development-sandbox 1.10.0 → 1.11.4

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

@@ -0,0 +1,76 @@
+// The apps feature's work: the rows of a scope, an app switched on or off, your own programs saved, and the request
+// page opened in this PC's browser. Writes go through ConfigFile like the settings do (comments kept, nothing written
+// unless the file stays valid).
+import { APPS } from '../../../shared/apps/index.js';
+import { errMsg, fail } from '../../../core/util/index.js';
+import { openIssuePage } from '../../../host/web/index.js';
+import { implement } from '../../context.js';
+import { allowedText, fieldOf, valueFromText } from '../../kernel/index.js';
+import { settingsFiles } from '../settings/settings.run.js';
+import { appRows, customRows, CUSTOM_KEY, INSTALL, SAVED } from './apps-rows.js';
+import { listApps, requestApp, requestAppUrl, setCustomApps, toggleApp } from './apps.def.js';
+export const listAppsRun = implement(listApps, (ctx, input) => {
+    const file = settingsFiles(ctx)[input.scope];
+    const own = input.scope === 'user';
+    const node = own ? file.schema.child('apps')?.child('custom') : undefined;
+    return {
+        scope: input.scope,
+        file: file.file,
+        exists: file.exists,
+        apps: appRows(file, ctx.dataPath),
+        custom: own ? customRows(file) : [],
+        ...(own ? { customValue: SAVED.custom(file) } : {}),
+        ...(node ? { customField: fieldOf(node, CUSTOM_KEY, 'Your own programs') } : {}),
+    };
+});
+export const toggleAppRun = implement(toggleApp, (ctx, input) => {
+    const file = settingsFiles(ctx)[input.scope];
+    const entry = APPS.find((a) => a.id === input.id);
+    if (!entry || (file.isProject && entry.setting))
+        fail('"' + input.id + '" is not an app this scope can change.', 'Pick one of the apps the Apps page lists.');
+    const name = entry.name;
+    // A setting-backed app (VS Code, Windows Terminal) is its setting; a catalogue app is one id in apps.install.
+    const key = entry.setting ? entry.setting.split('.') : INSTALL;
+    let value = input.on;
+    if (!entry.setting) {
+        const current = SAVED.install(file) ?? [];
+        const next = input.on
+            ? current.includes(entry.id)
+                ? current
+                : [...current, entry.id]
+            : current.filter((id) => id !== entry.id);
+        // Your own file keeps no empty list (back to the default); a project file always says what it chooses.
+        value = next.length || file.isProject ? next : undefined;
+    }
+    const outcome = file.set(key, value);
+    if (typeof outcome === 'object')
+        fail('Could not change ' + key.join('.') + ': ' + outcome.problems.join('; '), 'Nothing was written.');
+    const said = input.on ? name + ' is installed in every sandbox.' : name + ' is no longer installed.';
+    return { message: said + (outcome === 'unchanged' ? ' (it was already)' : '') };
+});
+export const setCustomAppsRun = implement(setCustomApps, (ctx, input) => {
+    if (input.scope === 'project')
+        fail('Your own programs are set in your own settings only.', 'Switch to All projects.');
+    const file = settingsFiles(ctx).user;
+    const node = file.schema.child('apps')?.child('custom');
+    if (!node)
+        fail('Your own programs are not a setting of this version.', 'Update sandbox, then try again.');
+    const value = typeof input.value === 'string' ? valueFromText(node, input.value) : input.value;
+    const problem = node.check(value);
+    if (problem !== true)
+        fail('That does not work for apps.custom: ' + problem, allowedText(node));
+    const outcome = file.set(CUSTOM_KEY, value);
+    if (typeof outcome === 'object')
+        fail('Could not change apps.custom: ' + outcome.problems.join('; '), 'Nothing was written.');
+    return { message: 'Your own programs are saved.' };
+});
+export const requestAppRun = implement(requestApp, () => {
+    const url = requestAppUrl();
+    try {
+        openIssuePage(url);
+    }
+    catch (e) {
+        fail(errMsg(e), 'Open it yourself: ' + url);
+    }
+    return { url };
+});

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

@@ -0,0 +1,3 @@
+export * from './apps.def.js';
+export * from './apps.run.js';
+export * from './apps-rows.js';

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

@@ -0,0 +1,4 @@
+// The apps feature: the catalogue of apps every sandbox installs (all projects or this project) and your own programs.
+export * from './apps.def.js';
+export * from './apps.run.js';
+export * from './apps-rows.js';

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

@@ -0,0 +1,154 @@
+import { z } from 'zod';
+import { type Page } from '../../kernel/index.js';
+export declare const DATA_AREAS: readonly ["tools", "databases", "state", "logs", "data", "host"];
+export type DataAreaName = (typeof DATA_AREAS)[number];
+/** The heading of each area's section (the CLI's group labels). */
+export declare const AREA_LABEL: Readonly<Record<DataAreaName, string>>;
+declare const DataEntrySchema: z.ZodObject<{
+    area: z.ZodEnum<{
+        host: "host";
+        tools: "tools";
+        databases: "databases";
+        state: "state";
+        data: "data";
+        logs: "logs";
+    }>;
+    name: z.ZodString;
+    path: z.ZodString;
+    bytes: z.ZodNumber;
+    size: z.ZodString;
+    target: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+declare const DiskSchema: z.ZodObject<{
+    drive: z.ZodString;
+    totalBytes: z.ZodNumber;
+    freeBytes: z.ZodNumber;
+    usedBytes: z.ZodNumber;
+    holdsStorage: z.ZodBoolean;
+    used: z.ZodString;
+    usedPercent: z.ZodNumber;
+    free: z.ZodString;
+    total: z.ZodString;
+}, z.core.$strip>;
+export declare const DataShowSchema: z.ZodObject<{
+    dataPath: z.ZodString;
+    storageRoot: z.ZodString;
+    totalBytes: z.ZodNumber;
+    total: z.ZodString;
+    storageShare: z.ZodString;
+    areaTotals: z.ZodRecord<z.ZodString, z.ZodString>;
+    entries: z.ZodArray<z.ZodObject<{
+        area: z.ZodEnum<{
+            host: "host";
+            tools: "tools";
+            databases: "databases";
+            state: "state";
+            data: "data";
+            logs: "logs";
+        }>;
+        name: z.ZodString;
+        path: z.ZodString;
+        bytes: z.ZodNumber;
+        size: z.ZodString;
+        target: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    disks: z.ZodArray<z.ZodObject<{
+        drive: z.ZodString;
+        totalBytes: z.ZodNumber;
+        freeBytes: z.ZodNumber;
+        usedBytes: z.ZodNumber;
+        holdsStorage: z.ZodBoolean;
+        used: z.ZodString;
+        usedPercent: z.ZodNumber;
+        free: z.ZodString;
+        total: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type DataShow = z.output<typeof DataShowSchema>;
+export type DataEntryRow = z.output<typeof DataEntrySchema>;
+export type DataDisk = z.output<typeof DiskSchema>;
+export declare const showData: import("../../kernel/define.js").QueryDef<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+    dataPath: z.ZodString;
+    storageRoot: z.ZodString;
+    totalBytes: z.ZodNumber;
+    total: z.ZodString;
+    storageShare: z.ZodString;
+    areaTotals: z.ZodRecord<z.ZodString, z.ZodString>;
+    entries: z.ZodArray<z.ZodObject<{
+        area: z.ZodEnum<{
+            host: "host";
+            tools: "tools";
+            databases: "databases";
+            state: "state";
+            data: "data";
+            logs: "logs";
+        }>;
+        name: z.ZodString;
+        path: z.ZodString;
+        bytes: z.ZodNumber;
+        size: z.ZodString;
+        target: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    disks: z.ZodArray<z.ZodObject<{
+        drive: z.ZodString;
+        totalBytes: z.ZodNumber;
+        freeBytes: z.ZodNumber;
+        usedBytes: z.ZodNumber;
+        holdsStorage: z.ZodBoolean;
+        used: z.ZodString;
+        usedPercent: z.ZodNumber;
+        free: z.ZodString;
+        total: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>, "data.show">;
+export declare const cleanData: import("../../kernel/define.js").OperationDef<z.ZodObject<{
+    targets: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    message: z.ZodString;
+    freedBytes: z.ZodNumber;
+}, z.core.$strip>, "data.clean">;
+export declare const pruneStorage: import("../../kernel/define.js").OperationDef<z.ZodObject<{
+    days: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    message: z.ZodString;
+    removed: z.ZodBoolean;
+}, z.core.$strip>, "data.prune">;
+/** The data page: the disks, then every kept folder in one table (its total as the summary, clean-up as its action). */
+export declare function dataPage(o: DataShow): Page;
+export declare const dataView: import("../../kernel/define.js").ViewDef<{
+    data: import("../../kernel/define.js").QueryDef<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+        dataPath: z.ZodString;
+        storageRoot: z.ZodString;
+        totalBytes: z.ZodNumber;
+        total: z.ZodString;
+        storageShare: z.ZodString;
+        areaTotals: z.ZodRecord<z.ZodString, z.ZodString>;
+        entries: z.ZodArray<z.ZodObject<{
+            area: z.ZodEnum<{
+                host: "host";
+                tools: "tools";
+                databases: "databases";
+                state: "state";
+                data: "data";
+                logs: "logs";
+            }>;
+            name: z.ZodString;
+            path: z.ZodString;
+            bytes: z.ZodNumber;
+            size: z.ZodString;
+            target: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        disks: z.ZodArray<z.ZodObject<{
+            drive: z.ZodString;
+            totalBytes: z.ZodNumber;
+            freeBytes: z.ZodNumber;
+            usedBytes: z.ZodNumber;
+            holdsStorage: z.ZodBoolean;
+            used: z.ZodString;
+            usedPercent: z.ZodNumber;
+            free: z.ZodString;
+            total: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, "data.show">;
+}, Record<string, never>, "data">;
+export {};

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

@@ -0,0 +1,194 @@
+// The data area: what the sandbox keeps between runs (toolchains, databases, agent state, logs, what this PC keeps for
+// it), deleting chosen parts of it, and the clean-up of old launch folders. Pure: the page builder is here, the work is
+// in data.run.ts. Sizes come as bytes and as words (the run formats them: this file cannot import core/disk).
+import { z } from 'zod';
+import { action, defineOperation, defineQuery, defineView, fieldOf, SchemaNode, } from '../../kernel/index.js';
+export const DATA_AREAS = ['tools', 'databases', 'state', 'logs', 'data', 'host'];
+/** The heading of each area's section (the CLI's group labels). */
+export const AREA_LABEL = {
+    tools: 'Toolchains',
+    databases: 'Databases',
+    state: 'Agent state',
+    logs: 'Logs',
+    data: 'Other',
+    host: 'On this PC',
+};
+const DataEntrySchema = z.object({
+    area: z.enum(DATA_AREAS).describe('Which kind of data it is'),
+    name: z.string().describe('The folder as listed (tools: its name; others: area/name)'),
+    path: z.string().describe('Its full path on this PC'),
+    bytes: z.number().describe('Its size in bytes (links count 0)'),
+    size: z.string().describe('Its size in words, e.g. 1.5 KB'),
+    target: z.string().nullable().describe('What sandbox data clean calls it; null when it is kept on purpose'),
+});
+const DiskSchema = z.object({
+    drive: z.string().describe('The drive, e.g. C:\\'),
+    totalBytes: z.number().describe('Its size in bytes'),
+    freeBytes: z.number().describe('Free bytes'),
+    usedBytes: z.number().describe('Used bytes'),
+    holdsStorage: z.boolean().describe('The sandbox keeps its files on this drive'),
+    used: z.string().describe('Used, in words'),
+    usedPercent: z.number().describe('Used, in percent of the size (rounded)'),
+    free: z.string().describe('Free, in words'),
+    total: z.string().describe('Size, in words'),
+});
+export const DataShowSchema = z.object({
+    dataPath: z.string().describe('The data folder (C:\\AgentData inside the sandbox)'),
+    storageRoot: z.string().describe('The storage folder that holds it'),
+    totalBytes: z.number().describe('Everything listed, in bytes'),
+    total: z.string().describe('Everything listed, in words'),
+    storageShare: z.string().describe('"<- sandbox storage (<total> of it)": the note on the storage drive'),
+    areaTotals: z.record(z.string(), z.string()).describe("Each area's total in words"),
+    entries: z.array(DataEntrySchema).describe('What is stored, by area, biggest first'),
+    disks: z.array(DiskSchema).describe("This PC's drives"),
+});
+export const showData = defineQuery({
+    id: 'data.show',
+    title: 'Stored data',
+    summary: 'show what is kept between sandboxes (tools, databases, logins, logs), or delete some of it',
+    input: z.object({}),
+    output: DataShowSchema,
+    cli: {
+        name: 'data',
+        action: 'show',
+        json: true,
+        // The --json shape `sandbox data` has always printed.
+        shapeJson: (o) => ({
+            dataPath: o.dataPath,
+            storageRoot: o.storageRoot,
+            totalBytes: o.totalBytes,
+            entries: o.entries.map(({ area, name, path, bytes }) => ({ area, name, path, bytes })),
+            disks: o.disks.map(({ drive, totalBytes, freeBytes, usedBytes, holdsStorage }) => ({
+                drive,
+                totalBytes,
+                freeBytes,
+                usedBytes,
+                holdsStorage,
+            })),
+        }),
+    },
+});
+const MessageSchema = z.object({ message: z.string().describe('What happened') });
+export const cleanData = defineOperation({
+    id: 'data.clean',
+    title: 'Delete stored data…',
+    summary: 'delete chosen parts of what is kept between sandboxes',
+    input: z.object({
+        targets: z.array(z.string()).default([]).describe('what to clean, e.g. tools/go databases logs'),
+    }),
+    output: MessageSchema.extend({
+        freedBytes: z.number().describe('Bytes freed (0 when nothing was removed)'),
+    }),
+    danger: true,
+    text: (o) => o.message,
+    next: (o) => (o.freedBytes > 0 ? 'sandbox data   (see what is left)' : undefined),
+    cli: { name: 'data', action: 'clean', positional: ['targets'] },
+});
+const PruneInputSchema = z.object({
+    days: z.number().int().min(1).default(7).describe('launch folders older than this many days'),
+});
+export const pruneStorage = defineOperation({
+    id: 'data.prune',
+    title: 'Clean up…',
+    summary: 'delete old launch folders, logs and leftovers',
+    input: PruneInputSchema,
+    output: MessageSchema.extend({ removed: z.boolean().describe('Something was deleted') }),
+    text: (o) => o.message,
+    next: (o) => (o.removed ? 'sandbox data   (see what else is saved, and clean it)' : undefined),
+    cli: {
+        name: 'clean',
+        group: 'Data',
+        flags: { days: { flag: '--days', value: 'n' } },
+        yes: 'do not ask before deleting',
+    },
+});
+const DAYS_FIELD = fieldOf(new SchemaNode(PruneInputSchema).child('days'), ['days']);
+/** The data page: the disks, then every kept folder in one table (its total as the summary, clean-up as its action). */
+export function dataPage(o) {
+    const disks = {
+        id: 'disks',
+        title: 'Disks',
+        columns: [
+            { key: 'drive', label: 'DRIVE' },
+            { key: 'used', label: 'USED' },
+            { key: 'free', label: 'FREE' },
+            { key: 'size', label: 'SIZE' },
+            { key: 'note', label: '' },
+        ],
+        // The web shows each drive as a row (a table with the storage note does not fit a phone); the CLI keeps the table.
+        columnsOn: 'cli',
+        items: o.disks.map((d) => ({
+            id: 'disk:' + d.drive,
+            label: d.drive,
+            hint: d.used + ' used · ' + d.free + ' free of ' + d.total, // the menu's wording
+            ...(d.holdsStorage ? { description: 'The sandbox keeps its files on this drive.' } : {}),
+            cells: {
+                drive: d.drive,
+                used: d.used + ' (' + d.usedPercent + '%)',
+                free: d.free,
+                size: d.total,
+                note: d.holdsStorage ? o.storageShare : '',
+            },
+        })),
+        notes: [{ text: 'Persistent data for the sandbox: ' + o.dataPath + ' (C:\\AgentData inside)' }],
+    };
+    // Every folder in one table, grouped by kind (the order of DATA_AREAS), biggest first within a kind.
+    const kindRank = (area) => DATA_AREAS.indexOf(area);
+    const rows = [...o.entries].sort((a, b) => kindRank(a.area) - kindRank(b.area) || b.bytes - a.bytes);
+    const kept = {
+        id: 'kept',
+        title: 'What the sandbox keeps',
+        summary: o.total + ' in all',
+        columns: [
+            { key: 'kind', label: 'KIND' },
+            { key: 'name', label: 'NAME' },
+            { key: 'size', label: 'SIZE' },
+            { key: 'folder', label: 'FOLDER' },
+        ],
+        items: rows.map((e) => {
+            const del = e.target
+                ? action(cleanData, { targets: [e.target] }, { label: 'Delete', key: 'x', verb: 'delete' })
+                : undefined;
+            return {
+                id: 'entry:' + e.name,
+                label: e.name,
+                hint: e.size,
+                cells: { kind: AREA_LABEL[e.area], name: e.name, size: e.size, folder: e.path },
+                ...(del ? { primary: del } : {}),
+            };
+        }),
+        actions: [
+            action(pruneStorage, {}, {
+                label: 'Clean up…',
+                verb: 'choose what',
+                description: 'Delete caches, old sandboxes and other leftovers (the clean command, with its options).',
+                fields: [DAYS_FIELD],
+            }),
+        ],
+        notes: [
+            ...(o.entries.length
+                ? []
+                : [{ text: 'Nothing stored yet. Toolchains, databases and agent logins appear here after the first start.' }]),
+            ...keptNote(o),
+            {
+                text: 'Free space with: sandbox data clean <target...>  (e.g. tools/go, databases/postgres-18, logs, launches)',
+                tone: 'muted',
+                only: 'cli',
+            },
+        ],
+    };
+    return { title: 'Data', sections: [disks, kept] };
+}
+/** The folders kept on purpose (not deleted here), named in one note. */
+function keptNote(o) {
+    const names = o.entries.filter((e) => !e.target).map((e) => e.name);
+    return names.length ? [{ text: 'Kept on this PC on purpose, not deleted here: ' + names.join(', ') + '.' }] : [];
+}
+export const dataView = defineView({
+    id: 'data',
+    title: 'Data',
+    summary: 'What the sandbox keeps between runs, and deleting parts of it.',
+    queries: { data: showData },
+    operations: [cleanData, pruneStorage],
+    build: ({ data }) => dataPage(data),
+});

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

@@ -0,0 +1,46 @@
+export declare const showDataRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").QueryDef<import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    dataPath: import("zod").ZodString;
+    storageRoot: import("zod").ZodString;
+    totalBytes: import("zod").ZodNumber;
+    total: import("zod").ZodString;
+    storageShare: import("zod").ZodString;
+    areaTotals: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+    entries: import("zod").ZodArray<import("zod").ZodObject<{
+        area: import("zod").ZodEnum<{
+            host: "host";
+            tools: "tools";
+            databases: "databases";
+            state: "state";
+            data: "data";
+            logs: "logs";
+        }>;
+        name: import("zod").ZodString;
+        path: import("zod").ZodString;
+        bytes: import("zod").ZodNumber;
+        size: import("zod").ZodString;
+        target: import("zod").ZodNullable<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>>;
+    disks: import("zod").ZodArray<import("zod").ZodObject<{
+        drive: import("zod").ZodString;
+        totalBytes: import("zod").ZodNumber;
+        freeBytes: import("zod").ZodNumber;
+        usedBytes: import("zod").ZodNumber;
+        holdsStorage: import("zod").ZodBoolean;
+        used: import("zod").ZodString;
+        usedPercent: import("zod").ZodNumber;
+        free: import("zod").ZodString;
+        total: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>, "data.show">, import("../../../cli/commands/context.js").Context>;
+export declare const cleanDataRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{
+    targets: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    message: import("zod").ZodString;
+    freedBytes: import("zod").ZodNumber;
+}, import("zod/v4/core").$strip>, "data.clean">, import("../../../cli/commands/context.js").Context>;
+export declare const pruneStorageRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{
+    days: import("zod").ZodDefault<import("zod").ZodNumber>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    message: import("zod").ZodString;
+    removed: import("zod").ZodBoolean;
+}, import("zod/v4/core").$strip>, "data.prune">, import("../../../cli/commands/context.js").Context>;

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

@@ -0,0 +1,141 @@
+// The data area's work: measuring what is kept, deleting chosen parts of it (DataService: never follows links, refuses
+// while a sandbox runs) and the clean-up of old launch folders, logs and leftovers. Talks only through io.
+import { humanBytes } from '../../../core/disk.js';
+import { fail } from '../../../core/util/index.js';
+import { cleanTargetOf, DataService } from '../../../cli/services/index.js';
+import { describePrune, pruneStorage as prune } from '../../../host/storage/index.js';
+import { isSandboxRunning } from '../../../host/sandbox/index.js';
+import { RunDir } from '../../../shared/channel/index.js';
+import { implement } from '../../context.js';
+import { cancelled } from '../../kernel/index.js';
+import { cleanData, DATA_AREAS, pruneStorage, showData } from './data.def.js';
+const MEASURING = 'Measuring the saved data (big folders take a moment)';
+const NOTHING_CHOSEN = 'Nothing chosen, nothing removed.';
+/** The page's numbers, in bytes and in words (the definition cannot format them). */
+function showOf(report) {
+    const total = report.totalBytes;
+    const areaTotals = {};
+    for (const area of DATA_AREAS) {
+        const sum = report.entries.filter((e) => e.area === area).reduce((n, e) => n + e.bytes, 0);
+        areaTotals[area] = humanBytes(sum);
+    }
+    return {
+        dataPath: report.dataPath,
+        storageRoot: report.storageRoot,
+        totalBytes: total,
+        total: humanBytes(total),
+        storageShare: '<- sandbox storage (' + humanBytes(total) + ' of it)',
+        areaTotals,
+        entries: report.entries.map((e) => ({
+            area: e.area,
+            name: e.name,
+            path: e.path,
+            bytes: e.bytes,
+            size: humanBytes(e.bytes),
+            target: cleanTargetOf(e),
+        })),
+        disks: report.disks.map((d) => ({
+            drive: d.drive,
+            totalBytes: d.totalBytes,
+            freeBytes: d.freeBytes,
+            usedBytes: d.usedBytes,
+            holdsStorage: d.holdsStorage,
+            used: humanBytes(d.usedBytes),
+            usedPercent: Math.round((d.usedBytes / d.totalBytes) * 100),
+            free: humanBytes(d.freeBytes),
+            total: humanBytes(d.totalBytes),
+        })),
+    };
+}
+/** Rows as aligned columns, as the command line's tables print them (the last column is not padded). */
+function alignedLines(rows) {
+    const width = (i) => Math.max(0, ...rows.map((r) => (r[i] ?? '').length));
+    return rows.map((row) => row.map((cell, i) => (i === row.length - 1 ? cell : cell.padEnd(width(i) + 2))).join(''));
+}
+/** No target named: what can be cleaned, with sizes, to tick from. Undefined when nothing can be. */
+async function pickTargets(service, io) {
+    io.progress(MEASURING);
+    const choices = service.entries().flatMap((e) => {
+        const target = cleanTargetOf(e);
+        return target ? [{ value: target, label: target.padEnd(28) + humanBytes(e.bytes) }] : [];
+    });
+    if (!choices.length)
+        return undefined;
+    return io.checklist({
+        title: 'What do you want to delete? (space ticks, enter confirms)',
+        choices,
+        noTerminal: {
+            message: 'Which data should be cleaned?',
+            fix: 'Name them: sandbox data clean logs tools/go   (what exists: sandbox data)',
+        },
+    });
+}
+export const showDataRun = implement(showData, (ctx) => {
+    return showOf(new DataService(ctx).report());
+});
+export const cleanDataRun = implement(cleanData, async (ctx, input, io) => {
+    const service = new DataService(ctx);
+    let inputs = input.targets;
+    if (!inputs.length) {
+        const chosen = await pickTargets(service, io);
+        if (!chosen?.length)
+            return { message: NOTHING_CHOSEN, freedBytes: 0 };
+        inputs = chosen;
+    }
+    const plan = service.plan(inputs);
+    if (!plan.present.length)
+        return {
+            message: 'Nothing to remove: ' + plan.targets.map((t) => t.target).join(', ') + ' do(es) not exist.',
+            freedBytes: 0,
+        };
+    for (const line of alignedLines(plan.present.map((t) => ['  ' + t.target, humanBytes(t.bytes), t.path])))
+        io.log(line);
+    for (const t of plan.present)
+        if (t.warning)
+            io.log('Warning: ' + t.target + ' ' + t.warning + '.', 'warn');
+    const names = plan.present.map((t) => t.target).join(', ');
+    const confirmed = plan.present.some((t) => t.target === 'all')
+        ? await io.confirm({
+            title: 'This cannot be undone; the next sandbox starts from scratch and reinstalls everything.',
+            typed: 'all',
+            danger: true,
+            noTerminal: { message: 'Nothing removed.', fix: 'Add --yes to delete without asking.' },
+        })
+        : await io.confirm({
+            title: 'Delete ' + names + ' (' + humanBytes(plan.totalBytes) + ')? This cannot be undone.',
+            yes: 'Delete',
+            danger: true,
+            noTerminal: { message: 'Cannot ask here (no terminal).', fix: 'Add --yes to delete without asking.' },
+        });
+    if (!confirmed)
+        cancelled('Nothing removed.');
+    const outcome = service.clean(plan);
+    if (outcome.failed.length)
+        fail('Could not remove everything: ' + outcome.failed.join('; '), 'Close programs using those folders and run the same command again.');
+    return {
+        message: 'Removed ' +
+            names +
+            ' and freed ' +
+            humanBytes(outcome.freedBytes) +
+            (outcome.touchedData ? '; the next sandbox reinstalls what it needs.' : '.'),
+        freedBytes: outcome.freedBytes,
+    };
+});
+export const pruneStorageRun = implement(pruneStorage, async (ctx, input, io) => {
+    const running = isSandboxRunning() ? new RunDir(ctx.dataPath).readSandboxStatus()?.launchId : undefined;
+    const options = { launchDays: input.days, keep: running ? [running] : [] };
+    const found = prune(ctx.storageRoot, { ...options, dryRun: true });
+    if (found.launches + found.logs + found.leftovers === 0)
+        return { message: 'Nothing to clean.', removed: false };
+    io.log('Can be removed: ' + describePrune(found).replace(' removed', '') + '.');
+    const confirmed = await io.confirm({
+        title: 'Delete them?',
+        yes: 'Delete',
+        danger: true,
+        noTerminal: { message: 'Cannot ask here (no terminal).', fix: 'Add --yes to delete without asking.' },
+    });
+    if (!confirmed)
+        cancelled('Nothing removed.');
+    const removed = describePrune(prune(ctx.storageRoot, options)).replace(' removed', '');
+    return { message: 'Removed ' + removed + '.', removed: true };
+});

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

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

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

@@ -0,0 +1,3 @@
+// The data area: what the sandbox keeps between runs, deleting parts of it, and the clean-up.
+export * from './data.def.js';
+export * from './data.run.js';