windows-development-sandbox 1.5.0 → 1.7.0

package/dist/cli/menu/command-form.js

@@ -1,18 +1,26 @@
-// One command as a form: its arguments and options listed with their current values, each changed in place, and the
-// exact command line it will run shown live (the same line you could type yourself). Built from manifest.ts, so a new
-// command or option appears here on its own.
+// One command as a form: its arguments and options listed with their current values, each changed in place with the
+// input that fits it (a switch flips, a choice is picked, a number is typed within its limits, a folder or file is
+// picked in the path picker, a list is edited item by item), and the exact command line it will run shown live (the
+// same line you could type yourself). Built from manifest.ts, so a new command or option appears here on its own.
+import { z } from 'zod';
 import { humanBytes } from '../../core/disk.js';
-import { fail, plainText } from '../../core/util/index.js';
+import { plainText } from '../../core/util/index.js';
 import { SandboxChannel } from '../../host/channel/index.js';
 import { isSandboxRunning } from '../../host/sandbox/index.js';
+import { moveProblem } from '../../host/storage/index.js';
 import { splitArgs } from '../args.js';
 import { cleanTargetOf } from '../commands/data/collect.js';
-import { AccountsService, DataService } from '../services/index.js';
+import { AccountsService, DataService, ProjectsService } from '../services/index.js';
 import { commandLine } from '../history.js';
 import { askedWhen } from '../manifest.js';
 import { Text, Theme } from '../tui/index.js';
-import { optionProblem } from './command-fields.js';
+import { actionOf, argLabel, argPathKind, optionLabel, optionPathKind, optionProblem, plainDescription, plainSummary, } from './command-fields.js';
+import { StringListEditor } from './settings/collections/string-list-editor.js';
+import { askPath } from './settings/path-kind.js';
+import { SchemaNode } from './settings/schema-node.js';
+import { ValueEditor } from './settings/value-editor.js';
 const MORE = '@more';
+const OTHER = '@other';
 export class CommandForm {
     app;
     ctx;
@@ -36,6 +44,11 @@ export class CommandForm {
                 ]);
         }
     }
+    /** The actions the command's first argument offers (account: save, use, rename ...). */
+    actions() {
+        const choices = this.spec.args[0]?.choices;
+        return Array.isArray(choices) ? choices : [];
+    }
     /** Values a choices list names, filled in from config and the running sandbox. */
     choices(choices) {
         if (Array.isArray(choices))
@@ -53,10 +66,21 @@ export class CommandForm {
     first() {
         return this.values.get('arg:' + this.spec.args[0]?.name)?.[0] ?? '';
     }
+    valueOf(name) {
+        return this.values.get('arg:' + name)?.[0] ?? '';
+    }
     /** Options the form may ask for at all (advanced ones included). */
     askable() {
         const first = this.first();
-        return this.spec.options.filter((o) => !o.noMenu && askedWhen(o.when, first) && !(typeof o.choices === 'string' && !this.choices(o.choices).length));
+        return this.spec.options.filter((o) => {
+            if (o.noMenu || !askedWhen(o.when, first))
+                return false;
+            if (typeof o.choices === 'string' && !this.choices(o.choices).length)
+                return false;
+            // "(check) the folder": asked only for that action.
+            const action = actionOf(o.description, this.actions());
+            return !action || action === first;
+        });
     }
     hiddenCount() {
         return this.showAdvanced ? 0 : this.askable().filter((o) => o.advanced && !this.values.has('opt:' + o.flag)).length;
@@ -102,7 +126,7 @@ export class CommandForm {
     /** The name of a required argument that has no value yet. */
     missing() {
         const field = this.fields().find((f) => f.kind === 'arg' && f.spec.required && !this.values.get(this.id(f))?.length);
-        return field?.kind === 'arg' ? Text.humanize(field.spec.name) : undefined;
+        return field?.kind === 'arg' ? argLabel(field.spec) : undefined;
     }
     item(f) {
         const v = this.values.get(this.id(f));
@@ -119,12 +143,13 @@ export class CommandForm {
                 : Array.isArray(v) && v.length
                     ? v.join(' ')
                     : Theme.muted('not set');
+        const actions = this.actions();
         if (f.kind === 'arg')
             return {
                 value: this.id(f),
-                label: Text.humanize(f.spec.name),
+                label: argLabel(f.spec),
                 hint: shown,
-                description: f.spec.description,
+                description: plainDescription(f.spec.description, actions),
                 section: 'What',
                 keywords: f.spec.name,
             };
@@ -133,8 +158,9 @@ export class CommandForm {
                 value: 'json',
                 label: 'Machine-readable output',
                 hint: shown,
-                description: 'Print JSON instead of a table (--json).',
+                description: 'Print JSON instead of a table.',
                 section: 'Output',
+                flip: true,
             };
         if (f.kind === 'extra')
             return {
@@ -148,15 +174,12 @@ export class CommandForm {
             };
         return {
             value: this.id(f),
-            label: f.spec.label ??
-                f.spec.flag
-                    .replace(/^--/, '')
-                    .replace(/-/g, ' ')
-                    .replace(/^./, (c) => c.toUpperCase()),
+            label: optionLabel(f.spec),
             hint: shown,
-            description: f.spec.description,
+            description: plainDescription(f.spec.description, actions),
             section: f.spec.advanced ? 'Advanced' : 'Options',
             keywords: f.spec.flag,
+            flip: f.spec.type === 'boolean',
         };
     }
     /** Shows the form until you run the command (its argv) or go back (null). */
@@ -170,7 +193,7 @@ export class CommandForm {
             const line = commandLine(this.argv());
             const picked = await this.app.list({
                 path,
-                intro: this.spec.summary.replace(/^./, (c) => c.toUpperCase()) + '.',
+                intro: plainSummary(this.spec.summary),
                 status: Theme.muted('$ ') + Theme.accent(line),
                 items: [
                     ...fields.map((f) => this.item(f)),
@@ -181,8 +204,9 @@ export class CommandForm {
                 startAt: focus,
                 actions: [
                     { key: 'r', label: 'start', ctrl: true },
-                    { key: 'r', label: 'clear' },
+                    { key: 'r', label: 'clear', applies: (id) => this.values.has(id) },
                 ],
+                enterLabel: (_category, id) => (id === MORE ? 'show' : this.isSwitch(id) ? 'flip' : 'change'),
                 notice,
             });
             notice = undefined;
@@ -210,64 +234,124 @@ export class CommandForm {
                 this.values.delete(this.id(field));
                 continue;
             }
-            await this.edit(field, path);
+            notice = await this.edit(field, path);
             // Enter on the last field starts it (a switch only flips).
             const isSwitch = field.kind === 'json' || (field.kind === 'option' && field.spec.type === 'boolean');
             if (field === fields[fields.length - 1] && !isSwitch && !hidden && !this.missing())
                 return this.argv();
         }
     }
+    isSwitch(id) {
+        const f = this.fields().find((x) => this.id(x) === id);
+        return f?.kind === 'json' || (f?.kind === 'option' && f.spec.type === 'boolean');
+    }
+    /** Sets (or, with no value, clears) a field's answer. */
+    set(id, value) {
+        if (value.length)
+            this.values.set(id, value);
+        else
+            this.values.delete(id);
+    }
+    /** The kind of path a field takes (a folder or a file), if it is one. */
+    pathKind(f) {
+        if (f.kind === 'option')
+            return optionPathKind(f.spec);
+        return f.kind === 'arg' ? argPathKind(f.spec, this.spec.name, this.first()) : undefined;
+    }
+    /** A name that does not exist yet (the new login's name): typed, not picked. */
+    freeText(f) {
+        return f.kind === 'arg' && this.spec.name === 'account' && f.spec.name === 'name' && this.first() === 'save';
+    }
+    /** The values to pick from for a field with a fixed or looked-up set of answers. */
+    options(f) {
+        if (f.kind === 'extra' || f.kind === 'json' || this.freeText(f))
+            return [];
+        const fixed = this.choices(f.spec.choices);
+        if (fixed.length || f.kind !== 'arg' || this.spec.name !== 'projects')
+            return fixed;
+        const first = this.first();
+        if (f.spec.name === 'value' && first === 'all')
+            return ['on', 'off'];
+        if (f.spec.name === 'value' && first === 'roots')
+            return ['list', 'add', 'remove'];
+        if (f.spec.name === 'folder' && this.valueOf('value') === 'remove')
+            return new ProjectsService(this.ctx).list().roots;
+        return [];
+    }
+    /** Changes one field with the input that fits it. Returns a notice to show (when there is something to say). */
     async edit(f, path) {
         const id = this.id(f);
         const current = this.values.get(id);
         if (f.kind === 'json' || (f.kind === 'option' && f.spec.type === 'boolean')) {
             this.values.set(id, current !== true);
-            return;
+            return undefined;
         }
-        const label = f.kind === 'extra' ? 'Arguments' : f.kind === 'arg' ? Text.humanize(f.spec.name) : f.spec.flag;
-        const about = f.kind === 'extra' ? [] : [f.spec.description];
+        const label = f.kind === 'extra' ? 'Arguments' : f.kind === 'arg' ? argLabel(f.spec) : optionLabel(f.spec);
+        const about = f.kind === 'extra' ? [] : [plainDescription(f.spec.description, this.actions())];
+        const here = [...path, label];
         if (f.kind === 'arg' && this.spec.name === 'data' && f.spec.name === 'targets') {
             const picked = await this.dataTargets(path);
             if (picked)
                 this.values.set(id, picked);
-            return;
+            return undefined;
         }
-        const list = f.kind === 'extra' ? [] : this.choices(f.spec.choices);
         const many = (f.kind === 'option' && f.spec.type === 'list') || (f.kind === 'arg' && f.spec.variadic);
+        const list = this.options(f);
         if (list.length && many) {
             const picked = await this.app.list({
-                path: [...path, label],
+                path: here,
                 intro: about,
                 multi: true,
                 items: list.map((v) => ({ value: v, label: v, checked: Array.isArray(current) && current.includes(v) })),
             });
             if (picked.kind === 'multi')
-                this.values.set(id, picked.values);
-            return;
+                this.set(id, picked.values);
+            return undefined;
+        }
+        if (f.kind === 'arg' && this.spec.name === 'projects' && f.spec.name === 'value' && this.projectAction()) {
+            await this.projectFolder(id, here, about);
+            return undefined;
         }
         if (list.length) {
             const optional = !(f.kind === 'arg' && f.spec.required);
-            const picked = await this.app.choose([...path, label], about.join(' '), [
+            const picked = await this.app.choose(here, about.join(' '), [
                 ...list.map((v) => ({ value: v, label: v })),
                 ...(optional ? [{ value: '', label: Theme.muted('(not set)') }] : []),
             ], Array.isArray(current) ? current[0] : undefined);
-            if (picked !== undefined) {
-                if (picked === '')
-                    this.values.delete(id);
-                else
-                    this.values.set(id, [picked]);
-            }
-            return;
+            if (picked !== undefined)
+                this.set(id, picked === '' ? [] : [picked]);
+            return undefined;
         }
-        if (f.kind === 'arg' && typeof f.spec.choices === 'string')
-            fail('There is nothing to choose from: no ' + f.spec.choices + ' yet.', f.spec.choices === 'accounts'
-                ? 'Sign in inside the sandbox, then run: sandbox account save <name>'
-                : 'Start one first (sandbox claude).');
+        if (f.kind !== 'extra' && typeof f.spec.choices === 'string' && !this.freeText(f))
+            return this.nothingToChoose(f.spec.choices);
+        const kind = this.pathKind(f);
+        if (kind && f.kind !== 'extra') {
+            if (many)
+                return this.pathList(id, here, about, kind);
+            const picked = await askPath(this.app, {
+                path: here,
+                title: kind === 'file' ? 'Choose the file' : 'Choose the folder',
+                about,
+                kind,
+                initial: Array.isArray(current) ? current[0] : '',
+                validate: (v) => this.pathProblem(f, v),
+            });
+            if (picked !== undefined)
+                this.set(id, [picked]);
+            return undefined;
+        }
+        if (f.kind === 'option' && f.spec.type === 'list')
+            return this.pathList(id, here, about, undefined);
+        const number = f.kind === 'option' && f.spec.type === 'number' ? f.spec : undefined;
         const typed = await this.app.text({
-            path: [...path, label],
+            path: here,
             label,
             about,
             allowEmpty: true,
+            accept: number ? /[0-9]/ : undefined,
+            hint: number
+                ? 'A whole number greater than 0' + (number.default !== undefined ? '. Default: ' + number.default : '') + '.'
+                : undefined,
             initial: Array.isArray(current)
                 ? many || f.kind === 'extra'
                     ? current.map((x) => (/\s/.test(x) ? '"' + x + '"' : x)).join(' ')
@@ -276,12 +360,51 @@ export class CommandForm {
             validate: (v) => (f.kind === 'option' ? (optionProblem(f.spec, v) ?? true) : true),
         });
         if (typed === undefined)
+            return undefined;
+        this.set(id, many || f.kind === 'extra' ? splitArgs(typed) : typed.trim() ? [typed.trim()] : []);
+        return undefined;
+    }
+    /** Is the problem with a picked path (true = fine)? Moving or switching the data folder has its own rules. */
+    pathProblem(f, picked) {
+        if (this.spec.name === 'storage' && f.kind === 'arg') {
+            const problem = moveProblem(this.ctx.storageRoot, picked, true);
+            return problem ? problem.message : true;
+        }
+        return f.kind === 'option' ? (optionProblem(f.spec, picked) ?? true) : true;
+    }
+    /** Several folders or files (--script ...): a list to add to, change and remove from. */
+    async pathList(id, path, about, kind) {
+        const node = new SchemaNode(z.array(z.string()).describe(about.join(' ')));
+        const edited = await new StringListEditor(this.app, path, node, new ValueEditor(this.app), [], kind, 'Esc keeps it for the command').run(Array.isArray(this.values.get(id)) ? [...this.values.get(id)] : []);
+        if (edited)
+            this.set(id, edited.value);
+        return undefined;
+    }
+    /** projects remove / include / exclude pick from the known projects (or any folder); add takes a folder. */
+    projectAction() {
+        return ['remove', 'include', 'exclude'].includes(this.first());
+    }
+    async projectFolder(id, path, about) {
+        const known = new ProjectsService(this.ctx).list().projects.map((p) => p.folder);
+        const current = this.values.get(id);
+        const picked = await this.app.choose(path, about.join(' '), [...known.map((v) => ({ value: v, label: v })), { value: OTHER, label: 'Another folder…' }], Array.isArray(current) ? current[0] : undefined);
+        if (picked === undefined)
             return;
-        const value = many || f.kind === 'extra' ? splitArgs(typed) : typed.trim() ? [typed.trim()] : [];
-        if (value.length)
-            this.values.set(id, value);
-        else
-            this.values.delete(id);
+        if (picked !== OTHER) {
+            this.set(id, [picked]);
+            return;
+        }
+        const folder = await askPath(this.app, { path, title: 'Choose the folder', about, kind: 'dir' });
+        if (folder !== undefined)
+            this.set(id, [folder]);
+    }
+    /** Nothing to pick from (no saved logins, no running session): say what to do, in the form, without an error. */
+    nothingToChoose(what) {
+        return Theme.warn(what === 'accounts'
+            ? 'No saved logins yet: sign in inside the sandbox, then save it in Accounts.'
+            : what === 'sessions'
+                ? 'No session is running: start an agent first.'
+                : 'There is nothing to choose from yet.');
     }
     /** `data clean` targets, ticked from a list with their sizes (never "all": that is typed on purpose). */
     async dataTargets(path) {

package/dist/cli/menu/data-folder.d.ts

@@ -0,0 +1,18 @@
+import type { Context } from '../commands/context.js';
+import type { App } from '../tui/index.js';
+import type { ShellExit } from './shell.js';
+/** The row in Settings and Maintenance. */
+export declare function dataFolderRow(ctx: Context): {
+    label: string;
+    hint: string;
+    description: string;
+};
+export declare class DataFolderFlow {
+    private readonly app;
+    private readonly ctx;
+    constructor(app: App, ctx: Context);
+    /** The command to run (move or use), or undefined when nothing was chosen. */
+    run(): Promise<ShellExit | undefined>;
+    private measure;
+    private decide;
+}

package/dist/cli/menu/data-folder.js

@@ -0,0 +1,99 @@
+// The "Data folder" row and its flow: shows where the saved data is, lets you pick another folder in the path picker,
+// asks whether to move the data or only switch, and hands the command to run on the normal screen (the move prints its
+// progress there).
+import fs from 'node:fs';
+import { humanBytes } from '../../core/disk.js';
+import { describeDuration, describeSize, estimate, holdsData, measureFolder, moveProblem, moveWarning, } from '../../host/storage/index.js';
+/** Measuring for the dialog stops after this long (the size then reads "at least"). */
+const MEASURE_MS = 8000;
+/** The row in Settings and Maintenance. */
+export function dataFolderRow(ctx) {
+    return {
+        label: 'Data folder',
+        hint: ctx.storageRoot,
+        description: 'Where your tools, logins, history and logs are kept between sandboxes. Press Enter to move them to another folder or drive, or to use a different folder.',
+    };
+}
+export class DataFolderFlow {
+    app;
+    ctx;
+    constructor(app, ctx) {
+        this.app = app;
+        this.ctx = ctx;
+    }
+    /** The command to run (move or use), or undefined when nothing was chosen. */
+    async run() {
+        const from = this.ctx.storageRoot;
+        const exists = fs.existsSync(from);
+        const measured = exists ? this.measure(from) : { bytes: 0, files: 0, partial: false };
+        const size = exists && holdsData(from) ? describeSize(measured) : 'nothing in it yet';
+        const to = await this.app.pickPath({
+            path: ['Data folder'],
+            title: 'Choose the folder for your saved data',
+            about: [
+                'Now: ' + from + ' (' + size + ').',
+                'Pick a new or empty folder to move your data there, or a folder that already holds data to use it.',
+            ],
+            initial: from.replace(/[\\/][^\\/]*$/, '\\'),
+            use: 'use this folder',
+            validate: (picked) => {
+                const problem = moveProblem(from, picked, true);
+                return problem ? problem.message : true;
+            },
+        });
+        if (!to)
+            return undefined;
+        return this.decide(from, to, measured, exists);
+    }
+    measure(from) {
+        const before = this.app.status;
+        this.app.status = () => 'Measuring your saved data…';
+        this.app.redraw();
+        try {
+            return measureFolder(from, MEASURE_MS);
+        }
+        finally {
+            this.app.status = before;
+        }
+    }
+    async decide(from, to, measured, exists) {
+        if (to.toLowerCase() === from.toLowerCase())
+            return undefined;
+        const target = holdsData(to);
+        const lines = [];
+        let canMove = exists && holdsData(from) && !target;
+        if (canMove) {
+            const est = estimate(from, to, measured);
+            lines.push('From: ' + from, 'To:   ' + to, '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 ? to + ' already holds data, so it is used as it is.' : 'There is nothing in ' + from + ' to move.', 'Your data stays where it is.');
+        }
+        const choice = await this.app.dialog({
+            title: canMove ? 'Move your data to ' + to + '?' : 'Use ' + to + '?',
+            lines: [...lines, '', 'Use without moving: the new folder is used from now on and your old data is left behind.'],
+            choices: [
+                ...(canMove ? [{ value: 'move', label: 'Move data', key: 'm' }] : []),
+                { value: 'use', label: 'Switch without moving', key: 's' },
+                { value: 'cancel', label: 'Cancel', key: 'c' },
+            ],
+            initial: 0,
+            escape: 'cancel',
+        });
+        if (choice === 'move')
+            return { kind: 'run', argv: ['storage', 'move', to, '--yes'] };
+        if (choice === 'use')
+            return { kind: 'run', argv: ['storage', 'use', to, '--yes'] };
+        return undefined;
+    }
+}

package/dist/cli/menu/menu.d.ts

@@ -5,7 +5,7 @@ export declare class Menu {
     private readonly app;
     constructor(ctx: Context, runArgv: (argv: string[]) => Promise<number>);
     private status;
-    /** The tabs, in order. */
+    /** The sections, in order. */
     private shell;
     /** Runs the menu until you leave it, or until a command that takes over the terminal (attach) has run. */
     start(): Promise<number>;

package/dist/cli/menu/menu.js

@@ -1,6 +1,6 @@
-// The interactive menu (`sandbox` with no arguments): a full-screen app with seven tabs (Start, Sessions, Sandbox,
-// Apps, Settings, Accounts, Maintenance). The tabs are real screens fed by the services; only what needs the terminal
-// (attach, a start, a log) leaves the menu for a moment, one keypress from its screen.
+// The interactive menu (`sandbox` with no arguments): a full-screen app with seven sections down the left (Agents,
+// Sessions, Sandbox, Apps, Settings, Accounts, Maintenance). The sections are real screens fed by the services; only
+// what needs the terminal (attach, a start, a log) leaves the menu for a moment, one keypress from its screen.
 import fs from 'node:fs';
 import path from 'node:path';
 import { loadConfig } from '../../core/config/index.js';
@@ -13,15 +13,17 @@ import { commandSpec } from '../manifest.js';
 import { AgentCommandsService, LogsService } from '../services/index.js';
 import { App, ExitRequested, Frame, Text, Theme } from '../tui/index.js';
 import { AccountsPage } from './pages/accounts-page.js';
+import { AgentsPage } from './pages/agents-page.js';
 import { AppsPage } from './pages/apps-page.js';
 import { MaintenancePage } from './pages/maintenance-page.js';
 import { SandboxPage } from './pages/sandbox-page.js';
 import { SessionsPage } from './pages/sessions-page.js';
 import { SettingsPage } from './pages/settings-page.js';
-import { StartPage } from './pages/start-page.js';
 import { ConfigFile } from './settings/config-file.js';
 import { Draft } from './settings/draft.js';
 import { Shell } from './shell.js';
+/** Where the menu was last left in this run: it opens there again (a new run opens on Agents). */
+let lastView;
 export class Menu {
     ctx;
     runArgv;
@@ -55,7 +57,7 @@ export class Menu {
             '   ' +
             folder);
     }
-    /** The tabs, in order. */
+    /** The sections, in order. */
     shell() {
         const files = {
             user: ConfigFile.user(this.ctx.loaded.configPath),
@@ -64,11 +66,11 @@ export class Menu {
         const draft = new Draft();
         const { app, ctx } = this;
         return new Shell(app, [
-            new StartPage(app, ctx),
+            new AgentsPage(app, ctx, files.user, draft),
             new SessionsPage(app, ctx),
             new SandboxPage(app, ctx),
             new AppsPage(app, files, draft, ctx.dataPath),
-            new SettingsPage(app, files, draft),
+            new SettingsPage(app, files, draft, ctx),
             new AccountsPage(app, ctx),
             new MaintenancePage(app, ctx),
         ], draft, (saved) => this.applyAgentCommands(saved));
@@ -81,9 +83,10 @@ export class Menu {
         }
         try {
             const shell = this.shell();
-            await shell.openTab(0);
+            await shell.restore(lastView ?? { section: 0, category: undefined });
             for (;;) {
                 const exit = await this.app.show(shell);
+                lastView = shell.view();
                 if (exit.kind === 'quit')
                     return 0;
                 if (exit.kind === 'view')