windows-development-sandbox 1.9.0 → 1.11.3

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

@@ -2,7 +2,9 @@
 // from the config schema through Fields, with get, set and reset. Pure: schemas and the view; the rows are made on the
 // Node side (settings-rows.ts) because the config schema is, and secrets never leave it unmasked.
 import { z } from 'zod';
-import { action, defineOperation, defineQuery, defineView, FieldSchema, link, valueText, } from '../../kernel/index.js';
+import { action, defineOperation, defineQuery, defineView, FieldSchema, fieldOf, SchemaNode, valueText, } from '../../kernel/index.js';
+import { browseFolder } from '../files/files.def.js';
+import { changeDataFolder } from '../storage/storage.def.js';
 export const ScopeSchema = z
     .enum(['user', 'project'])
     .describe("Your own settings (all projects) or this folder's .sandbox-config.json (this project)");
@@ -40,6 +42,8 @@ export const SettingsListSchema = z.object({
     exists: z.boolean(),
     /** Your own settings: where the data folder is (it has its own flow; its setting is not listed). */
     dataFolder: z.string().optional(),
+    /** Where an export goes by default (full path; your own settings only). */
+    exportFile: z.string().optional().describe('Where an export goes by default (full path; your own settings only)'),
     categories: z.array(z.object({ id: z.string(), label: z.string(), description: z.string() })),
     rows: z.array(SettingRowSchema),
 });
@@ -83,6 +87,57 @@ export const resetSetting = defineOperation({
     text: (o) => o.message,
     cli: { name: 'config', action: 'reset', positional: ['key'] },
 });
+const JsonFileSchema = z
+    .string()
+    .max(2000)
+    .regex(/\.json$/i, 'The file name should end in .json.');
+export const exportConfig = defineOperation({
+    id: 'settings.export',
+    title: 'Export settings…',
+    summary: 'write the settings you changed to a .json file to share (no secrets, no data folder, no paths of this PC)',
+    input: z.object({
+        settingsFile: JsonFileSchema.optional().describe('(export, import) the .json file; default sandbox-settings.json in the current folder'),
+        withPaths: z.boolean().default(false).describe('(export) keep folders and files of this PC in the file'),
+    }),
+    output: z.object({
+        file: z.string().describe('The file written (full path)'),
+        leftOut: z.array(z.string()).describe('What was left out, one "<key> (<why>)" each'),
+        pathsLeftOut: z.boolean().describe('A folder or file of this PC was left out (and --with-paths was not given)'),
+    }),
+    text: (o) => [
+        'Wrote ' + o.file + ' (only what differs from the defaults).',
+        ...(o.leftOut.length ? ['Left out:', ...o.leftOut.map((l) => '  ' + l)] : []),
+        ...(o.pathsLeftOut ? ["Keep this PC's folders and files in the file with --with-paths."] : []),
+    ].join('\n'),
+    cli: {
+        name: 'config',
+        action: 'export',
+        positional: ['settingsFile'],
+        flags: { withPaths: { flag: '--with-paths' } },
+    },
+});
+export const importConfig = defineOperation({
+    id: 'settings.import',
+    title: 'Import settings…',
+    summary: 'read a shared settings file, show what it would change, and apply it after one yes',
+    input: z.object({
+        settingsFile: JsonFileSchema.optional().describe('(export, import) the .json file'),
+    }),
+    output: z.object({
+        changed: z.number().describe('How many settings changed'),
+        message: z.string().describe('What happened'),
+    }),
+    text: (o) => o.message,
+    cli: { name: 'config', action: 'import', positional: ['settingsFile'] },
+});
+/** A file field of an operation's input, asked for in the page (a path to a file). */
+function fileField(def, label) {
+    return {
+        ...fieldOf(new SchemaNode(def.input).child('settingsFile'), ['settingsFile']),
+        label,
+        optional: false,
+    };
+}
 /** The facts under a setting: its key, your value, the project's, the default, and the lock. */
 function details(row, scope) {
     const text = (v) => valueText(v, row.field, 40).text;
@@ -103,15 +158,17 @@ function settingItem(row, scope) {
         id: row.id,
         label: row.label,
         hint: shown,
-        ...(row.set ? { tone: scope === 'project' ? 'accent' : 'ok', badges: [{ text: 'set', tone: 'accent' }] } : {}),
+        ...(row.set ? { tone: scope === 'project' ? 'accent' : 'ok', badges: [{ text: 'changed', tone: 'accent' }] } : {}),
         description: row.field.help,
         group: row.section,
         details: details(row, scope),
         keywords: row.id,
+        code: row.id,
         cells: { setting: row.id, value: shown },
         primary: action(setSetting, { scope, key: row.id }, {
             label: 'Change',
             verb: 'edit',
+            inline: true,
             fields: [{ ...row.field, name: 'value', label: row.label }],
             initial: { value: editable },
         }),
@@ -122,15 +179,15 @@ function settingItem(row, scope) {
             : [],
     };
 }
-/** The Data folder row: where the saved data is; moving it has a flow of its own (menu; sandbox storage move). */
+/** The Data folder row: where the saved data is; changing it asks for the folder, then moves or switches (storage). */
 function dataFolderItem(folder) {
     return {
         id: '@data-folder',
         label: 'Data folder',
         hint: folder,
         cells: { setting: 'storage.root', value: folder },
-        description: 'Where your tools, logins, history and logs are kept between sandboxes. Move it with the menu (Settings > Data folder) or sandbox storage move <folder>.',
-        primary: link({ kind: 'command', argv: ['storage'] }, 'Data folder', { verb: 'change' }),
+        description: 'Where your tools, logins, history and logs are kept between sandboxes. Move it with sandbox storage move <folder>.',
+        primary: action(changeDataFolder, {}, { label: 'Data folder', verb: 'change' }),
     };
 }
 /** The settings page of one scope: a section per category, each setting with its value and an edit action. */
@@ -151,6 +208,7 @@ export function settingsPage(o) {
     }));
     return {
         title: 'Settings',
+        categories: true,
         notice: {
             text: 'Editing ' +
                 o.file +
@@ -159,6 +217,22 @@ export function settingsPage(o) {
             tone: o.scope === 'project' ? 'accent' : 'muted',
         },
         sections,
+        // Export and import are for your own settings only (never on the project tab).
+        actions: o.scope === 'user'
+            ? [
+                action(exportConfig, {}, {
+                    verb: 'export',
+                    fields: [fileField(exportConfig, 'Where to write the settings file')],
+                    initial: { settingsFile: o.exportFile },
+                    description: 'Write the settings you changed to a .json file you can share with a team. Secrets, the data folder and folders or files of this PC are left out.',
+                }),
+                action(importConfig, {}, {
+                    verb: 'import',
+                    fields: [fileField(importConfig, 'Which settings file')],
+                    description: 'Read a settings file someone shared, see what it would change, and apply it once you say yes. Secrets, the data folder and paths in it are never taken.',
+                }),
+            ]
+            : [],
     };
 }
 export const settingsView = defineView({
@@ -166,7 +240,8 @@ export const settingsView = defineView({
     title: 'Settings',
     summary: 'Every setting, for all projects or just this project, with its value, default and description.',
     queries: { settings: listSettings },
-    operations: [setSetting, resetSetting],
+    operations: [setSetting, resetSetting, exportConfig, importConfig, changeDataFolder],
+    pickers: [browseFolder],
     tabs: {
         param: 'scope',
         choices: [

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

@@ -1,5 +1,7 @@
 import { type AppContext } from '../../context.js';
 import { type SettingsFiles } from './settings-rows.js';
+/** The file `sandbox config export` writes when none is named. */
+export declare const DEFAULT_EXPORT = "sandbox-settings.json";
 /** Your own settings file (the one --config names) and the project file of the current folder. */
 export declare function settingsFiles(ctx: AppContext): SettingsFiles;
 export declare const listSettingsRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").QueryDef<import("zod").ZodObject<{
@@ -15,6 +17,7 @@ export declare const listSettingsRun: import("../../kernel/define.js").Implement
     file: import("zod").ZodString;
     exists: import("zod").ZodBoolean;
     dataFolder: import("zod").ZodOptional<import("zod").ZodString>;
+    exportFile: import("zod").ZodOptional<import("zod").ZodString>;
     categories: import("zod").ZodArray<import("zod").ZodObject<{
         id: import("zod").ZodString;
         label: import("zod").ZodString;
@@ -65,3 +68,17 @@ export declare const resetSettingRun: import("../../kernel/define.js").Implement
     changed: import("zod").ZodBoolean;
     message: import("zod").ZodString;
 }, import("zod/v4/core").$strip>, "settings.reset">, import("../../../cli/commands/context.js").Context>;
+export declare const exportConfigRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{
+    settingsFile: import("zod").ZodOptional<import("zod").ZodString>;
+    withPaths: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    file: import("zod").ZodString;
+    leftOut: import("zod").ZodArray<import("zod").ZodString>;
+    pathsLeftOut: import("zod").ZodBoolean;
+}, import("zod/v4/core").$strip>, "settings.export">, import("../../../cli/commands/context.js").Context>;
+export declare const importConfigRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{
+    settingsFile: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    changed: import("zod").ZodNumber;
+    message: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, "settings.import">, import("../../../cli/commands/context.js").Context>;

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

@@ -1,15 +1,23 @@
 // The settings feature's work: the rows of a scope, and one setting read, changed or reset. Files are changed one
 // setting at a time with comments kept, and nothing is written unless the whole file stays valid (settings-file.ts).
+import fs from 'node:fs';
+import path from 'node:path';
 import _ from 'lodash';
+import { loadConfig } from '../../../core/config/index.js';
 import { redactSecrets } from '../../../core/schema/index.js';
-import { fail } from '../../../core/util/index.js';
+import { fail, safeText, writeJson } from '../../../core/util/index.js';
 import { hereDir } from '../../../cli/commands/projects/here.js';
 import { implement } from '../../context.js';
-import { allowedText, valueFromText } from '../../kernel/index.js';
+import { allowedText, cancelled, valueFromText } from '../../kernel/index.js';
 import { CATEGORIES } from './categories.def.js';
 import { ConfigFile } from './settings-file.js';
+import { diffText, exportSettings, planImport, skippedLine } from './settings-share.js';
 import { findSetting, masked, settingRows } from './settings-rows.js';
-import { getSetting, listSettings, resetSetting, setSetting } from './settings.def.js';
+import { exportConfig, getSetting, importConfig, listSettings, resetSetting, setSetting, } from './settings.def.js';
+/** The file `sandbox config export` writes when none is named. */
+export const DEFAULT_EXPORT = 'sandbox-settings.json';
+/** A shared file is a few KB; anything bigger is not one. */
+const MAX_BYTES = 1024 * 1024;
 /** Your own settings file (the one --config names) and the project file of the current folder. */
 export function settingsFiles(ctx) {
     return { user: ConfigFile.user(ctx.loaded.configPath), project: ConfigFile.project(hereDir(ctx)) };
@@ -26,7 +34,7 @@ export const listSettingsRun = implement(listSettings, (ctx, input) => {
         scope: input.scope,
         file: file.file,
         exists: file.exists,
-        ...(input.scope === 'user' ? { dataFolder: ctx.storageRoot } : {}),
+        ...(input.scope === 'user' ? { dataFolder: ctx.storageRoot, exportFile: path.resolve(DEFAULT_EXPORT) } : {}),
         categories: CATEGORIES.filter((c) => rows.some((r) => r.category === c.id)).map((c) => ({
             id: c.id,
             label: c.label,
@@ -82,3 +90,80 @@ export const resetSettingRun = implement(resetSetting, (ctx, input) => {
             : input.key + ' is back to its default: ' + JSON.stringify(masked(key, file.defaultOf(key))) + '.',
     };
 });
+/** Your settings as they are on disk now (the menu may have saved changes since it started). */
+function freshConfig(ctx) {
+    return loadConfig(ctx.loaded.configPath ?? undefined).config;
+}
+/** Reads a shared file and plans the import. Fails with the reason when it cannot be read. */
+function readImport(config, file) {
+    const source = path.resolve(file);
+    if (!fs.existsSync(source))
+        fail('There is no file ' + source + '.', 'Give the path of a file made by sandbox config export.');
+    if (fs.statSync(source).size > MAX_BYTES)
+        fail(source + ' is too big to be a settings file.');
+    const plan = planImport(fs.readFileSync(source, 'utf8'), config);
+    if (plan.problems.length)
+        fail(source + ' is not valid settings:\n  ' + plan.problems.map(safeText).join('\n  '), 'Nothing was changed. Fix the file, or export a new one with: sandbox config export');
+    return plan;
+}
+/** Writes the planned changes to your settings file (comments stay); returns how many settings changed. */
+function applyImport(ctx, plan) {
+    const outcome = ConfigFile.user(ctx.loaded.configPath).setMany(plan.changes);
+    if (typeof outcome === 'object')
+        fail('Could not import: ' + outcome.problems.join('; '), 'Nothing was written. Your settings are unchanged.');
+    return plan.changes.length;
+}
+export const exportConfigRun = implement(exportConfig, async (ctx, input, io) => {
+    const target = path.resolve(input.settingsFile ?? DEFAULT_EXPORT);
+    if (fs.existsSync(target)) {
+        const replace = await io.confirm({
+            title: target + ' exists. Replace it?',
+            yes: 'Replace',
+            noTerminal: { message: target + ' exists already.', fix: 'Pick another name, or delete it first.' },
+        });
+        if (!replace)
+            cancelled();
+    }
+    const { data, skipped } = exportSettings(freshConfig(ctx), input.withPaths);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    writeJson(target, data);
+    return {
+        file: target,
+        leftOut: skipped.map(skippedLine),
+        pathsLeftOut: !input.withPaths && skipped.some((s) => s.why === 'path'),
+    };
+});
+export const importConfigRun = implement(importConfig, async (ctx, input, io) => {
+    const file = input.settingsFile ??
+        (await io.path({
+            title: 'Which settings file',
+            lines: ['A file made by Export settings (or sandbox config export).'],
+            pathKind: 'file',
+        }));
+    if (file === undefined)
+        cancelled();
+    const plan = readImport(freshConfig(ctx), file);
+    if (plan.skipped.length) {
+        io.log('Not imported (never taken from a file):');
+        for (const s of plan.skipped)
+            io.log('  ' + safeText(skippedLine(s)));
+    }
+    const n = plan.changes.length;
+    if (!n)
+        return { changed: 0, message: 'Nothing to change: your settings already match the file.' };
+    io.log('This would change ' + n + ' setting' + (n === 1 ? '' : 's') + ':');
+    for (const line of diffText(plan.lines))
+        io.log('  ' + safeText(line));
+    const yes = await io.confirm({
+        title: 'Change your settings like this?',
+        yes: 'Change',
+        noTerminal: { message: 'Cannot ask here (no terminal).', fix: 'Add --yes to change them without asking.' },
+    });
+    if (!yes)
+        cancelled('Nothing was changed.');
+    const changed = applyImport(ctx, plan);
+    return {
+        changed,
+        message: 'Imported ' + changed + ' setting' + (changed === 1 ? '' : 's') + '. New sandboxes use them.',
+    };
+});

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

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

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

@@ -0,0 +1,3 @@
+// The storage area: where the saved data lives, moving it or switching folders, and contained storage (beta).
+export * from './storage.def.js';
+export * from './storage.run.js';

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

@@ -0,0 +1,133 @@
+import { z } from 'zod';
+import { type Page } from '../../kernel/index.js';
+export declare const StorageShowSchema: z.ZodObject<{
+    root: z.ZodString;
+    exists: z.ZodBoolean;
+    holdsData: z.ZodBoolean;
+    measured: z.ZodNullable<z.ZodObject<{
+        bytes: z.ZodNumber;
+        files: z.ZodNumber;
+        partial: z.ZodBoolean;
+    }, z.core.$strip>>;
+    size: z.ZodString;
+    defaultRoot: z.ZodString;
+    defaultInUse: z.ZodBoolean;
+    otherFoldersWithData: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type StorageShow = z.output<typeof StorageShowSchema>;
+export declare const showStorage: import("../../kernel/define.js").QueryDef<z.ZodObject<{
+    measure: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    root: z.ZodString;
+    exists: z.ZodBoolean;
+    holdsData: z.ZodBoolean;
+    measured: z.ZodNullable<z.ZodObject<{
+        bytes: z.ZodNumber;
+        files: z.ZodNumber;
+        partial: z.ZodBoolean;
+    }, z.core.$strip>>;
+    size: z.ZodString;
+    defaultRoot: z.ZodString;
+    defaultInUse: z.ZodBoolean;
+    otherFoldersWithData: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, "storage.show">;
+export declare const moveStorage: import("../../kernel/define.js").OperationDef<z.ZodObject<{
+    folder: z.ZodOptional<z.ZodString>;
+    keepOld: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodString;
+    copied: z.ZodBoolean;
+    files: z.ZodNumber;
+    bytes: z.ZodNumber;
+    pinned: z.ZodString;
+    removedOld: z.ZodBoolean;
+    notes: z.ZodArray<z.ZodString>;
+    message: z.ZodString;
+}, z.core.$strip>, "storage.move">;
+export declare const useStorage: import("../../kernel/define.js").OperationDef<z.ZodObject<{
+    folder: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    message: z.ZodString;
+}, z.core.$strip>, "storage.use">;
+export declare const changeDataFolder: import("../../kernel/define.js").OperationDef<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+    message: z.ZodString;
+}, z.core.$strip>, "storage.change">;
+export declare const ContainedStatusSchema: z.ZodObject<{
+    setting: z.ZodEnum<{
+        off: "off";
+        vhdx: "vhdx";
+    }>;
+    maxGb: z.ZodNumber;
+    available: z.ZodBoolean;
+    reasons: z.ZodArray<z.ZodString>;
+    fixes: z.ZodArray<z.ZodString>;
+    image: z.ZodString;
+    imageExists: z.ZodBoolean;
+    imageBytes: z.ZodNullable<z.ZodNumber>;
+    mountFolder: z.ZodString;
+    recordedMounted: z.ZodBoolean;
+    holders: z.ZodNumber;
+    mountedNow: z.ZodNullable<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ContainedStatus = z.output<typeof ContainedStatusSchema>;
+export declare const containedStatus: import("../../kernel/define.js").QueryDef<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+    setting: z.ZodEnum<{
+        off: "off";
+        vhdx: "vhdx";
+    }>;
+    maxGb: z.ZodNumber;
+    available: z.ZodBoolean;
+    reasons: z.ZodArray<z.ZodString>;
+    fixes: z.ZodArray<z.ZodString>;
+    image: z.ZodString;
+    imageExists: z.ZodBoolean;
+    imageBytes: z.ZodNullable<z.ZodNumber>;
+    mountFolder: z.ZodString;
+    recordedMounted: z.ZodBoolean;
+    holders: z.ZodNumber;
+    mountedNow: z.ZodNullable<z.ZodBoolean>;
+}, z.core.$strip>, "storage.containedStatus">;
+export declare const containedOn: import("../../kernel/define.js").OperationDef<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+    message: z.ZodString;
+}, z.core.$strip>, "storage.containedOn">;
+export declare const containedOff: import("../../kernel/define.js").OperationDef<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+    message: z.ZodString;
+}, z.core.$strip>, "storage.containedOff">;
+/** The Storage page: the data folder (change, move, use another), then contained storage (beta). */
+export declare function storagePage(o: StorageShow, c: ContainedStatus): Page;
+export declare const storageView: import("../../kernel/define.js").ViewDef<{
+    storage: import("../../kernel/define.js").QueryDef<z.ZodObject<{
+        measure: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        root: z.ZodString;
+        exists: z.ZodBoolean;
+        holdsData: z.ZodBoolean;
+        measured: z.ZodNullable<z.ZodObject<{
+            bytes: z.ZodNumber;
+            files: z.ZodNumber;
+            partial: z.ZodBoolean;
+        }, z.core.$strip>>;
+        size: z.ZodString;
+        defaultRoot: z.ZodString;
+        defaultInUse: z.ZodBoolean;
+        otherFoldersWithData: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>, "storage.show">;
+    contained: import("../../kernel/define.js").QueryDef<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+        setting: z.ZodEnum<{
+            off: "off";
+            vhdx: "vhdx";
+        }>;
+        maxGb: z.ZodNumber;
+        available: z.ZodBoolean;
+        reasons: z.ZodArray<z.ZodString>;
+        fixes: z.ZodArray<z.ZodString>;
+        image: z.ZodString;
+        imageExists: z.ZodBoolean;
+        imageBytes: z.ZodNullable<z.ZodNumber>;
+        mountFolder: z.ZodString;
+        recordedMounted: z.ZodBoolean;
+        holders: z.ZodNumber;
+        mountedNow: z.ZodNullable<z.ZodBoolean>;
+    }, z.core.$strip>, "storage.containedStatus">;
+}, Record<string, never>, "storage">;