windows-development-sandbox 1.1.0 → 1.4.1

package/dist/cli/menu-multi.js

@@ -1,82 +0,0 @@
-// The menu's "Start several agents": projects, then agents for each, then options; it only builds a command line
-// (sandbox launch --session <agent>@<folder> ...), so "repeat last" works and typing it does the same.
-import fs from 'node:fs';
-import path from 'node:path';
-import { checkbox, confirm, input, select } from '@inquirer/prompts';
-import { assertSafeWorkspace } from '../core/safe-paths.js';
-import { expandPath, errMsg } from '../core/util.js';
-import { readKnown } from '../host/projects.js';
-import { isWithin } from '../shared/projects.js';
-import { c, pageSizeFor, shortenMiddle, termWidth } from './colors.js';
-import { commandLine } from './history.js';
-const ADD = '@add';
-/** Folders worth offering: this one, the projects started before, and the folders inside your roots. */
-export const candidateFolders = (ctx, cwd = process.cwd()) => {
-    const roots = ctx.loaded.config.projects.roots.map((r) => expandPath(r, ctx.loaded.base));
-    const inRoots = roots.flatMap((r) => { try {
-        return fs.readdirSync(r, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.isSymbolicLink() && !e.name.startsWith('.')).slice(0, 200).map((e) => path.join(r, e.name));
-    }
-    catch {
-        return [];
-    } });
-    const all = [path.resolve(cwd), ...readKnown(ctx.storageRoot).map((k) => k.host), ...inRoots];
-    return all.filter((f, i) => all.findIndex((g) => g.toLowerCase() === f.toLowerCase()) === i && fs.existsSync(f));
-};
-/** The command line for several sessions: one --session per (agent, folder), with the shared options. */
-export const severalAgentsArgv = (sessions, o) => ['launch', ...sessions.flatMap((s) => ['--session', s.harness + '@' + s.folder]), ...(o.headless ? ['--headless'] : []), ...(o.attachFirst ? ['-t'] : [])];
-export const askSeveralAgents = async (ctx) => {
-    const here = path.resolve(process.cwd());
-    const width = Math.max(20, termWidth() - 14);
-    let folders = await checkbox({
-        message: 'Which projects? (each gets its sessions; all of them are mapped into one sandbox)',
-        pageSize: pageSizeFor(16),
-        choices: [
-            ...candidateFolders(ctx).map((f) => ({ value: f, name: shortenMiddle(f, width) + (isWithin(f, here) && isWithin(here, f) ? c.dim('  (this folder)') : ''), checked: f.toLowerCase() === here.toLowerCase() })),
-            { value: ADD, name: 'Add a folder...' },
-        ],
-    });
-    if (folders.includes(ADD)) {
-        const extra = await input({
-            message: 'Folder to add:',
-            validate: (v) => {
-                const dir = path.resolve(v.trim());
-                if (!v.trim() || !fs.existsSync(dir) || !fs.statSync(dir).isDirectory())
-                    return 'Not a folder: ' + dir;
-                try {
-                    assertSafeWorkspace(dir, ctx.packageRoot, ctx.storageRoot);
-                    return true;
-                }
-                catch (e) {
-                    return errMsg(e);
-                }
-            },
-        });
-        folders = [...folders.filter((f) => f !== ADD), path.resolve(extra.trim())];
-    }
-    if (!folders.length)
-        return null;
-    const agents = Object.keys(ctx.loaded.config.harnesses);
-    const sessions = [];
-    for (const folder of folders) {
-        const picked = await checkbox({
-            message: 'Agents for ' + shortenMiddle(folder, width - 10) + ' (one session each):',
-            pageSize: pageSizeFor(agents.length),
-            choices: agents.map((a) => ({ value: a, name: a, checked: a === ctx.loaded.config.defaultHarness })),
-            required: true,
-        });
-        sessions.push(...picked.map((harness) => ({ harness, folder })));
-    }
-    const headless = await confirm({ message: 'Hide the sandbox window (headless)?', default: ctx.loaded.config.sandbox.headless });
-    const attach = await select({
-        message: 'Attach this terminal to:',
-        choices: [{ name: 'none (each has a tab inside; sandbox attach shows any of them)', value: -1 }, ...sessions.map((s, i) => ({ name: s.harness + ' in ' + shortenMiddle(s.folder, width - 20), value: i }))],
-        default: 0,
-    });
-    // The one to attach goes first: -t attaches the first session.
-    const ordered = attach >= 0 ? [sessions[attach], ...sessions.filter((_s, i) => i !== attach)] : sessions;
-    const projects = [...new Set(sessions.map((s) => path.basename(s.folder)))];
-    console.log('Start 1 sandbox with ' + sessions.length + ' session' + (sessions.length === 1 ? '' : 's') + ': ' + ordered.map((s) => s.harness + ' in ' + path.basename(s.folder)).join(', ') + ' - map ' + projects.join(' and '));
-    const argv = severalAgentsArgv(ordered, { headless, attachFirst: attach >= 0 });
-    console.log(c.dim('  ' + commandLine(argv)));
-    return await confirm({ message: 'Start them?', default: true }) ? argv : null;
-};

package/dist/cli/menu.d.ts

@@ -1,14 +0,0 @@
-import type { Context } from './commands/context.js';
-import { splitArgs } from './args.js';
-import { type CommandSpecT, type OptionSpecT } from './manifest.js';
-/** Splits "a b 'c d'" like a shell would (enough for agent arguments and exec commands). */
-export { splitArgs };
-/** What this option accepts, checked while typing (undefined = anything). */
-export declare const optionProblem: (o: OptionSpecT, v: string) => string | undefined;
-/** Asks everything a command takes and returns its argv (or null when the user backs out). */
-export declare const askCommand: (ctx: Context, spec: CommandSpecT, preset?: string[]) => Promise<string[] | null>;
-/**
- * Runs the menu until Exit, or until a command that takes over the terminal (launch, attach) has run. `run` executes
- * an argv exactly like typing it.
- */
-export declare const menu: (ctx: Context, run: (argv: string[]) => Promise<number>) => Promise<number>;

package/dist/cli/menu.js

@@ -1,290 +0,0 @@
-// The interactive menu (`sandbox` with no arguments). Built from manifest.ts: pick a command, answer one question per
-// argument and option (on/off options as checkboxes), see the exact command line, run it. The command line it shows is
-// what you would type yourself, and the last one is offered again at the top next time.
-import fs from 'node:fs';
-import path from 'node:path';
-import { checkbox, confirm, input, select, Separator } from '@inquirer/prompts';
-import { humanBytes } from '../core/disk.js';
-import { errMsg, fail } from '../core/util.js';
-import { listAccounts } from '../host/accounts.js';
-import { runningSessions } from '../host/channel.js';
-import { isSandboxRunning } from '../host/platform.js';
-import { cleanTargetOf, collectDataEntries } from './commands/data/collect.js';
-import { c, clearScreen, pageSizeFor, shorten, shortenMiddle, termWidth } from './colors.js';
-import { commandLine, readHistory } from './history.js';
-import { settingsMenu } from './settings/index.js';
-import { splitArgs } from './args.js';
-import { syncAgentCommands } from './commands/agent-commands.js';
-import { loadConfig } from '../core/config.js';
-import { askedWhen, COMMANDS, Group } from './manifest.js';
-import { askSeveralAgents } from './menu-multi.js';
-import { validNodeSpec, validPythonSpec } from './validate.js';
-// ---- the screen ------------------------------------------------------------------------------------------------------
-/** The settings screen may have switched agentCommands (Beta): apply it now, from the saved file. */
-const applyAgentCommands = (ctx) => {
-    try {
-        syncAgentCommands(ctx, loadConfig(ctx.loaded.configPath ?? undefined).config);
-    }
-    catch (e) {
-        console.warn('Agent commands (Beta): ' + errMsg(e));
-    }
-};
-/** Waits for one key, so the output of a command stays on screen until you have read it. Ctrl+C leaves. */
-const pressAnyKey = (message) => new Promise((resolve) => {
-    process.stdout.write('\n' + c.dim(message));
-    const { stdin } = process;
-    stdin.setRawMode(true);
-    stdin.resume();
-    stdin.once('data', (key) => {
-        stdin.setRawMode(false);
-        stdin.pause();
-        process.stdout.write('\n');
-        if (key[0] === 3)
-            process.exit(130);
-        resolve();
-    });
-});
-// ---- asking for one command ------------------------------------------------------------------------------------------
-/** Values for a choices list the manifest names (filled in from config and the running sandbox). */
-const choicesFor = (ctx, choices) => {
-    if (Array.isArray(choices))
-        return choices;
-    if (choices === 'harnesses')
-        return Object.keys(ctx.loaded.config.harnesses);
-    if (choices === 'accounts')
-        return listAccounts(ctx.storageRoot, ctx.dataPath).map((a) => a.name);
-    if (choices === 'sessions')
-        return isSandboxRunning() ? runningSessions(ctx.dataPath).map((s) => s.id) : [];
-    return [];
-};
-/** Splits "a b 'c d'" like a shell would (enough for agent arguments and exec commands). */
-export { splitArgs };
-/** What this option accepts, checked while typing (undefined = anything). */
-export const optionProblem = (o, v) => {
-    if (v === '')
-        return undefined;
-    if (o.type === 'number' && !(Number(v) > 0))
-        return 'Enter a number greater than 0.';
-    if (o.flag === '--node' && !validNodeSpec(v))
-        return 'Use a number like 22 or 22.11.0, or lts, latest.';
-    if (o.flag === '--python' && !validPythonSpec(v))
-        return 'Use 3, 3.12 or 3.12.4.';
-    if (o.value === 'dir' && !fs.existsSync(path.resolve(v)))
-        return 'That folder does not exist.';
-    if (o.value === 'file') {
-        const missing = splitArgs(v).find((f) => !fs.existsSync(path.resolve(f)));
-        if (missing)
-            return missing + ' does not exist.';
-    }
-    return undefined;
-};
-/** Targets of `data clean` as a checkbox list with sizes (never "all", never --yes: those are typed on purpose). */
-const askDataTargets = async (ctx) => {
-    console.log(c.dim('Measuring the saved data (big folders take a moment)...'));
-    const rows = collectDataEntries(ctx.dataPath, ctx.storageRoot).flatMap((e) => { const target = cleanTargetOf(e); return target ? [{ target, bytes: e.bytes }] : []; });
-    if (!rows.length) {
-        console.log('Nothing is saved yet, so there is nothing to delete.');
-        return [];
-    }
-    const width = Math.max(...rows.map((r) => r.target.length));
-    return checkbox({
-        message: 'Delete which? ' + c.dim('(space to tick, enter to continue; you confirm once more)'),
-        pageSize: pageSizeFor(16),
-        choices: rows.map((r) => ({ name: r.target.padEnd(width) + '  ' + humanBytes(r.bytes).padStart(8), value: r.target, short: r.target })),
-        validate: (picked) => (picked.length > 0 ? true : 'Tick at least one with space, or press Ctrl+C to go back.'),
-    });
-};
-const askArg = async (ctx, spec, arg) => {
-    if (spec.name === 'data' && arg.name === 'targets')
-        return askDataTargets(ctx);
-    const list = choicesFor(ctx, arg.choices);
-    if (list.length && !arg.variadic) {
-        const picked = await select({ message: arg.description, choices: [...list.map((v) => ({ name: v, value: v })), ...(arg.required ? [] : [{ name: c.dim('(skip)'), value: '' }])] });
-        return picked ? [picked] : [];
-    }
-    // A list the manifest fills in at run time (saved accounts, running sessions) that is empty: nothing to pick, so do not ask.
-    if (typeof arg.choices === 'string' && !arg.required)
-        return [];
-    if (typeof arg.choices === 'string')
-        fail('There is nothing to choose from: no ' + arg.choices + ' yet.', arg.choices === 'accounts' ? 'Sign in inside the sandbox, then run: sandbox account save <name>' : 'Start one first (sandbox claude).');
-    const answer = await input({ message: arg.description + (arg.required ? '' : c.dim(' (optional)')), validate: (v) => (!arg.required || v.trim() !== '' ? true : 'This is required.') });
-    return arg.variadic ? splitArgs(answer) : answer.trim() ? [answer.trim()] : [];
-};
-const askOptions = async (ctx, options) => {
-    const argv = [];
-    const flags = options.filter((o) => o.type === 'boolean');
-    if (flags.length)
-        argv.push(...await checkbox({ message: 'Options ' + c.dim('(space to toggle, enter to continue)'), choices: flags.map((o) => ({ name: o.flag + c.dim('  ' + shorten(o.description, Math.max(20, termWidth() - o.flag.length - 8))), value: o.flag })) }));
-    for (const o of options.filter((x) => x.type !== 'boolean')) {
-        const list = choicesFor(ctx, o.choices);
-        const label = o.flag + c.dim('  ' + o.description);
-        // A named list that is empty (no saved accounts) has nothing to pick: leave the option out.
-        if (typeof o.choices === 'string' && !list.length)
-            continue;
-        if (o.type === 'list' && list.length) {
-            for (const v of await checkbox({ message: label, choices: list.map((v) => ({ name: v, value: v })) }))
-                argv.push(o.flag, v);
-            continue;
-        }
-        const value = list.length
-            ? await select({ message: label, choices: [{ name: c.dim('(default' + (o.choices === 'harnesses' ? ': ' + ctx.loaded.config.defaultHarness : o.choices === 'accounts' ? ': none chosen' : '') + ')'), value: '' }, ...list.map((v) => ({ name: v, value: v }))] })
-            : await input({ message: label + c.dim(o.default !== undefined ? ' (default ' + o.default + ')' : ' (empty = default)'), validate: (v) => optionProblem(o, v) ?? true });
-        if (!value)
-            continue;
-        for (const v of o.type === 'list' ? splitArgs(value) : [value])
-            argv.push(o.flag, v);
-    }
-    return argv;
-};
-/** Asks everything a command takes and returns its argv (or null when the user backs out). */
-export const askCommand = async (ctx, spec, preset = []) => {
-    console.log('\n' + c.bold(spec.name) + c.dim('  ' + shorten(spec.summary, termWidth() - spec.name.length - 3)));
-    const argv = [spec.name, ...preset];
-    // The common case needs one answer: start with the settings you already have, or change them first.
-    if (spec.name === 'launch' && preset.length) {
-        const quick = await select({ message: 'Start ' + (preset[preset.indexOf('--harness') + 1] ?? 'the agent') + ' in ' + shortenMiddle(process.cwd(), Math.max(20, termWidth() - 30)), choices: [{ name: 'Start now', value: 'now' }, { name: 'Change options first...', value: 'custom' }, { name: c.dim('< back'), value: 'back' }] });
-        if (quick === 'back')
-            return null;
-        if (quick === 'now') {
-            console.log(c.dim('  ' + commandLine(argv)));
-            return argv;
-        }
-    }
-    let first = '';
-    for (const [i, arg] of spec.args.entries()) {
-        if (!askedWhen(arg.when, first))
-            continue;
-        const answer = await askArg(ctx, spec, arg);
-        if (i === 0)
-            first = answer[0] ?? '';
-        argv.push(...answer);
-    }
-    const offered = (o) => !o.noMenu && askedWhen(o.when, first);
-    const basic = spec.options.filter((o) => !o.advanced && !preset.includes(o.flag) && offered(o));
-    const advanced = spec.options.filter((o) => o.advanced && offered(o));
-    argv.push(...await askOptions(ctx, basic));
-    if (advanced.length && await confirm({ message: 'Change advanced options (' + advanced.map((o) => o.flag).join(', ') + ')?', default: false }))
-        argv.push(...await askOptions(ctx, advanced));
-    if (spec.json && !(spec.name === 'data' && first === 'clean') && await confirm({ message: 'Machine-readable output (--json)?', default: false }))
-        argv.push('--json');
-    if (spec.passthrough) {
-        const extra = splitArgs(await input({ message: spec.passthrough === 'agent' ? 'Extra arguments for the agent ' + c.dim('(optional, e.g. --continue)') : 'Arguments for the command' + c.dim(' (optional)') }));
-        if (extra.length)
-            argv.push(...(spec.passthrough === 'agent' ? ['--', ...extra] : extra));
-    }
-    console.log(c.dim('  ' + commandLine(argv)));
-    return await confirm({ message: 'Run it?', default: true }) ? argv : null;
-};
-// ---- the menu --------------------------------------------------------------------------------------------------------
-/** Is this agent already in the sandbox's persistent storage (so starting it needs no install)? */
-const agentInstalled = (ctx, name) => {
-    const h = ctx.loaded.config.harnesses[name];
-    const dir = path.join(ctx.dataPath, 'tools', 'agents', name);
-    return Boolean(h) && [h.hostExecutable, h.npmBin && h.npmBin + '.cmd', h.uvBin && h.uvBin + '.exe'].some((f) => f && fs.existsSync(path.join(dir, f)));
-};
-const GROUP_TITLES = { Agents: 'Start an agent', Sandbox: 'Sandbox', Sessions: 'Sessions', Accounts: 'Claude accounts', Data: 'Saved data and cleanup', Health: 'Diagnostics and repair', Config: 'Configuration' };
-const pickAgent = async (ctx) => {
-    const names = Object.keys(ctx.loaded.config.harnesses);
-    clearScreen();
-    const name = await select({
-        message: 'Which agent?',
-        pageSize: pageSizeFor(16),
-        choices: [
-            ...names.map((n) => ({ name: n.padEnd(10) + (agentInstalled(ctx, n) ? c.green(' installed') : c.dim(' installs on first start')) + (n === ctx.loaded.config.defaultHarness ? c.dim('  (default)') : ''), value: n })),
-            new Separator(),
-            { name: 'Claude on this PC, NOT sandboxed (host-claude)', value: '@host' },
-            { name: c.dim('< back'), value: '' },
-        ],
-    });
-    if (name === '@host')
-        return { kind: 'ask', spec: COMMANDS.find((s) => s.name === 'host-claude') };
-    return name ? { kind: 'ask', spec: COMMANDS.find((s) => s.name === 'launch'), preset: ['--harness', name] } : { kind: 'group', group: '' };
-};
-const mainMenu = async (ctx) => {
-    const last = readHistory()[0];
-    const running = isSandboxRunning();
-    clearScreen();
-    console.log(c.bold(c.cyan('Windows Development Sandbox')) + c.dim('  ' + shortenMiddle(process.cwd(), Math.max(20, termWidth() - 32))) + '\n' + (running ? c.green('  A sandbox is running') + c.dim(' (' + runningSessions(ctx.dataPath).length + ' session(s))') : c.dim('  No sandbox running')) + '\n');
-    return select({
-        message: 'What would you like to do?',
-        pageSize: pageSizeFor(14),
-        choices: [
-            ...(last ? [{ name: 'Repeat last: ' + c.cyan(shorten(commandLine(last.argv), Math.max(20, termWidth() - 20))), value: { kind: 'run', argv: last.argv } }] : []),
-            { name: 'Start ' + ctx.loaded.config.defaultHarness + ' in this folder', value: { kind: 'ask', spec: COMMANDS.find((s) => s.name === 'launch'), preset: ['--harness', ctx.loaded.config.defaultHarness] } },
-            { name: 'Start several agents (one or more projects, attach to any)...', value: { kind: 'several' } },
-            { name: 'Start another agent...', value: { kind: 'group', group: '@agents' } },
-            { name: 'Start a sandbox without an agent', value: { kind: 'ask', spec: COMMANDS.find((s) => s.name === 'start') } },
-            new Separator(),
-            ...Group.options.filter((g) => g !== 'Agents').map((g) => ({ name: GROUP_TITLES[g] + '...', value: { kind: 'group', group: g } })),
-            { name: 'Settings ' + c.dim('(every setting, saved to your config file)'), value: { kind: 'group', group: '@settings' } },
-            new Separator(),
-            { name: 'Exit', value: { kind: 'exit' } },
-        ],
-    });
-};
-const groupMenu = async (group) => {
-    clearScreen();
-    return select({
-        message: GROUP_TITLES[group] ?? group,
-        pageSize: pageSizeFor(16),
-        choices: [
-            ...COMMANDS.filter((s) => s.group === group && !s.hidden).map((s) => ({ name: s.name.padEnd(10), description: s.summary, value: { kind: 'ask', spec: s } })),
-            { name: c.dim('< back'), value: { kind: 'group', group: '' } },
-        ],
-    });
-};
-/**
- * Runs the menu until Exit, or until a command that takes over the terminal (launch, attach) has run. `run` executes
- * an argv exactly like typing it.
- */
-export const menu = async (ctx, run) => {
-    if (!process.stdin.isTTY) {
-        console.log('The menu needs an interactive terminal. Run sandbox --help for the commands.');
-        return 1;
-    }
-    try {
-        for (let pick = await mainMenu(ctx);;) {
-            if (pick.kind === 'exit')
-                return 0;
-            if (pick.kind === 'group' && pick.group === '@settings') {
-                await settingsMenu(ctx.loaded.configPath);
-                applyAgentCommands(ctx);
-                pick = await mainMenu(ctx);
-            }
-            else if (pick.kind === 'group')
-                pick = pick.group === '' ? await mainMenu(ctx) : pick.group === '@agents' ? await pickAgent(ctx) : await groupMenu(pick.group);
-            else {
-                // Ctrl+C while answering the questions of one command goes back to the menu; on the menu itself it leaves.
-                let argv;
-                try {
-                    clearScreen();
-                    argv = pick.kind === 'run' ? pick.argv : pick.kind === 'several' ? await askSeveralAgents(ctx) : await askCommand(ctx, pick.spec, pick.preset);
-                }
-                catch (e) {
-                    if (e instanceof Error && e.name === 'ExitPromptError')
-                        argv = null;
-                    else
-                        throw e;
-                }
-                if (!argv) {
-                    pick = await mainMenu(ctx);
-                    continue;
-                }
-                clearScreen();
-                console.log(c.dim('$ ' + commandLine(argv)) + '\n');
-                const code = await run(argv);
-                if (COMMANDS.find((s) => s.name === argv[0])?.interactive)
-                    return code;
-                await pressAnyKey((code === 0 ? c.green('Done.') : yellowCode(code)) + ' Press any key for the menu...');
-                pick = await mainMenu(ctx);
-            }
-        }
-    }
-    catch (e) {
-        // Ctrl+C in a prompt: leave quietly.
-        if (e instanceof Error && e.name === 'ExitPromptError')
-            return 130;
-        throw e;
-    }
-};
-const yellowCode = (code) => c.yellow('Exit code ' + code);

package/dist/cli/settings/edit.d.ts

@@ -1,13 +0,0 @@
-/** The user's own config, or a project's .sandbox-config.json (a smaller schema; nothing is merged with defaults). */
-export type SettingsTarget = 'user' | 'project';
-/** What the value is in the file (undefined when it is not set there). */
-export declare const fileValue: (text: string, key: string[]) => unknown;
-/**
- * Applies one change (undefined = remove the line, back to the default) to the config text and returns the new text, or
- * the problems that make the result invalid.
- */
-export declare const editConfigText: (text: string, key: string[], value: unknown, target?: SettingsTarget) => {
-    text: string;
-} | {
-    problems: string[];
-};

package/dist/cli/settings/edit.js

@@ -1,19 +0,0 @@
-// Changing a config file's text: one setting at a time, through jsonc-parser so comments and formatting stay, and never
-// into something invalid. Pure; the caller writes the file.
-import { applyEdits, modify, parse } from 'jsonc-parser';
-import _ from 'lodash';
-import { DEFAULTS, mergeConfig } from '../../core/config.js';
-import { Config, describeIssues, LocalOverrides } from '../../core/schema.js';
-/** What the value is in the file (undefined when it is not set there). */
-export const fileValue = (text, key) => _.get(parse(text) ?? {}, key);
-/**
- * Applies one change (undefined = remove the line, back to the default) to the config text and returns the new text, or
- * the problems that make the result invalid.
- */
-export const editConfigText = (text, key, value, target = 'user') => {
-    // Removing a setting the file does not have changes nothing (jsonc-parser throws on it).
-    const edits = value === undefined && fileValue(text || '{}', key) === undefined ? [] : modify(text || '{}', key, value, { formattingOptions: { insertSpaces: true, tabSize: 2, eol: '\n' } });
-    const next = applyEdits(text || '{}', edits);
-    const parsed = target === 'project' ? LocalOverrides.safeParse(parse(next) ?? {}) : Config.safeParse(mergeConfig(DEFAULTS, parse(next) ?? {}));
-    return parsed.success ? { text: next.endsWith('\n') ? next : next + '\n' } : { problems: describeIssues(parsed.error) };
-};

package/dist/cli/settings/index.d.ts

@@ -1,8 +0,0 @@
-export { editConfigText } from './edit.js';
-/** Titles of the top-level sections in the menu. A test makes sure every section of the schema has one. */
-export declare const SECTION_TITLES: Record<string, string>;
-/**
- * The settings screen: first which file to edit (your own, or this folder's project file), then its settings. Your file
- * is created when missing; so is the project file once a setting is saved.
- */
-export declare const settingsMenu: (configPath: string | null, projectDir?: string) => Promise<void>;

package/dist/cli/settings/index.js

@@ -1,131 +0,0 @@
-// The settings screen in the menu: every setting, generated from the zod schemas (so nothing needs to be listed by
-// hand), shown with its current value and description, edited with a fitting prompt and saved to a config file. Two
-// files can be edited: your own (all projects) and this folder's .sandbox-config.json (only what a project may set).
-// Edits keep comments and formatting, and nothing is written unless the whole file is still valid.
-import fs from 'node:fs';
-import path from 'node:path';
-import { select, Separator } from '@inquirer/prompts';
-import _ from 'lodash';
-import { DEFAULTS, loadConfig, userConfigPath } from '../../core/config.js';
-import { LOCAL_CONFIG_NAME, NEVER_LOOSER } from '../../core/local-config.js';
-import { Config as ConfigSchema, LocalOverrides } from '../../core/schema.js';
-import { c, clearScreen, pageSizeFor, shortenMiddle, termWidth } from '../colors.js';
-import { editConfigText, fileValue } from './edit.js';
-import { askValue } from './prompts.js';
-import { childrenOf, describeSetting, isSection, unwrap } from './schema.js';
-export { editConfigText } from './edit.js';
-/** Titles of the top-level sections in the menu. A test makes sure every section of the schema has one. */
-export const SECTION_TITLES = {
-    toolchains: 'Languages and tools', databases: 'Databases', sandbox: 'The sandbox machine (memory, window, GPU, network)', attach: 'Attaching (auto attach, auto hide)', agentCommands: 'Agent commands: claude, codex ... start in a sandbox (Beta)',
-    provisioning: 'Provisioning and git', downloads: 'Downloads (checksums)', secrets: 'Secrets', claudeProfile: 'Your Claude settings and history', storage: 'Storage',
-    network: 'Network', hooks: 'Hooks', personalization: 'Desktop look', projects: 'Several projects (project roots, adding folders while running)',
-};
-/** A value in one short line: maps as their keys, long lists shortened. */
-const show = (value) => {
-    if (value === undefined)
-        return c.dim('(not set)');
-    if (typeof value === 'string')
-        return value;
-    if (value && typeof value === 'object' && !Array.isArray(value)) {
-        const keys = Object.keys(value);
-        return keys.length ? '{ ' + _.truncate(keys.join(', '), { length: 60 }) + ' }' : '{}';
-    }
-    return _.truncate(JSON.stringify(value), { length: 70 });
-};
-const readText = (file) => (fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '');
-/** The user's settings with the built-in defaults filled in (what a sandbox would use without a project file). */
-const userConfig = (file) => loadConfig(fs.existsSync(file) ? file : undefined).config;
-/** What is in effect now: for your own file the merged config, for a project file only what that file sets. */
-const currentValue = (session, key, text, config) => session.target === 'project' ? fileValue(text, key) : _.get(config, key);
-/** Edits one setting: shows it, asks, saves (or resets it to the default / removes it from the project file). */
-const editSetting = async (session, schema, key, config) => {
-    const { file, target } = session;
-    const text = readText(file);
-    const inFile = fileValue(text, key);
-    const project = target === 'project';
-    console.log('\n' + c.cyan(key.join('.')) + (describeSetting(schema) ? '\n' + c.dim(describeSetting(schema)) : ''));
-    if (project && NEVER_LOOSER.includes(key.join('.')))
-        console.log(c.yellow('A project can only make this stricter than your own setting; a looser value is ignored.'));
-    console.log('Now: ' + (project ? show(inFile) + c.dim(inFile === undefined ? '  (not set in this project; yours: ' + show(_.get(config, key)) + ')' : '  (set in ' + file + ')') : show(_.get(config, key)) + (inFile === undefined ? c.dim('  (built-in default)') : c.dim('  (set in ' + file + ')'))));
-    const resetLabel = project ? 'Remove from this project file' : 'Reset to the default (' + show(_.get(DEFAULTS, key)) + ')';
-    const action = inFile === undefined ? 'change' : await select({ message: 'What now?', choices: [{ name: 'Change it', value: 'change' }, { name: resetLabel, value: 'reset' }, { name: c.dim('< back'), value: 'back' }] });
-    if (action === 'back')
-        return;
-    const answer = action === 'reset' ? { value: undefined } : await askValue(schema, key, project ? inFile ?? _.get(config, key) : _.get(config, key), config);
-    if (!answer)
-        return;
-    // In your own file the default needs no line; an unchanged value needs no save.
-    const value = !project && _.isEqual(answer.value, _.get(DEFAULTS, key)) ? undefined : answer.value;
-    if (value === inFile && (project || _.isEqual(answer.value, _.get(config, key)))) {
-        console.log(c.dim('Unchanged.'));
-        return;
-    }
-    const result = editConfigText(text, key, value, target);
-    if ('problems' in result) {
-        console.log(c.red('Not saved: ') + result.problems.join('; '));
-        return;
-    }
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    fs.writeFileSync(file, result.text, 'utf8');
-    console.log(c.green('Saved') + c.dim(' to ' + file + (project ? '.' : '. New sandboxes use it.')));
-    // The approval is tied to the file's exact contents, so any change makes the project file untrusted again.
-    if (project)
-        console.log(c.yellow('This project file is not approved any more: the next launch shows what it applies and asks you to approve it.'));
-};
-/** Browses one level of settings; sections open, leaves are edited. */
-const browse = async (session, schema, key) => {
-    for (;;) {
-        const config = userConfig(session.target === 'user' ? session.file : userConfigPath());
-        const entries = childrenOf(schema);
-        const text = readText(session.file);
-        clearScreen();
-        console.log(c.dim('Editing ' + shortenMiddle(session.file, termWidth() - 10)) + '\n' + c.dim('Values in ') + c.yellow('yellow') + c.dim(' (marked *) are set in that file; the rest are defaults.') + '\n');
-        const pickName = await select({
-            message: key.length ? key.join('.') : 'Settings',
-            pageSize: pageSizeFor(18),
-            choices: [
-                ...entries.map(([name, s]) => {
-                    const full = [...key, name];
-                    const changed = fileValue(text, full) !== undefined;
-                    const shown = show(currentValue(session, full, text, config));
-                    const label = isSection(s) ? (key.length ? name : SECTION_TITLES[name] ?? name) + c.dim(' ...') : name.padEnd(18) + ' ' + (changed ? c.yellow(shown) + ' *' : shown);
-                    return { name: label, value: name, description: describeSetting(s) };
-                }),
-                new Separator(),
-                { name: c.dim('< back'), value: '@back' },
-            ],
-        });
-        if (pickName === '@back')
-            return;
-        const child = unwrap(schema).shape[pickName];
-        if (isSection(child))
-            await browse(session, child, [...key, pickName]);
-        else
-            await editSetting(session, child, [...key, pickName], config);
-    }
-};
-/**
- * The settings screen: first which file to edit (your own, or this folder's project file), then its settings. Your file
- * is created when missing; so is the project file once a setting is saved.
- */
-export const settingsMenu = async (configPath, projectDir = process.cwd()) => {
-    const sessions = {
-        user: { target: 'user', file: configPath ?? userConfigPath(), schema: ConfigSchema },
-        project: { target: 'project', file: path.join(projectDir, LOCAL_CONFIG_NAME), schema: LocalOverrides },
-    };
-    for (;;) {
-        clearScreen();
-        const which = await select({
-            message: 'Which settings?',
-            choices: [
-                { name: 'Your settings (all projects)', description: sessions.user.file, value: 'user' },
-                { name: 'This project', description: sessions.project.file + ' (only what a project may set; needs your approval at launch)', value: 'project' },
-                new Separator(),
-                { name: c.dim('< back'), value: '@back' },
-            ],
-        });
-        if (which === '@back')
-            return;
-        await browse(sessions[which], sessions[which].schema, []);
-    }
-};

package/dist/cli/settings/prompts.d.ts

@@ -1,7 +0,0 @@
-import type { Config } from '../../core/types.js';
-import { type Schema } from './schema.js';
-export type Answer = {
-    value: unknown;
-} | undefined;
-/** `key` is the setting's path; `config` (the user's settings) lets the default agent be picked from the configured ones. */
-export declare const askValue: (schema: Schema, key: string[], current: unknown, config?: Config) => Promise<Answer>;

package/dist/cli/settings/prompts.js

@@ -1,48 +0,0 @@
-// The prompt that fits a setting's type. Returns the new value, or undefined to change nothing.
-import { input, select } from '@inquirer/prompts';
-import { c } from '../colors.js';
-import { jsonExample, kind, promptKind, unwrap } from './schema.js';
-const CANCEL = '@cancel';
-const cancel = { name: c.dim('< cancel'), value: CANCEL };
-const pick = async (label, choices, current) => {
-    const v = await select({ message: label, choices: [...choices, cancel], default: current });
-    return v === CANCEL ? undefined : { value: v };
-};
-const typed = async (label, current, validate, convert) => {
-    const shown = current === undefined ? '' : typeof current === 'string' ? current : JSON.stringify(current);
-    const answer = await input({ message: label + c.dim(' (empty = cancel)'), default: shown, validate: (v) => (v === '' ? true : validate(v)) });
-    return answer === '' ? undefined : { value: convert(answer) };
-};
-const BOOLEANS = [{ name: 'true', value: true }, { name: 'false', value: false }];
-/** `key` is the setting's path; `config` (the user's settings) lets the default agent be picked from the configured ones. */
-export const askValue = async (schema, key, current, config) => {
-    const label = key.join('.');
-    const s = unwrap(schema);
-    // The default agent is one of the configured ones: a list, not free text.
-    if (label === 'defaultHarness' && config)
-        return pick(label, Object.keys(config.harnesses).map((h) => ({ name: h, value: h })), current);
-    switch (promptKind(s)) {
-        case 'boolean': return pick(label, BOOLEANS, current);
-        case 'enum': return pick(label, Object.values(s._zod.def.entries ?? {}).map((v) => ({ name: String(v), value: v })), current);
-        case 'union': {
-            const options = s._zod.def.options ?? [];
-            const literals = options.filter((o) => kind(o) === 'literal').flatMap((o) => unwrap(o)._zod.def.values ?? []);
-            const other = options.find((o) => !['literal', 'boolean'].includes(kind(o)));
-            const choices = [...(options.some((o) => kind(o) === 'boolean') ? BOOLEANS : []), ...literals.map((v) => ({ name: String(v), value: v }))];
-            if (!other)
-                return pick(label, choices, current);
-            const chosen = await pick(label, [...choices, { name: 'a ' + kind(other) + ' ...', value: '@other' }], current);
-            return chosen?.value === '@other' ? askValue(other, key, current) : chosen;
-        }
-        case 'number': return typed(label, current, (v) => (Number.isFinite(Number(v)) ? true : 'Enter a number, e.g. 8192.'), Number);
-        case 'string': return typed(label, current, () => true, (v) => v);
-        case 'string-list': return typed(label + c.dim(' (comma separated, [] = none)'), current, () => true, (v) => (v.trim() === '[]' ? [] : v.split(',').map((x) => x.trim()).filter(Boolean)));
-        default: return typed(label + c.dim(' (JSON, e.g. ' + jsonExample(key, s) + ')'), current, (v) => { try {
-            JSON.parse(v);
-            return true;
-        }
-        catch {
-            return 'valid JSON';
-        } }, (v) => JSON.parse(v));
-    }
-};