windows-development-sandbox 1.4.1 → 1.5.0

package/dist/cli/commands/sessions.js

@@ -1,258 +0,0 @@
-// Working with a running sandbox: attach, sessions, status, exec, restart, stop, show/hide. Each knows which project
-// you run it from (project.ts): attach and sessions put that project's sessions first, exec and db run in it, restart
-// restarts its sessions, stop warns about the other projects' sessions.
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { select } from '@inquirer/prompts';
-import _ from 'lodash';
-import { askYesNo } from '../../core/prompt.js';
-import { activeAccount } from '../../host/accounts.js';
-import { execInSandbox, pickSession, pingSandbox, restartSessions, currentSessions, runningSessions, sessionsFirstIn } from '../../host/channel.js';
-import { sessionViewers } from '../../host/attach.js';
-import { insideSandbox, isSandboxRunning } from '../../host/platform.js';
-import { NeedsRestart, readRegistry } from '../../host/projects.js';
-import { guardedProjects, repoFindings } from '../../host/repo-guard.js';
-import { hideSandboxWindow, showSandboxWindow } from '../../host/window.js';
-import { isWithin, projectForGuestDir } from '../../shared/projects.js';
-import { listProjectStatus, listSessions, readSandboxStatus } from '../../shared/rundir.js';
-import { watcherRunning } from '../../sync/watcher.js';
-import { errMsg, fail, safeText, sleep } from '../../core/util.js';
-import { printJson, requireOnPc, requireRunning, sandboxAlive, table } from './context.js';
-import { attachHere, readySandbox } from './launch.js';
-import { hereDir, joinHere, locateHere, provisionJoined } from './project.js';
-import { working } from '../progress.js';
-import { ago, c, shortenMiddle, termWidth } from '../colors.js';
-const viewerText = (v) => (v === undefined ? '-' : v === null ? 'unknown (older session)' : v.remote + ' here, ' + (v.viewers - v.remote) + ' in sandbox');
-const projectOf = (projects, s) => s.project ?? projectForGuestDir(projects, s.cwd)?.name ?? '-';
-export const attach = async (ctx) => {
-    requireOnPc('attach');
-    requireRunning('Start one with: sandbox claude --terminal');
-    const ready = await readySandbox(ctx.dataPath);
-    const id = ctx.options.positionals[0];
-    if (!id && runningSessions(ctx.dataPath).length === 0)
-        await sleep(1500);
-    const here = locateHere(ctx, ready);
-    if (id)
-        return attachHere(ctx, pickSession(ctx.dataPath, id));
-    // Several sessions: choose, this folder's project first (the newest is the default).
-    const running = sessionsFirstIn(runningSessions(ctx.dataPath), here.guestDir);
-    if (running.length > 1 && process.stdin.isTTY && process.stdout.isTTY) {
-        const projects = readRegistry(ctx.storageRoot)?.projects ?? [];
-        const chosen = await select({
-            message: 'Which session?' + (here.project ? ' (' + here.project.name + ' first)' : ''),
-            choices: running.map((s) => ({ value: s.id, name: (here.guestDir && isWithin(here.guestDir, s.cwd) ? '* ' : '  ') + safeText(s.harness).padEnd(9) + ' ' + safeText(projectOf(projects, s)).padEnd(16) + ' ' + ago(s.startedAt).padEnd(11) + ' ' + s.id })),
-        });
-        return attachHere(ctx, pickSession(ctx.dataPath, chosen));
-    }
-    return attachHere(ctx, pickSession(ctx.dataPath, undefined, here.guestDir));
-};
-/** Sessions with who is watching them; `here` marks the ones in the project of the current folder. */
-const listedSessions = async (ctx) => {
-    // Who is attached comes from each session itself, so a terminal that was closed is never counted.
-    const live = isSandboxRunning();
-    // Only this sandbox's sessions are asked (and at most MAX_QUERIED_SESSIONS): the sandbox writes these files.
-    const ask = new Set(live ? currentSessions(ctx.dataPath).map((s) => s.id) : []);
-    const here = live ? locateHere(ctx, readSandboxStatus(ctx.dataPath)) : { guestDir: null };
-    const projects = readRegistry(ctx.storageRoot)?.projects ?? [];
-    return Promise.all(listSessions(ctx.dataPath).map(async (s) => ({
-        ...s, projectName: projectOf(projects, s), here: Boolean(here.guestDir && isWithin(here.guestDir, s.cwd)),
-        ...(ask.has(s.id) ? { viewers: await sessionViewers(s) } : {}),
-    })));
-};
-export const sessions = async (ctx) => {
-    const list = await listedSessions(ctx);
-    if (printJson(ctx, list.map((s) => _.omit(s, 'attach'))))
-        return 0;
-    if (list.length === 0) {
-        console.log('No sessions. Start one with: sandbox claude');
-        return 0;
-    }
-    // This folder's project first, newest first within each group; harness, cwd and times are written by the sandbox.
-    const ordered = [..._.sortBy(list.filter((s) => s.here), (s) => s.startedAt).reverse(), ..._.sortBy(list.filter((s) => !s.here), (s) => s.startedAt).reverse()];
-    const folderWidth = Math.max(16, termWidth() - 80);
-    table([['', 'ID', 'AGENT', 'PROJECT', 'STATE', 'ATTACHED', 'FOLDER', 'STARTED'], ...ordered.map((s) => [
-            s.here ? '*' : '', s.id, safeText(s.harness), safeText(s.projectName ?? '-'), s.phase + (s.exitCode !== undefined ? ' (' + s.exitCode + ')' : ''), viewerText(s.viewers), shortenMiddle(safeText(s.cwd), folderWidth), ago(s.startedAt),
-        ])]);
-    if (list.some((s) => s.here))
-        console.log(c.dim('* = the project of this folder'));
-    return 0;
-};
-/** Running databases by port, from the sandbox's own `sbx-db list` (best effort: unknown when it does not answer). */
-const runningPorts = async (ctx, cwd) => {
-    try {
-        const r = await execInSandbox(ctx.dataPath, ['sbx-db', 'list'], cwd, 30, sandboxAlive);
-        return new Set((r.stdout ?? '').split(/\r?\n/).filter((l) => /\brunning\b/.test(l)).map((l) => Number(/port (\d+)/.exec(l)?.[1])).filter((n) => n > 0));
-    }
-    catch {
-        return null;
-    }
-};
-export const status = async (ctx) => {
-    const running = isSandboxRunning();
-    const sandbox = readSandboxStatus(ctx.dataPath);
-    const registry = running ? readRegistry(ctx.storageRoot) : null;
-    const ready = running && sandbox?.phase === 'ready';
-    const daemon = ready ? await pingSandbox(ctx.dataPath, sandboxAlive).then((r) => r.message, (e) => 'no answer (' + errMsg(e) + ')') : '-';
-    const here = running ? locateHere(ctx, sandbox) : { project: null, guestDir: null };
-    const sessionList = running ? await listedSessions(ctx) : [];
-    const provisioning = running ? listProjectStatus(ctx.dataPath) : [];
-    const ports = ready && sandbox ? await runningPorts(ctx, sandbox.guestWorkspace) : null;
-    const findings = repoFindings(ctx.dataPath);
-    const startedAt = Number(/^(\d+)-/.exec(registry?.launchId ?? sandbox?.launchId ?? '')?.[1]) || null;
-    const projects = (registry?.projects ?? []).map((p) => {
-        const prov = provisioning.find((s) => s.name.toLowerCase() === p.name.toLowerCase());
-        const own = sessionList.filter((s) => s.phase === 'running' && projectForGuestDir(registry?.projects ?? [], s.cwd)?.name === p.name);
-        return {
-            name: p.name, host: p.host, guest: p.guest, mechanism: p.mechanism, here: here.project?.name === p.name,
-            setup: prov ? { phase: prov.phase, message: safeText(prov.message) } : { phase: 'not set up yet', message: 'set up when you first start a session or command there' },
-            databases: (prov?.databases ?? []).map((d) => ({ database: safeText(d.database), port: d.port, state: ports ? (ports.has(d.port) ? 'running' : 'stopped') : 'unknown' })),
-            sessions: own.map((s) => ({ id: s.id, harness: safeText(s.harness), viewers: viewerText(s.viewers), started: s.startedAt })),
-            // With several guarded folders each finding starts with its folder.
-            repoGuard: findings.filter((f) => f.detail.toLowerCase().startsWith(p.host.toLowerCase() + ':')).map((f) => f.kind + ': ' + safeText(f.detail)),
-        };
-    });
-    const info = {
-        sandbox: {
-            running, phase: running ? sandbox?.phase ?? 'unknown' : 'stopped', message: sandbox?.message, headless: sandbox?.headless,
-            uptime: running && startedAt ? ago(startedAt).replace(' ago', '') : null, daemon, account: activeAccount(ctx.dataPath), syncWatcher: watcherRunning(ctx.dataPath),
-        },
-        here: { folder: hereDir(ctx), project: here.project?.name ?? null, guest: here.guestDir },
-        roots: registry?.roots ?? [],
-        projects,
-        otherSessions: sessionList.filter((s) => s.phase === 'running' && !projects.some((p) => p.sessions.some((x) => x.id === s.id))).map((s) => ({ id: s.id, harness: safeText(s.harness), cwd: safeText(s.cwd) })),
-        repoGuard: { guarded: guardedProjects(ctx.dataPath).length, findings: findings.map((f) => f.kind + ': ' + f.detail) },
-    };
-    if (printJson(ctx, info))
-        return 0;
-    const yesNo = (v) => (typeof v === 'boolean' ? (v ? 'yes' : 'no') : String(v ?? '-'));
-    table(Object.entries(info.sandbox).map(([k, v]) => [_.startCase(k), safeText(yesNo(v))]));
-    if (!running)
-        return 0;
-    console.log('\n' + c.bold('Projects') + c.dim('  (* = this folder: ' + info.here.folder + (info.here.project ? '' : ', not in this sandbox') + ')'));
-    for (const p of projects) {
-        console.log((p.here ? '* ' : '  ') + c.bold(p.name) + '  ' + p.host + '  ->  ' + p.guest + c.dim('  (' + (p.mechanism === 'launch' ? 'started from here' : p.mechanism === 'root' ? 'in a project root' : p.mechanism === 'boot' ? 'mapped at start' : 'wsb share') + ')'));
-        console.log('      setup: ' + p.setup.phase + (p.setup.phase === 'ready' ? '' : ' - ' + shortenMiddle(p.setup.message, termWidth() - 20)));
-        if (p.databases.length)
-            console.log('      databases: ' + p.databases.map((d) => d.database + ' :' + d.port + ' ' + d.state).join(', '));
-        for (const s of p.sessions)
-            console.log('      session ' + s.id + '  ' + s.harness + '  ' + s.viewers + '  ' + ago(s.started));
-        for (const f of p.repoGuard)
-            console.log('      ' + c.yellow('guard: ' + f));
-    }
-    for (const r of info.roots)
-        console.log('  root  ' + r.host + '  ->  ' + r.guest + c.dim('  (every project in it opens without a restart)'));
-    for (const s of info.otherSessions)
-        console.log('  session ' + s.id + '  ' + s.harness + '  ' + s.cwd);
-    console.log('\n' + c.bold('Repo guard') + '  ' + info.repoGuard.guarded + ' folder(s) guarded; ' + (findings.length ? c.yellow(findings.length + ' change(s) neutralised:') : 'nothing from the sandbox needed neutralising'));
-    for (const f of info.repoGuard.findings.slice(-10))
-        console.log('  ' + c.yellow(safeText(f)));
-    return 0;
-};
-/** What a command run in the sandbox printed (text from the sandbox: through safeText), or why it failed. */
-const printExecResult = (result) => {
-    if (result.stdout)
-        process.stdout.write(safeText(result.stdout));
-    if (result.stderr)
-        process.stderr.write(safeText(result.stderr));
-    if (!result.ok && !result.stdout && !result.stderr)
-        console.error(safeText(result.message));
-};
-/** The guest folder for this folder, joining the running sandbox (and setting the project up) when needed. */
-const guestFolderHere = async (ctx, what) => {
-    const ready = await readySandbox(ctx.dataPath);
-    try {
-        // A command needs no restart for what the project wants at boot: it runs without them (and says so).
-        const joined = await joinHere(ctx, ready, { noRestart: true });
-        for (const note of joined.notes)
-            console.error(note);
-        await provisionJoined(ctx, joined);
-        return joined.guestDir;
-    }
-    catch (e) {
-        if (!(e instanceof NeedsRestart))
-            throw e;
-        return fail(hereDir(ctx) + ' is not in the running sandbox (' + e.reason + '), so "sandbox ' + what + '" cannot run there.', 'sandbox claude (or sandbox start) from that folder offers a restart that adds it; or add its parent folder as a root: sandbox projects roots add "' + path.dirname(e.hostDir) + '"');
-    }
-};
-export const exec = async (ctx) => {
-    const command = [...ctx.options.positionals, ...ctx.options.passthrough];
-    if (command.length === 0)
-        fail('No command given.', 'Usage: sandbox exec [--timeout <s>] -- <command> [args...]');
-    requireOnPc('exec');
-    requireRunning();
-    const cwd = await guestFolderHere(ctx, 'exec');
-    const result = await execInSandbox(ctx.dataPath, command, cwd, ctx.options.timeout, sandboxAlive);
-    if (!printJson(ctx, result))
-        printExecResult(result);
-    return result.exitCode ?? 1;
-};
-/** `sandbox db`: runs the sandbox's own `sbx-db` in this folder's project, which knows its database versions and ports. */
-export const db = async (ctx) => {
-    const [action = 'list', name] = ctx.options.positionals;
-    if (!['list', 'start', 'stop'].includes(action))
-        fail('Unknown db action "' + action + '".', 'Use: sandbox db  (list)  or  sandbox db start|stop <postgres|mysql|mongodb|redis|dynamodb>');
-    if (action !== 'list' && !name)
-        fail('Which database?', 'Usage: sandbox db ' + action + ' <postgres|mysql|mongodb|redis|dynamodb>');
-    // Already inside the sandbox: run the database tool here instead of asking the sandbox from outside.
-    if (insideSandbox())
-        return spawnSync(process.execPath, [path.join(ctx.packageRoot, 'dist', 'runtime', 'db.js'), action, ...(name ? [name] : [])], { stdio: 'inherit', windowsHide: true }).status ?? 1;
-    requireRunning('Start one with: sandbox start --database <name>');
-    const cwd = await guestFolderHere(ctx, 'db');
-    // Starting can download the database the first time.
-    const result = await working((action === 'list' ? 'Asking' : action === 'start' ? 'Starting' : 'Stopping') + ' the database' + (name ? ' ' + name : 's') + ' in the sandbox', () => execInSandbox(ctx.dataPath, ['sbx-db', action, ...(name ? [name] : [])], cwd, 1800, sandboxAlive));
-    printExecResult(result);
-    return result.exitCode ?? 1;
-};
-/** Restarts this folder's project's sessions (--all: every session). */
-export const restart = async (ctx) => {
-    requireOnPc('restart');
-    requireRunning();
-    const here = locateHere(ctx, readSandboxStatus(ctx.dataPath));
-    const scope = ctx.options.all || !here.project ? undefined : here.project.guest;
-    if (!scope && !ctx.options.all)
-        console.log(c.dim(hereDir(ctx) + ' is not a project of the running sandbox: restarting every session.'));
-    console.log(safeText((await working('Restarting the agents' + (scope ? ' of ' + here.project?.name : ''), () => restartSessions(ctx.dataPath, ctx.options.harness ?? null, sandboxAlive, scope))).message));
-    return 0;
-};
-export const stop = async (ctx) => {
-    requireOnPc('stop');
-    if (!isSandboxRunning()) {
-        console.log('No Windows Sandbox is running.');
-        return 0;
-    }
-    const sandbox = readSandboxStatus(ctx.dataPath) ?? fail('This sandbox was not started by this tool.', 'Close its window instead.');
-    // Stopping ends every project's sessions, not just this folder's: say which, and ask when others would end too.
-    const here = locateHere(ctx, sandbox);
-    const running = currentSessions(ctx.dataPath);
-    const others = running.filter((s) => !(here.guestDir && isWithin(here.project?.guest ?? here.guestDir, s.cwd)));
-    if (running.length)
-        console.log('Stopping ends ' + running.length + ' session(s): ' + running.map((s) => safeText(s.harness) + ' in ' + safeText(s.project ?? path.win32.basename(s.cwd))).join(', ') + '.');
-    if (others.length && !ctx.options.yes) {
-        // A script must never end other projects' sessions by accident: without a terminal to ask in, it needs --yes.
-        const interactive = process.stdin.isTTY && process.stdout.isTTY;
-        if (!interactive)
-            fail(others.length + ' of these sessions belong to other projects, so the sandbox was not stopped.', 'Stop it anyway with: sandbox stop --yes');
-        if (!(await askYesNo(others.length + ' of them belong to other projects. Stop the whole sandbox?'))) {
-            console.log('Nothing changed.');
-            return 1;
-        }
-    }
-    await working('Asking the sandbox to shut down', () => execInSandbox(ctx.dataPath, ['C:\\Windows\\System32\\shutdown.exe', '/s', '/t', '2'], sandbox.guestWorkspace, 30, sandboxAlive));
-    console.log('Sandbox is shutting down; history and claude-mem sync back when it closes.');
-    return 0;
-};
-export const show = (ctx) => {
-    requireOnPc('show');
-    requireRunning();
-    if (!showSandboxWindow(ctx.storageRoot))
-        fail('Could not find the Windows Sandbox window.', 'It may still be starting; try again in a few seconds.');
-    return 0;
-};
-export const hide = async (ctx) => {
-    requireOnPc('hide');
-    requireRunning();
-    if (!(await hideSandboxWindow(ctx.storageRoot, 5)))
-        fail('Could not find a visible Windows Sandbox window.', 'It may already be hidden (sbx-show brings it back).');
-    console.log('Sandbox window hidden. Bring it back with: sbx-show');
-    return 0;
-};

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

@@ -1,30 +0,0 @@
-import { App } from '../../tui/index.js';
-import { SchemaNode } from './schema-node.js';
-/** The new value, or undefined when you backed out without changing anything. */
-export type Edited = {
-    value: unknown;
-} | undefined;
-/** A value in one short line, for the right-hand column. */
-export declare const formatValue: (value: unknown, max?: number) => string;
-/** Optional extra knowledge: values to suggest for some settings (the configured agents for defaultHarness). */
-export interface EditorHints {
-    suggestions?: (key: string[]) => string[] | undefined;
-}
-export declare class ValueEditor {
-    private readonly app;
-    private readonly hints;
-    constructor(app: App, hints?: EditorHints);
-    edit(path: string[], key: string[], node: SchemaNode, current: unknown): Promise<Edited>;
-    private pick;
-    private suggest;
-    private json;
-}
-/** One object as a form: each field with its value, Enter to change it, r to clear an optional one. */
-export declare class ObjectEditor {
-    private readonly app;
-    private readonly path;
-    private readonly node;
-    private readonly editor;
-    constructor(app: App, path: string[], node: SchemaNode, editor: ValueEditor);
-    run(start: Record<string, unknown>, isNew?: boolean): Promise<Edited>;
-}

package/dist/cli/menu/settings/editors.js

@@ -1,305 +0,0 @@
-// Editing one value with the screen that fits it: on/off flips, choices are picked from a list, numbers and text are
-// typed and checked as you type, lists and maps get an editor of their own (add, change, remove), and objects (a
-// mapped folder, an agent) open as a small form. JSON is only the last resort for shapes none of these fit.
-import _ from 'lodash';
-import { Text, Theme } from '../../tui/index.js';
-/** A value in one short line, for the right-hand column. */
-export const formatValue = (value, max = 60) => {
-    if (value === undefined)
-        return Theme.muted('not set');
-    if (value === true)
-        return Theme.ok('On');
-    if (value === false)
-        return Theme.muted('Off');
-    if (value === null)
-        return Theme.muted('none');
-    if (typeof value === 'string')
-        return value === '' ? Theme.muted('(empty)') : Text.truncate(value, max);
-    if (typeof value === 'number')
-        return String(value);
-    if (Array.isArray(value))
-        return value.length === 0 ? Theme.muted('none') : Text.truncate(value.length + ' · ' + value.map((v) => (typeof v === 'object' ? summary(v) : String(v))).join(', '), max);
-    const keys = Object.keys(value);
-    return keys.length ? Text.truncate(keys.length + ' · ' + keys.join(', '), max) : Theme.muted('none');
-};
-/** A one-line name for an object in a list (a mapping's folders, an agent's package ...). */
-const summary = (value) => {
-    if (!_.isPlainObject(value))
-        return String(value);
-    const o = value;
-    const strings = Object.entries(o).filter(([, v]) => typeof v === 'string' && v);
-    if (typeof o.host === 'string' && typeof o.guest === 'string')
-        return o.host + ' → ' + o.guest + (o.readOnly ? ' (read-only)' : '');
-    return strings.slice(0, 2).map(([, v]) => v).join(' · ') || '{ ' + Object.keys(o).join(', ') + ' }';
-};
-const choiceLabel = (v) => (v === true ? 'On' : v === false ? 'Off' : String(v));
-export class ValueEditor {
-    app;
-    hints;
-    constructor(app, hints = {}) {
-        this.app = app;
-        this.hints = hints;
-    }
-    async edit(path, key, node, current) {
-        const about = node.description ? [node.description] : [];
-        const suggestions = this.hints.suggestions?.(key);
-        if (suggestions?.length && node.type === 'string')
-            return this.suggest(path, key, node, current, suggestions);
-        switch (node.editor) {
-            case 'boolean': return { value: !(current ?? false) };
-            case 'choice': return this.pick(path, node, current, node.choiceValues);
-            case 'union': {
-                const open = node.openOption;
-                const custom = '@custom';
-                const picked = await this.app.choose(path, node.description ?? '', [...node.choiceValues.map((v) => ({ value: v, label: choiceLabel(v) })), ...(open ? [{ value: custom, label: 'Custom ' + open.type + '…', description: 'Type a ' + open.type + ' of your own.' }] : [])], node.choiceValues.includes(current) ? current : open && current !== undefined ? custom : undefined);
-                if (picked === undefined)
-                    return undefined;
-                return picked === custom && open ? this.edit(path, key, open, node.choiceValues.includes(current) ? undefined : current) : { value: picked };
-            }
-            case 'number': {
-                const range = node.min !== undefined || node.max !== undefined ? ' (' + (node.min ?? '…') + ' to ' + (node.max ?? '…') + ')' : '';
-                const typed = await this.app.text({ path, label: Text.humanize(key[key.length - 1]) + range, about, initial: current === undefined ? '' : String(current), validate: (v) => (v.trim() === '' || !Number.isFinite(Number(v)) ? 'Enter a number.' : node.check(Number(v))) });
-                return typed === undefined ? undefined : { value: Number(typed) };
-            }
-            case 'string': {
-                const typed = await this.app.text({ path, label: Text.humanize(key[key.length - 1]), about, initial: typeof current === 'string' ? current : '', allowEmpty: node.check('') === true, validate: (v) => node.check(v) });
-                return typed === undefined ? undefined : { value: typed };
-            }
-            case 'choice-list': {
-                const ticked = Array.isArray(current) ? current : [];
-                const picked = await this.app.list({ path, intro: node.description, multi: true, items: node.element.choices.map((v) => ({ value: v, label: String(v), checked: ticked.includes(v) })) });
-                return picked.kind === 'multi' ? { value: picked.values } : undefined;
-            }
-            case 'string-list': return new StringListEditor(this.app, path, node, this).run(Array.isArray(current) ? current : []);
-            case 'string-map': return new MapEditor(this.app, path, node, this).run(_.isPlainObject(current) ? current : {});
-            case 'object-list': return new ObjectListEditor(this.app, path, node, this).run(Array.isArray(current) ? current : []);
-            case 'object-map': return new ObjectMapEditor(this.app, path, node, this).run(_.isPlainObject(current) ? current : {});
-            case 'object': return new ObjectEditor(this.app, path, node, this).run(_.isPlainObject(current) ? current : node.initial());
-            default: return this.json(path, key, node, current);
-        }
-    }
-    async pick(path, node, current, values) {
-        const picked = await this.app.choose(path, node.description ?? '', values.map((v) => ({ value: v, label: choiceLabel(v) })), current);
-        return picked === undefined ? undefined : { value: picked };
-    }
-    async suggest(path, key, node, current, suggestions) {
-        const other = '@other';
-        const picked = await this.app.choose(path, node.description ?? '', [...suggestions.map((s) => ({ value: s, label: s })), { value: other, label: 'Other…', description: 'Type a name that is not in the list.' }], typeof current === 'string' ? current : undefined);
-        if (picked === undefined)
-            return undefined;
-        if (picked !== other)
-            return { value: picked };
-        const typed = await this.app.text({ path, label: Text.humanize(key[key.length - 1]), initial: typeof current === 'string' ? current : '', validate: (v) => node.check(v) });
-        return typed === undefined ? undefined : { value: typed };
-    }
-    async json(path, key, node, current) {
-        const typed = await this.app.text({
-            path, label: Text.humanize(key[key.length - 1]) + ' (JSON)', about: node.description ? [node.description] : [], initial: current === undefined ? '' : JSON.stringify(current),
-            validate: (v) => { try {
-                return node.check(JSON.parse(v));
-            }
-            catch {
-                return 'This is not valid JSON.';
-            } },
-        });
-        return typed === undefined ? undefined : { value: JSON.parse(typed) };
-    }
-}
-// ---- collections -----------------------------------------------------------------------------------------------------
-const SAVE = '@save';
-const ADD = '@add';
-/**
- * The shared shape of the list and map editors: a working copy shown as a list with "Save" and "Add" at the top, Enter
- * to change an entry, d to delete it. Esc with unsaved changes asks first.
- */
-class CollectionEditor {
-    app;
-    path;
-    node;
-    editor;
-    value;
-    original;
-    constructor(app, path, node, editor) {
-        this.app = app;
-        this.path = path;
-        this.node = node;
-        this.editor = editor;
-    }
-    noun = 'entry';
-    async run(start) {
-        this.original = structuredClone(start);
-        this.value = structuredClone(start);
-        let focus;
-        for (;;) {
-            const dirty = !_.isEqual(this.value, this.original);
-            const entries = this.entries();
-            const picked = await this.app.list({
-                path: this.path,
-                intro: this.node.description,
-                items: [
-                    { value: SAVE, label: dirty ? Theme.ok(Theme.glyph.ok + ' Save changes') : Theme.muted(Theme.glyph.ok + ' Done (no changes)'), section: 'Actions' },
-                    { value: ADD, label: '+ Add ' + this.noun, section: 'Actions' },
-                    ...entries.map((e) => ({ ...e, section: entries.length + ' ' + this.noun + (entries.length === 1 ? '' : 's') })),
-                ],
-                startAt: focus,
-                actions: [{ key: 'd', label: 'delete' }, ...(this.move ? [{ key: 'u', label: 'move up' }, { key: 'j', label: 'move down' }] : [])],
-                empty: 'No ' + this.noun + 's yet.',
-            });
-            if (picked.kind === 'back') {
-                if (!dirty || await this.app.confirm({ path: this.path, question: 'Discard your changes?', yes: 'Discard', no: 'Keep editing', initial: false, danger: true }))
-                    return undefined;
-                continue;
-            }
-            if (picked.kind === 'pick' && picked.value === SAVE)
-                return dirty ? { value: this.value } : undefined;
-            if (picked.kind === 'pick' && picked.value === ADD) {
-                await this.add();
-                continue;
-            }
-            const id = picked.kind === 'pick' || picked.kind === 'action' ? picked.value : undefined;
-            if (id === undefined || id === SAVE || id === ADD)
-                continue;
-            focus = id;
-            if (picked.kind === 'pick')
-                await this.open(id);
-            else if (picked.kind === 'action' && picked.key === 'd')
-                this.remove(id);
-            else if (picked.kind === 'action' && this.move)
-                focus = this.move(id, picked.key === 'u' ? -1 : 1) ?? id;
-        }
-    }
-}
-/** A list of strings (project roots, scripts, extra packages ...). */
-class StringListEditor extends CollectionEditor {
-    noun = 'item';
-    entries() { return this.value.map((v, i) => ({ value: String(i), label: v || Theme.muted('(empty)') })); }
-    async ask(initial) {
-        const element = this.node.element;
-        return this.app.text({ path: this.path, label: 'Value', about: this.node.description ? [this.node.description] : [], initial, validate: (v) => element.check(v) });
-    }
-    async add() { const v = await this.ask(''); if (v !== undefined)
-        this.value.push(v); }
-    async open(id) { const v = await this.ask(this.value[Number(id)]); if (v !== undefined)
-        this.value[Number(id)] = v; }
-    remove(id) { this.value.splice(Number(id), 1); }
-    move(id, by) {
-        const from = Number(id);
-        const to = Math.max(0, Math.min(this.value.length - 1, from + by));
-        const [item] = this.value.splice(from, 1);
-        this.value.splice(to, 0, item);
-        return String(to);
-    }
-}
-/** A map of names to simple values (environment variables). */
-class MapEditor extends CollectionEditor {
-    noun = 'variable';
-    entries() { return Object.entries(this.value).map(([k, v]) => ({ value: k, label: k, hint: formatValue(v) })); }
-    async add() {
-        const name = await this.app.text({ path: this.path, label: 'Name', about: ['Letters, digits and _ only, e.g. NPM_CONFIG_REGISTRY.'], validate: (v) => (this.value[v] !== undefined ? 'That name is there already.' : /^[A-Za-z_][A-Za-z0-9_]*$/.test(v) ? true : 'Letters, digits and _ only.') });
-        if (name === undefined)
-            return;
-        const edited = await this.editor.edit([...this.path, name], [name], this.node.element, this.node.element.initial());
-        if (edited)
-            this.value[name] = edited.value;
-    }
-    async open(id) {
-        const edited = await this.editor.edit([...this.path, id], [id], this.node.element, this.value[id]);
-        if (edited)
-            this.value[id] = edited.value;
-    }
-    remove(id) { delete this.value[id]; }
-}
-/** A list of objects (mapped folders). */
-class ObjectListEditor extends CollectionEditor {
-    noun = 'entry';
-    entries() { return this.value.map((v, i) => ({ value: String(i), label: summary(v) })); }
-    async add() {
-        const edited = await new ObjectEditor(this.app, [...this.path, 'New'], this.node.element, this.editor).run(this.node.element.initial(), true);
-        if (edited)
-            this.value.push(edited.value);
-    }
-    async open(id) {
-        const edited = await new ObjectEditor(this.app, [...this.path, summary(this.value[Number(id)])], this.node.element, this.editor).run(this.value[Number(id)]);
-        if (edited)
-            this.value[Number(id)] = edited.value;
-    }
-    remove(id) { this.value.splice(Number(id), 1); }
-}
-/** A map of names to objects (agents). */
-class ObjectMapEditor extends CollectionEditor {
-    noun = 'entry';
-    entries() { return Object.entries(this.value).map(([k, v]) => ({ value: k, label: k, hint: Theme.muted(summary(v)) })); }
-    async add() {
-        const name = await this.app.text({ path: this.path, label: 'Name', validate: (v) => (this.value[v] !== undefined ? 'That name is there already.' : /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(v) ? true : 'Letters, digits, . _ and - only.') });
-        if (name === undefined)
-            return;
-        const edited = await new ObjectEditor(this.app, [...this.path, name], this.node.element, this.editor).run(this.node.element.initial(), true);
-        if (edited)
-            this.value[name] = edited.value;
-    }
-    async open(id) {
-        const edited = await new ObjectEditor(this.app, [...this.path, id], this.node.element, this.editor).run(this.value[id]);
-        if (edited)
-            this.value[id] = edited.value;
-    }
-    remove(id) { delete this.value[id]; }
-}
-/** One object as a form: each field with its value, Enter to change it, r to clear an optional one. */
-export class ObjectEditor {
-    app;
-    path;
-    node;
-    editor;
-    constructor(app, path, node, editor) {
-        this.app = app;
-        this.path = path;
-        this.node = node;
-        this.editor = editor;
-    }
-    async run(start, isNew = false) {
-        const value = structuredClone(start);
-        let focus;
-        let notice;
-        for (;;) {
-            const dirty = isNew || !_.isEqual(value, start);
-            const problem = this.node.check(value);
-            const fields = this.node.children();
-            const picked = await this.app.list({
-                path: this.path,
-                intro: this.node.description,
-                notice,
-                items: [
-                    { value: SAVE, label: problem === true ? (dirty ? Theme.ok(Theme.glyph.ok + ' Save') : Theme.muted(Theme.glyph.ok + ' Done (no changes)')) : Theme.warn(Theme.glyph.cross + ' Not complete yet'), description: problem === true ? undefined : problem, section: 'Actions' },
-                    ...fields.map(([name, field]) => ({ value: name, label: Text.humanize(name), hint: formatValue(value[name]), description: field.description, section: 'Fields' })),
-                ],
-                startAt: focus,
-                actions: [{ key: 'r', label: 'clear' }],
-            });
-            notice = undefined;
-            if (picked.kind === 'back') {
-                if (!dirty || await this.app.confirm({ path: this.path, question: 'Discard your changes?', yes: 'Discard', no: 'Keep editing', initial: false, danger: true }))
-                    return undefined;
-                continue;
-            }
-            if (picked.kind === 'pick' && picked.value === SAVE) {
-                if (problem !== true) {
-                    notice = Theme.warn(problem);
-                    continue;
-                }
-                return dirty ? { value } : undefined;
-            }
-            const name = picked.kind === 'pick' || picked.kind === 'action' ? picked.value : undefined;
-            if (!name || name === SAVE)
-                continue;
-            focus = name;
-            const field = this.node.child(name);
-            if (picked.kind === 'action') {
-                delete value[name];
-                continue;
-            }
-            const edited = await this.editor.edit([...this.path, Text.humanize(name)], [name], field, value[name]);
-            if (edited)
-                value[name] = edited.value;
-        }
-    }
-}

package/dist/cli/progress.d.ts

@@ -1,24 +0,0 @@
-/** Can a line be redrawn in place? */
-export declare const canAnimate: (env: NodeJS.ProcessEnv, isTTY: boolean) => boolean;
-/** "12 s", "2 min 5 s". */
-export declare const elapsed: (ms: number) => string;
-/** One line of progress: `line` is shown, `key` changes when it is worth a new plain line, `what` names what runs. */
-export interface Progressing {
-    line: string;
-    key: string;
-    what: string;
-}
-/**
- * Follows long work (a sandbox's boot): on a terminal one line redrawn in place with the time so far; without one a
- * plain line each time `key` changes. When nothing changes for `stallMs` it says so (stall(what, ms)). A failure first
- * prints where it stopped, then rethrows.
- */
-export declare const follow: <T>(show: () => Progressing, work: () => Promise<T>, o: {
-    stallMs?: number;
-    stall: (what: string, ms: number) => string;
-}) => Promise<T>;
-/**
- * Shows `message` while work runs and removes the line afterwards. The spinner only moves while the event loop is free
- * (waiting on the sandbox); for long synchronous work (measuring folders) the static line is what you see.
- */
-export declare const working: <T>(message: string | (() => string), work: () => Promise<T> | T, enabled?: boolean) => Promise<T>;