windows-development-sandbox 1.0.5 → 1.4.0

package/dist/cli/commands/setup.js

@@ -1,152 +0,0 @@
-// `sandbox setup`: checks this PC can run Windows Sandbox and offers to turn the feature on.
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import _ from 'lodash';
-import { z } from 'zod';
-import { askYesNo } from '../../core/workspace.js';
-import { fail, fileExists, isWin } from '../../core/util.js';
-import { SYSTEM, system32 } from '../../shared/system.js';
-import { table } from './context.js';
-const FEATURE = 'Containers-DisposableClientVM';
-export const ENABLE_COMMAND = 'Enable-WindowsOptionalFeature -Online -FeatureName ' + FEATURE + ' -All -NoRestart';
-const GB = 1024 ** 3;
-/** `reg query <key>` output to { valueName: data }. */
-export const parseRegQuery = (text) => Object.fromEntries(_.compact(text.split(/\r?\n/).map((line) => /^\s+(\S+)\s+REG_\w+\s+(.*)$/.exec(line)?.slice(1, 3))));
-/** Windows Sandbox needs Pro, Enterprise or Education (build 18305+); Home ("Core*") and Server cannot run it. */
-export const editionSupport = (edition) => {
-    if (!edition)
-        return 'unknown';
-    if (/^Core/i.test(edition))
-        return 'home';
-    if (/^Server/i.test(edition))
-        return 'unsupported';
-    return /^(Professional|Enterprise|Education|IoTEnterprise)/i.test(edition) ? 'supported' : 'unknown';
-};
-/** The "State : ..." line of `Dism /Get-FeatureInfo` (English output only; anything else is unknown). */
-export const parseDismState = (text) => {
-    const state = /^State\s*:\s*(.+?)\s*$/im.exec(text)?.[1].toLowerCase() ?? '';
-    if (state === 'enabled')
-        return 'enabled';
-    if (state.includes('pending'))
-        return 'pending';
-    return state.startsWith('disabled') ? 'disabled' : 'unknown';
-};
-/** Win32_OptionalFeature.InstallState: 1 enabled, 2 disabled, 3 absent. */
-export const featureFromInstallState = (state) => state === 1 ? 'enabled' : state === 2 || state === 3 ? 'disabled' : 'unknown';
-export const nodeMajor = (version) => Number(/^v?(\d+)/.exec(version.trim())?.[1] ?? 0);
-/** Offer to enable the feature only when it is off and this edition can have it. */
-export const canEnableFeature = (f) => f.feature !== 'enabled' && f.feature !== 'pending' && !f.sandboxExe && ['supported', 'unknown'].includes(editionSupport(f.edition));
-const formatGb = (bytes) => (bytes / GB).toFixed(1) + ' GB';
-/** Turns what we learnt about the PC into the checklist (pure, so it can be tested). */
-export const buildChecks = (f) => {
-    const support = editionSupport(f.edition);
-    const edition = (f.edition ?? 'unknown edition') + (f.build ? ', build ' + f.build : '');
-    const virt = f.hypervisorPresent || f.virtualizationFirmware;
-    const featureReady = f.feature === 'enabled' && f.sandboxExe;
-    return [
-        support === 'supported' && (f.build ?? 18305) >= 18305 ? { name: 'Windows edition', status: 'ok', detail: edition }
-            : support === 'home' ? { name: 'Windows edition', status: 'action', detail: edition + ': Windows Home cannot run Windows Sandbox. Upgrade to Pro (Settings > System > Activation).' }
-                : support === 'unsupported' ? { name: 'Windows edition', status: 'action', detail: edition + ': Windows Sandbox needs Windows 10/11 Pro, Enterprise or Education.' }
-                    : support === 'supported' ? { name: 'Windows edition', status: 'action', detail: edition + ': too old; Windows Sandbox needs Windows 10 version 1903 or newer.' }
-                        : { name: 'Windows edition', status: 'warn', detail: edition + ': not sure this edition has Windows Sandbox (it needs Pro, Enterprise or Education).' },
-        virt ? { name: 'CPU virtualization', status: 'ok', detail: f.hypervisorPresent ? 'on (hypervisor running)' : 'on' }
-            : virt === false ? { name: 'CPU virtualization', status: 'action', detail: 'off. Turn on Intel VT-x / AMD-V (SVM) in your PC\'s BIOS/UEFI settings, then run this again.' }
-                : { name: 'CPU virtualization', status: 'warn', detail: 'could not tell; if Windows Sandbox will not start, turn on VT-x / AMD-V in the BIOS/UEFI.' },
-        featureReady ? { name: 'Windows Sandbox feature', status: 'ok', detail: 'enabled' }
-            : f.feature === 'pending' || (f.feature === 'enabled' && !f.sandboxExe) ? { name: 'Windows Sandbox feature', status: 'action', detail: 'enabled, but Windows needs a restart to finish.' }
-                : f.sandboxExe ? { name: 'Windows Sandbox feature', status: 'ok', detail: 'installed' }
-                    : { name: 'Windows Sandbox feature', status: 'action', detail: 'not enabled. In an admin PowerShell: ' + ENABLE_COMMAND + ', then restart.' },
-        { name: 'Memory', status: f.totalRamBytes < 4 * GB ? 'action' : f.totalRamBytes < 8 * GB ? 'warn' : 'ok', detail: formatGb(f.totalRamBytes) + (f.totalRamBytes < 4 * GB ? ': Windows Sandbox needs at least 4 GB.' : f.totalRamBytes < 8 * GB ? ': works, but 8 GB or more is recommended.' : '') },
-        f.freeDiskBytes === null ? { name: 'Free disk', status: 'warn', detail: 'could not check the drive of ' + f.storageRoot }
-            : { name: 'Free disk', status: f.freeDiskBytes < 5 * GB ? 'action' : f.freeDiskBytes < 20 * GB ? 'warn' : 'ok', detail: formatGb(f.freeDiskBytes) + ' free for ' + f.storageRoot + (f.freeDiskBytes < 5 * GB ? ': free up space (toolchains need several GB).' : f.freeDiskBytes < 20 * GB ? ': getting low; toolchains and caches can use several GB.' : '') },
-        nodeMajor(f.nodeVersion) >= 20 ? { name: 'Node.js', status: 'ok', detail: f.nodeVersion } : { name: 'Node.js', status: 'action', detail: f.nodeVersion + ': needs 20 or newer (winget install OpenJS.NodeJS.LTS).' },
-    ];
-};
-// Fixed script (no outside data): CPU/hypervisor facts and the feature state, readable without admin rights.
-const PROBE = [
-    '$ErrorActionPreference = "SilentlyContinue"',
-    '$cpu = @(Get-CimInstance Win32_Processor)',
-    '$cs = Get-CimInstance Win32_ComputerSystem',
-    '$f = Get-CimInstance Win32_OptionalFeature -Filter "Name=\'' + FEATURE + '\'"',
-    '$v = $null; if ($cpu.Count) { $v = [bool]($cpu | Where-Object { $_.VirtualizationFirmwareEnabled }) }',
-    '$h = $null; if ($cs) { $h = [bool]$cs.HypervisorPresent }',
-    '$s = $null; if ($f) { $s = [int]$f.InstallState }',
-    '@{ virtualizationFirmware = $v; hypervisorPresent = $h; installState = $s } | ConvertTo-Json -Compress',
-].join('; ');
-const Probe = z.object({ virtualizationFirmware: z.boolean().nullable(), hypervisorPresent: z.boolean().nullable(), installState: z.number().nullable() }).partial();
-export const parseProbe = (text) => {
-    try {
-        return Probe.parse(JSON.parse(_.last(text.trim().split(/\r?\n/)) ?? ''));
-    }
-    catch {
-        return {};
-    }
-};
-const run = (exe, args) => {
-    const r = spawnSync(exe, args, { encoding: 'utf8', windowsHide: true, timeout: 60000 });
-    return r.status === 0 ? r.stdout : '';
-};
-const freeDisk = (dir) => {
-    let at = path.resolve(dir);
-    while (!fs.existsSync(at) && path.dirname(at) !== at)
-        at = path.dirname(at);
-    try {
-        const s = fs.statfsSync(at);
-        return s.bavail * s.bsize;
-    }
-    catch {
-        return null;
-    }
-};
-const gatherFacts = (storageRoot) => {
-    const reg = parseRegQuery(run(SYSTEM.reg(), ['query', 'HKLM\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion']));
-    const probe = parseProbe(run(SYSTEM.powershell(), ['-NoProfile', '-NonInteractive', '-Command', PROBE]));
-    // DISM knows about a pending restart but needs admin rights; the CIM state works for everyone.
-    const dism = parseDismState(run(SYSTEM.dism(), ['/English', '/Online', '/Get-FeatureInfo', '/FeatureName:' + FEATURE]));
-    return {
-        edition: reg.EditionID ?? null,
-        build: Number(reg.CurrentBuildNumber ?? reg.CurrentBuild) || null,
-        feature: dism === 'unknown' ? featureFromInstallState(probe.installState) : dism,
-        sandboxExe: fileExists(system32('WindowsSandbox.exe')),
-        virtualizationFirmware: probe.virtualizationFirmware ?? null,
-        hypervisorPresent: probe.hypervisorPresent ?? null,
-        totalRamBytes: os.totalmem(),
-        freeDiskBytes: freeDisk(storageRoot),
-        storageRoot,
-        nodeVersion: process.version,
-    };
-};
-const LABEL = { ok: '\x1b[32mOK\x1b[0m', warn: '\x1b[33mWARNING\x1b[0m', action: '\x1b[31mACTION NEEDED\x1b[0m' };
-const print = (checks) => table(checks.map((c) => [LABEL[c.status], c.name, c.detail]));
-/** Runs the enable command in an elevated PowerShell (Windows asks for permission); true if it worked. */
-const enableFeature = () => {
-    const inner = "'-NoProfile','-Command','" + ENABLE_COMMAND + " | Out-Null'";
-    const outer = "try { $p = Start-Process -FilePath '" + SYSTEM.powershell() + "' -Verb RunAs -Wait -PassThru -WindowStyle Hidden -ArgumentList " + inner + '; exit $p.ExitCode } catch { exit 1 }';
-    return spawnSync(SYSTEM.powershell(), ['-NoProfile', '-NonInteractive', '-Command', outer], { stdio: 'inherit' }).status === 0;
-};
-export const setup = async (ctx) => {
-    if (!isWin)
-        fail('Windows Sandbox only runs on Windows.', 'Run sandbox setup on a Windows 10/11 Pro, Enterprise or Education PC.');
-    console.log('Checking this PC for Windows Sandbox...\n');
-    const facts = gatherFacts(ctx.storageRoot);
-    let checks = buildChecks(facts);
-    print(checks);
-    if (canEnableFeature(facts)) {
-        console.log('');
-        if (await askYesNo('Turn on Windows Sandbox now? Windows will ask for admin permission.')) {
-            console.log('Enabling Windows Sandbox (this can take a minute)...');
-            if (!enableFeature())
-                fail('Windows Sandbox could not be enabled (or the admin prompt was declined).', 'In an admin PowerShell run: ' + ENABLE_COMMAND + ', then restart Windows.');
-            console.log('Done. Restart Windows to finish, then run sandbox setup again.\n');
-            checks = buildChecks(gatherFacts(ctx.storageRoot));
-            print(checks);
-        }
-        else
-            console.log('To do it yourself, in an admin PowerShell run:\n  ' + ENABLE_COMMAND + '\nthen restart Windows.');
-    }
-    const todo = checks.filter((c) => c.status === 'action').length;
-    console.log('\n' + (todo ? todo + ' thing(s) to fix before the sandbox can start (see ACTION NEEDED above).' : 'This PC is ready. cd into a project and run sandbox claude (or sandbox for no agent).'));
-    return todo ? 1 : 0;
-};

package/dist/cli/menu.d.ts

@@ -1,22 +0,0 @@
-import { z } from 'zod';
-import type { Context } from './commands/context.js';
-import { type CommandSpecT } from './manifest.js';
-declare const History: z.ZodArray<z.ZodObject<{
-    argv: z.ZodArray<z.ZodString>;
-    at: z.ZodString;
-}, z.core.$strict>>;
-export declare const readHistory: () => z.output<typeof History>;
-/** Remembers a command (menu or typed) so the menu can offer it again. Never fails the command itself. */
-export declare const recordHistory: (argv: string[]) => void;
-/** argv as you would type it (quoted where needed). */
-export declare const commandLine: (argv: string[]) => string;
-/** Splits "a b 'c d'" like a shell would (enough for agent arguments and exec commands). */
-export declare const splitArgs: (text: string) => string[];
-/** 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>;
-export {};

package/dist/cli/menu.js

@@ -1,187 +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 { z } from 'zod';
-import { userDir } from '../core/config.js';
-import { tryReadJson, writeJson } from '../core/util.js';
-import { listAccounts } from '../host/accounts.js';
-import { runningSessions } from '../host/channel.js';
-import { isSandboxRunning } from '../host/platform.js';
-import { settingsMenu } from './settings.js';
-import { COMMANDS, Group } from './manifest.js';
-const c = { bold: (s) => '\x1b[1m' + s + '\x1b[0m', dim: (s) => '\x1b[2m' + s + '\x1b[0m', cyan: (s) => '\x1b[36m' + s + '\x1b[0m', green: (s) => '\x1b[32m' + s + '\x1b[0m', yellow: (s) => '\x1b[33m' + s + '\x1b[0m' };
-// ---- history ---------------------------------------------------------------------------------------------------------
-const History = z.array(z.strictObject({ argv: z.array(z.string()).max(200), at: z.string() })).max(20);
-const historyFile = () => path.join(userDir(), 'history.json');
-const HIDDEN = new Set(['menu', '_watch', 'self-test']);
-export const readHistory = () => History.safeParse(tryReadJson(historyFile())).data ?? [];
-/** Remembers a command (menu or typed) so the menu can offer it again. Never fails the command itself. */
-export const recordHistory = (argv) => {
-    if (!argv.length || HIDDEN.has(argv[0]) || argv.includes('--help'))
-        return;
-    try {
-        writeJson(historyFile(), [{ argv, at: new Date().toISOString() }, ...readHistory().filter((h) => h.argv.join('\0') !== argv.join('\0'))].slice(0, 10));
-    }
-    catch { /* history is a convenience */ }
-};
-/** argv as you would type it (quoted where needed). */
-export const commandLine = (argv) => ['sandbox', ...argv].map((a) => (/[\s"]/.test(a) || a === '' ? '"' + a.replace(/"/g, '\\"') + '"' : a)).join(' ');
-// ---- 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 const splitArgs = (text) => [...text.matchAll(/"([^"]*)"|'([^']*)'|(\S+)/g)].map((m) => m[1] ?? m[2] ?? m[3]);
-const askArg = async (ctx, arg) => {
-    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] : [];
-    }
-    const answer = await input({ message: arg.description + (arg.required ? '' : c.dim(' (optional)')), validate: (v) => (!arg.required || v.trim() !== '' ? true : '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('  ' + o.description), 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);
-        const value = list.length
-            ? await select({ message: label, choices: [{ name: c.dim('(default)'), value: '' }, ...list.map((v) => ({ name: v, value: v }))] })
-            : await input({ message: label + c.dim(o.default !== undefined ? ' (default ' + o.default + ')' : ' (empty = default)'), validate: (v) => (o.type !== 'number' || v === '' || Number(v) > 0 ? true : 'a positive number') });
-        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('  ' + spec.summary));
-    const argv = [spec.name, ...preset];
-    for (const arg of spec.args)
-        argv.push(...await askArg(ctx, arg));
-    const basic = spec.options.filter((o) => !o.advanced && !preset.includes(o.flag));
-    const advanced = spec.options.filter((o) => o.advanced);
-    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 && 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 (attach, restart)', Accounts: 'Claude accounts', Data: 'Persisted data, sync and cleanup', Health: 'Diagnostics and repair (doctor, setup, repair, dry run, logs)', Config: 'Configuration' };
-const pickAgent = async (ctx) => {
-    const names = Object.keys(ctx.loaded.config.harnesses);
-    const name = await select({
-        message: 'Which agent?',
-        pageSize: 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();
-    console.log('\n' + c.bold(c.cyan('Windows Development Sandbox')) + c.dim('  ' + process.cwd()) + '\n' + (running ? c.green('  A sandbox is running') + c.dim(' (' + runningSessions(ctx.dataPath).length + ' session(s))') : c.dim('  No sandbox running')));
-    return select({
-        message: 'What would you like to do?',
-        pageSize: 14,
-        choices: [
-            ...(last ? [{ name: 'Repeat last: ' + c.cyan(commandLine(last.argv)), 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 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) => select({
-    message: GROUP_TITLES[group] ?? group,
-    pageSize: 16,
-    choices: [
-        ...COMMANDS.filter((s) => s.group === group && !s.hidden).map((s) => ({ name: s.name.padEnd(10) + c.dim(' ' + 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);
-                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 {
-                const argv = pick.kind === 'run' ? pick.argv : await askCommand(ctx, pick.spec, pick.preset);
-                if (!argv) {
-                    pick = await mainMenu(ctx);
-                    continue;
-                }
-                const code = await run(argv);
-                if (COMMANDS.find((s) => s.name === argv[0])?.interactive)
-                    return code;
-                await input({ message: c.dim((code === 0 ? 'Done' : yellowCode(code)) + '. Press Enter 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.d.ts

@@ -1,11 +0,0 @@
-/**
- * Applies one change (undefined = back to the default) to the config text and returns the new text, or the problems
- * that make the result invalid. Pure: the caller writes the file.
- */
-export declare const editConfigText: (text: string, key: string[], value: unknown) => {
-    text: string;
-} | {
-    problems: string[];
-};
-/** The settings screen. Changes are saved to the user config file (created when missing). */
-export declare const settingsMenu: (configPath: string | null) => Promise<void>;

package/dist/cli/settings.js

@@ -1,156 +0,0 @@
-// The settings screen in the menu: every setting, generated from the zod schema (so nothing needs to be listed by
-// hand), shown with its current value and description, edited with a fitting prompt and saved to the user config
-// file. Edits go through jsonc-parser, so comments and formatting in the file are kept, and nothing is written unless
-// the whole config is still valid.
-import fs from 'node:fs';
-import path from 'node:path';
-import { input, select, Separator } from '@inquirer/prompts';
-import { applyEdits, modify, parse } from 'jsonc-parser';
-import _ from 'lodash';
-import { DEFAULTS, loadConfig, mergeConfig, userConfigPath } from '../core/config.js';
-import { Config as ConfigSchema, describeIssues } from '../core/schema.js';
-const c = { dim: (s) => '\x1b[2m' + s + '\x1b[0m', cyan: (s) => '\x1b[36m' + s + '\x1b[0m', green: (s) => '\x1b[32m' + s + '\x1b[0m', yellow: (s) => '\x1b[33m' + s + '\x1b[0m', red: (s) => '\x1b[31m' + s + '\x1b[0m' };
-/** optional()/default() wrappers hide the real type. */
-const unwrap = (s) => (['optional', 'default', 'nullable'].includes(s._zod.def.type) && s._zod.def.innerType ? unwrap(s._zod.def.innerType) : s);
-const kind = (s) => unwrap(s)._zod.def.type;
-const isSection = (s) => kind(s) === 'object' && Boolean(unwrap(s).shape);
-/** Settings not worth editing here (the schema link) or better edited in the file (agent definitions). */
-const HIDDEN = new Set(['$schema']);
-/** 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 });
-};
-/** What the value is in the file the user owns (undefined when it comes from the built-in defaults). */
-const fileValue = (text, key) => _.get(parse(text) ?? {}, key);
-/**
- * Applies one change (undefined = back to the default) to the config text and returns the new text, or the problems
- * that make the result invalid. Pure: the caller writes the file.
- */
-export const editConfigText = (text, key, value) => {
-    const edits = modify(text || '{}', key, value, { formattingOptions: { insertSpaces: true, tabSize: 2, eol: '\n' } });
-    const next = applyEdits(text || '{}', edits);
-    const parsed = ConfigSchema.safeParse(mergeConfig(DEFAULTS, parse(next) ?? {}));
-    return parsed.success ? { text: next.endsWith('\n') ? next : next + '\n' } : { problems: describeIssues(parsed.error) };
-};
-/** A prompt that fits the setting's type; returns the new value, or undefined to change nothing. */
-const askValue = async (schema, label, current, config) => {
-    const s = unwrap(schema);
-    // The default agent is one of the configured ones: a list, not free text.
-    if (label === 'defaultHarness' && config) {
-        const v = await select({ message: label, choices: [...Object.keys(config.harnesses).map((h) => ({ name: h, value: h })), { name: c.dim('< cancel'), value: '@cancel' }], default: current });
-        return v === '@cancel' ? undefined : { value: v };
-    }
-    const t = s._zod.def.type;
-    const back = { name: c.dim('< cancel'), value: '@cancel' };
-    const pick = async (choices) => {
-        const v = await select({ message: label, choices: [...choices, back], default: current });
-        return v === '@cancel' ? undefined : { value: v };
-    };
-    if (t === 'boolean')
-        return pick([{ name: 'true', value: true }, { name: 'false', value: false }]);
-    if (t === 'enum')
-        return pick(Object.values(s._zod.def.entries ?? {}).map((v) => ({ name: String(v), value: v })));
-    if (t === 'union') {
-        const options = s._zod.def.options ?? [];
-        const literals = options.filter((o) => kind(o) === 'literal').flatMap((o) => unwrap(o)._zod.def.values ?? []);
-        const hasBool = options.some((o) => kind(o) === 'boolean');
-        const other = options.find((o) => !['literal', 'boolean'].includes(kind(o)));
-        const choices = [...(hasBool ? [{ name: 'true', value: true }, { name: 'false', value: false }] : []), ...literals.map((v) => ({ name: String(v), value: v }))];
-        if (!other)
-            return pick(choices);
-        const chosen = await pick([...choices, { name: 'a ' + kind(other) + ' ...', value: '@other' }]);
-        return chosen?.value === '@other' ? askValue(other, label, current) : chosen;
-    }
-    const typed = async (validate, convert) => {
-        const answer = await input({ message: label + c.dim(' (empty = cancel)'), default: current === undefined ? '' : typeof current === 'string' ? current : JSON.stringify(current), validate: (v) => (v === '' ? true : validate(v)) });
-        return answer === '' ? undefined : { value: convert(answer) };
-    };
-    if (t === 'number')
-        return typed((v) => (Number.isFinite(Number(v)) ? true : 'a number'), Number);
-    if (t === 'string')
-        return typed(() => true, (v) => v);
-    if (t === 'array' && kind(s._zod.def.element) === 'string') {
-        return typed(() => true, (v) => (v.trim() === '[]' ? [] : v.split(',').map((x) => x.trim()).filter(Boolean)));
-    }
-    // Lists of objects and maps (mappings, harnesses, environment): edited as JSON.
-    return typed((v) => { try {
-        JSON.parse(v);
-        return true;
-    }
-    catch {
-        return 'valid JSON';
-    } }, (v) => JSON.parse(v));
-};
-/** Edits one setting: shows it, asks, saves (or resets it to the default). */
-const editSetting = async (schema, key, config, file) => {
-    const text = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '';
-    const inFile = fileValue(text, key);
-    console.log('\n' + c.cyan(key.join('.')) + (schema.description ? '\n' + c.dim(schema.description) : ''));
-    console.log('Now: ' + show(_.get(config, key)) + (inFile === undefined ? c.dim('  (built-in default)') : c.dim('  (set in ' + file + ')')));
-    const action = inFile === undefined ? 'change' : await select({ message: 'What now?', choices: [{ name: 'Change it', value: 'change' }, { name: 'Reset to the default (' + show(_.get(DEFAULTS, key)) + ')', value: 'reset' }, { name: c.dim('< back'), value: 'back' }] });
-    if (action === 'back')
-        return;
-    const answer = action === 'reset' ? { value: undefined } : await askValue(schema, key.join('.'), _.get(config, key), config);
-    if (!answer)
-        return;
-    // The default needs no line in the file; an unchanged value needs no save.
-    const value = _.isEqual(answer.value, _.get(DEFAULTS, key)) ? undefined : answer.value;
-    if (value === inFile && _.isEqual(answer.value, _.get(config, key))) {
-        console.log(c.dim('Unchanged.'));
-        return;
-    }
-    const result = editConfigText(text, key, value);
-    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 + '. New sandboxes use it.'));
-};
-const SECTION_TITLES = {
-    toolchains: 'Languages and tools', databases: 'Databases', sandbox: 'The sandbox machine (memory, window, GPU, network)', attach: 'Attaching (auto attach, auto hide)',
-    provisioning: 'Provisioning and git', secrets: 'Secrets', claudeProfile: 'Your Claude settings and history', storage: 'Storage', network: 'Network', hooks: 'Hooks', personalization: 'Desktop look',
-};
-/** Browses one level of settings; sections open, leaves are edited. */
-const browse = async (schema, key, file) => {
-    for (;;) {
-        const config = loadConfig().config;
-        const entries = Object.entries(unwrap(schema).shape ?? {}).filter(([name]) => !HIDDEN.has(name));
-        const text = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '';
-        const pickName = await select({
-            message: key.length ? key.join('.') : 'Settings ' + c.dim('(saved to ' + file + ')'),
-            pageSize: 18,
-            choices: [
-                ...entries.map(([name, s]) => {
-                    const full = [...key, name];
-                    const changed = fileValue(text, full) !== undefined;
-                    const label = isSection(s) ? (key.length ? name : SECTION_TITLES[name] ?? name) + c.dim(' ...') : name.padEnd(18) + ' ' + (changed ? c.yellow(show(_.get(config, full))) : show(_.get(config, full)));
-                    return { name: label, value: name, description: s.description };
-                }),
-                new Separator(),
-                { name: c.dim('< back'), value: '@back' },
-            ],
-        });
-        if (pickName === '@back')
-            return;
-        const child = unwrap(schema).shape[pickName];
-        if (isSection(child))
-            await browse(child, [...key, pickName], file);
-        else
-            await editSetting(child, [...key, pickName], config, file);
-    }
-};
-/** The settings screen. Changes are saved to the user config file (created when missing). */
-export const settingsMenu = async (configPath) => {
-    const file = configPath ?? userConfigPath();
-    await browse(ConfigSchema, [], file);
-};