windows-development-sandbox 1.4.1 → 1.4.3

package/dist/cli/commands/setup/index.js

@@ -1,23 +1,33 @@
 // `sandbox setup`: checks this PC can run Windows Sandbox and offers to turn the feature on.
 import { spawnSync } from 'node:child_process';
 import { askYesNo } from '../../../core/prompt.js';
-import { fail, isWin } from '../../../core/util.js';
+import { fail, isWin } from '../../../core/util/index.js';
 import { refuseInSelfTest } from '../../../host/test-guard.js';
 import { SYSTEM } from '../../../shared/system.js';
-import { c } from '../../colors.js';
-import { table } from '../context.js';
+import { c, table } from '../../output/index.js';
 import { buildChecks, canEnableFeature } from './checks.js';
 import { ENABLE_COMMAND, gatherFacts } from './facts.js';
-const LABEL = { ok: c.green('OK'), warn: c.yellow('WARNING'), action: c.red('ACTION NEEDED') };
-const print = (checks) => table(checks.map((check) => [LABEL[check.status], check.name, check.detail]));
+const LABEL = {
+    ok: c.green('OK'),
+    warn: c.yellow('WARNING'),
+    action: c.red('ACTION NEEDED'),
+};
+function print(checks) {
+    table(checks.map((check) => [LABEL[check.status], check.name, check.detail]));
+}
 /** Runs the enable command in an elevated PowerShell (Windows asks for permission); true if it worked. */
-const enableFeature = () => {
+function enableFeature() {
     refuseInSelfTest('turn on Windows features');
     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) => {
+    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 async function setup(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');
@@ -38,6 +48,9 @@ export const setup = async (ctx) => {
             console.log('To do it yourself, in an admin PowerShell run:\n  ' + ENABLE_COMMAND + '\nthen restart Windows.');
     }
     const todo = checks.filter((check) => check.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).'));
+    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/commands/user-config.d.ts

@@ -1,8 +1,8 @@
 import type { Context } from './context.js';
-export declare const configFile: (ctx: Context) => string;
+export declare function configFile(ctx: Context): string;
 /** The value as written in your file (not merged with the defaults). */
-export declare const fileSetting: <T>(ctx: Context, key: string[], fallback: T) => T;
-export declare const setSetting: (ctx: Context, key: string[], value: unknown) => void;
+export declare function fileSetting<T>(ctx: Context, key: string[], fallback: T): T;
+export declare function setSetting(ctx: Context, key: string[], value: unknown): void;
 /** Adds a folder to a list setting (projects.roots, projects.exclude, ...) unless it is there already. */
-export declare const addToList: (ctx: Context, key: string[], folder: string) => boolean;
-export declare const removeFromList: (ctx: Context, key: string[], folder: string) => boolean;
+export declare function addToList(ctx: Context, key: string[], folder: string): boolean;
+export declare function removeFromList(ctx: Context, key: string[], folder: string): boolean;

package/dist/cli/commands/user-config.js

@@ -4,17 +4,19 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { parse } from 'jsonc-parser';
 import _ from 'lodash';
-import { userConfigPath } from '../../core/config.js';
-import { fail } from '../../core/util.js';
-import { editConfigText } from '../menu/settings/config-file.js';
-export const configFile = (ctx) => ctx.loaded.configPath ?? userConfigPath();
+import { userConfigPath } from '../../core/config/index.js';
+import { fail } from '../../core/util/index.js';
+import { editConfigText } from '../menu/settings/index.js';
+export function configFile(ctx) {
+    return ctx.loaded.configPath ?? userConfigPath();
+}
 /** The value as written in your file (not merged with the defaults). */
-export const fileSetting = (ctx, key, fallback) => {
+export function fileSetting(ctx, key, fallback) {
     const file = configFile(ctx);
     const text = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '';
     return _.get(parse(text) ?? {}, key) ?? fallback;
-};
-export const setSetting = (ctx, key, value) => {
+}
+export function setSetting(ctx, key, value) {
     const file = configFile(ctx);
     const text = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '';
     const result = editConfigText(text, key, value);
@@ -22,20 +24,20 @@ export const setSetting = (ctx, key, value) => {
         fail('Could not change ' + key.join('.') + ':\n  ' + result.problems.join('\n  '));
     fs.mkdirSync(path.dirname(file), { recursive: true });
     fs.writeFileSync(file, result.text, 'utf8');
-};
+}
 /** Adds a folder to a list setting (projects.roots, projects.exclude, ...) unless it is there already. */
-export const addToList = (ctx, key, folder) => {
+export function addToList(ctx, key, folder) {
     const list = fileSetting(ctx, key, []);
     if (list.some((p) => path.resolve(p).toLowerCase() === path.resolve(folder).toLowerCase()))
         return false;
     setSetting(ctx, key, [...list, folder]);
     return true;
-};
-export const removeFromList = (ctx, key, folder) => {
+}
+export function removeFromList(ctx, key, folder) {
     const list = fileSetting(ctx, key, []);
     const rest = list.filter((p) => path.resolve(p).toLowerCase() !== path.resolve(folder).toLowerCase());
     if (rest.length === list.length)
         return false;
     setSetting(ctx, key, rest);
     return true;
-};
+}

package/dist/cli/history.d.ts

@@ -1,11 +1,12 @@
 import { z } from 'zod';
-declare const History: z.ZodArray<z.ZodObject<{
+declare const HistorySchema: z.ZodArray<z.ZodObject<{
     argv: z.ZodArray<z.ZodString>;
     at: z.ZodString;
 }, z.core.$strict>>;
-export declare const readHistory: () => z.output<typeof History>;
+type History = z.output<typeof HistorySchema>;
+export declare function readHistory(): 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;
+export declare function recordHistory(argv: string[]): void;
 /** argv as you would type it (quoted where needed). */
-export declare const commandLine: (argv: string[]) => string;
+export declare function commandLine(argv: string[]): string;
 export {};

package/dist/cli/history.js

@@ -1,21 +1,33 @@
 // The last commands run (menu or typed), kept in ~/.agent-sandbox/history.json so the menu can offer them again.
 import path from 'node:path';
 import { z } from 'zod';
-import { userDir } from '../core/config.js';
-import { writeJson } from '../core/util.js';
-import { readValid } from '../shared/rundir.js';
-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');
+import { userDir } from '../core/config/index.js';
+import { JsonFile } from '../shared/io/index.js';
+const HistorySchema = z.array(z.strictObject({ argv: z.array(z.string()).max(200), at: z.string() })).max(20);
+function historyFile() {
+    return new JsonFile(HistorySchema, path.join(userDir(), 'history.json'));
+}
 const HIDDEN = new Set(['menu', '_watch', 'self-test']);
-export const readHistory = () => readValid(History, historyFile()) ?? [];
+export function readHistory() {
+    return historyFile().read() ?? [];
+}
 /** Remembers a command (menu or typed) so the menu can offer it again. Never fails the command itself. */
-export const recordHistory = (argv) => {
+export function 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));
+        historyFile().write([
+            { argv, at: new Date().toISOString() },
+            ...readHistory().filter((h) => h.argv.join('\0') !== argv.join('\0')),
+        ].slice(0, 10));
     }
-    catch { /* history is a convenience */ }
-};
+    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(' ');
+export function commandLine(argv) {
+    return ['sandbox', ...argv]
+        .map((a) => (/[\s"]/.test(a) || a === '' ? '"' + a.replace(/"/g, '\\"') + '"' : a))
+        .join(' ');
+}

package/dist/cli/index.d.ts

@@ -1,20 +1,10 @@
-/** The package folder (this file is dist/cli/index.js). */
-export declare const packageRoot: string;
 export interface Preset {
     harness?: string;
     command?: string;
 }
-/** `--config <file>` right after the command name (where every command accepts it); argv unchanged without a config. */
-export declare const withConfig: (argv: string[], config: string | undefined) => string[];
-/** `sandbox --config f.json status` works like `sandbox status --config f.json`: a leading --config moves behind the command. */
-export declare const hoistConfig: (argv: string[]) => string[];
 /**
- * CLI entry. `preset` lets wrapper binaries fix the command/agent (sandbox claude = launch --harness claude). No arguments
- * opens the menu; `sandbox <agent> [agent args]` starts that agent.
+ * CLI entry. `preset` lets wrapper binaries fix the command/agent (sandbox claude = launch --harness claude). No
+ * arguments opens the menu; `sandbox <agent> [agent args]` starts that agent.
  */
-export declare const main: (rawArgv: string[], preset?: Preset) => Promise<number>;
-/** argv without `--config <file>` / `--config=<file>`. */
-export declare const withoutConfig: (argv: string[]) => string[];
-/** Prints a problem the way a user can act on it: what happened, how to fix it; stack traces only for real bugs. */
-export declare const report: (e: unknown) => number;
-export declare const run: (argv: string[], preset?: Preset) => void;
+export declare function main(rawArgv: string[], preset?: Preset): Promise<number>;
+export declare function run(argv: string[], preset?: Preset): void;

package/dist/cli/index.js

@@ -1,64 +1,24 @@
 import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { CommanderError } from 'commander';
 import { buildProgram, parseCli } from './args.js';
 import { commandSpec } from './manifest.js';
-import { c } from './colors.js';
 import { recordHistory } from './history.js';
 import { menu } from './menu/index.js';
 import { validateOptions } from './validate.js';
-import { loadConfig } from '../core/config.js';
+import { loadConfig } from '../core/config/index.js';
 import * as commands from './commands/index.js';
-import { UserError, errMsg, fail, plainText } from '../core/util.js';
-/** The package folder (this file is dist/cli/index.js). */
-export const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
-const entry = path.join(packageRoot, 'dist', 'bin', 'agent-sandbox.js');
-const HANDLERS = {
-    launch: (ctx) => commands.launch(ctx),
-    generate: (ctx) => commands.launch(ctx, true),
-    attach: commands.attach,
-    sessions: commands.sessions,
-    status: commands.status,
-    exec: commands.exec,
-    'agent-commands': commands.agentCommandsCommand,
-    db: commands.db,
-    restart: commands.restart,
-    stop: commands.stop,
-    show: commands.show,
-    hide: commands.hide,
-    account: commands.account,
-    projects: commands.projects,
-    sync: commands.sync,
-    logs: commands.logs,
-    audit: commands.audit,
-    clean: commands.clean,
-    config: commands.config,
-    doctor: commands.doctor,
-    setup: commands.setup,
-    data: commands.data,
-    'host-claude': commands.claudeHost,
-    _watch: commands.watcher,
-};
+import { fail } from '../core/util/index.js';
+import { PACKAGE_ROOT } from '../core/package-info.js';
+import { withConfig, hoistConfig, withoutConfig } from './argv.js';
+import { report } from './report.js';
+import { HANDLERS } from './commands/index.js';
+const entry = path.join(PACKAGE_ROOT, 'dist', 'bin', 'agent-sandbox.js');
 /** Runs an argv from the menu exactly as if it had been typed, reporting errors instead of throwing. */
 const runFromMenu = (config) => (argv) => main(withConfig(argv, config)).catch((e) => report(e));
-/** `--config <file>` right after the command name (where every command accepts it); argv unchanged without a config. */
-export const withConfig = (argv, config) => (config && argv.length ? [argv[0], '--config', config, ...argv.slice(1)] : argv);
-/** `sandbox --config f.json status` works like `sandbox status --config f.json`: a leading --config moves behind the command. */
-export const hoistConfig = (argv) => {
-    const eq = argv[0]?.startsWith('--config=');
-    if (argv[0] !== '--config' && !eq)
-        return argv;
-    const value = eq ? argv[0].slice('--config='.length) : argv[1];
-    const rest = argv.slice(eq ? 1 : 2);
-    if (value === undefined || value === '')
-        return argv;
-    return rest.length ? withConfig(rest, value) : ['menu', '--config', value];
-};
 /**
- * CLI entry. `preset` lets wrapper binaries fix the command/agent (sandbox claude = launch --harness claude). No arguments
- * opens the menu; `sandbox <agent> [agent args]` starts that agent.
+ * CLI entry. `preset` lets wrapper binaries fix the command/agent (sandbox claude = launch --harness claude). No
+ * arguments opens the menu; `sandbox <agent> [agent args]` starts that agent.
  */
-export const main = async (rawArgv, preset = {}) => {
+export async function main(rawArgv, preset = {}) {
     const argv = preset.command || preset.harness ? rawArgv : hoistConfig(rawArgv);
     const isAgent = (name) => {
         if (!name || name.startsWith('-') || commandSpec(name))
@@ -80,44 +40,34 @@ export const main = async (rawArgv, preset = {}) => {
     const options = parseCli(preset.command ? [preset.command, ...argv] : argv, Boolean(preset.harness));
     if (preset.harness)
         options.harness = preset.harness;
-    const typed = preset.harness ? ['launch', '--harness', preset.harness, ...argv] : preset.command ? [preset.command, ...argv] : argv;
+    const typed = preset.harness
+        ? ['launch', '--harness', preset.harness, ...argv]
+        : preset.command
+            ? [preset.command, ...argv]
+            : argv;
     if (options.command === 'menu')
-        return menu(commands.createContext(packageRoot, entry, options), runFromMenu(options.config));
+        return menu(commands.createContext(PACKAGE_ROOT, entry, options), runFromMenu(options.config));
     // Loaded only when asked for: normal commands never load test code.
     if (options.command === 'self-test')
-        return (await import('../selftest/index.js')).selfTest(packageRoot, options.positionals);
+        return (await import('../selftest/index.js')).selfTest(PACKAGE_ROOT, options.positionals);
     // repair must run even when the config file is broken (createContext would refuse it).
     if (options.command === 'repair') {
         recordHistory(withoutConfig(typed));
-        return commands.repairCommand(packageRoot, entry, options);
+        return commands.repairCommand(PACKAGE_ROOT, entry, options);
     }
     const handler = HANDLERS[options.command];
     if (!handler)
         return fail('Unknown command "' + options.command + '".', 'Run sandbox --help for the list of commands, or sandbox for the menu.');
-    const ctx = commands.createContext(packageRoot, entry, options);
+    const ctx = commands.createContext(PACKAGE_ROOT, entry, options);
     validateOptions(ctx);
     // Only what parsed and validated is offered again by the menu, without the --config (it is the same every time).
     recordHistory(withoutConfig(typed));
     return (await handler(ctx)) ?? 0;
-};
-/** argv without `--config <file>` / `--config=<file>`. */
-export const withoutConfig = (argv) => argv.filter((a, i) => a !== '--config' && argv[i - 1] !== '--config' && !a.startsWith('--config='));
-/** Prints a problem the way a user can act on it: what happened, how to fix it; stack traces only for real bugs. */
-export const report = (e) => {
-    if (e instanceof CommanderError)
-        return ['commander.helpDisplayed', 'commander.help', 'commander.version'].includes(e.code) ? 0 : e.exitCode || 1;
-    if (e instanceof UserError) {
-        // Messages can quote what the sandbox wrote (a session's status, an address): never with its control codes.
-        console.error(c.red('Error: ') + plainText(e.message));
-        if (e.fix)
-            console.error('  Fix:  ' + plainText(e.fix));
-        return 1;
-    }
-    console.error(c.red('Unexpected error: ') + errMsg(e));
-    console.error(c.dim('This is a bug in windows-development-sandbox. Details: ' + (e instanceof Error && e.stack ? e.stack.split('\n').slice(1, 4).join(' | ').trim() : 'none')));
-    console.error('  Please report it with the output of: sandbox doctor');
-    return 1;
-};
-export const run = (argv, preset) => {
-    main(argv, preset).then((code) => { process.exitCode = code; }, (e) => { process.exitCode = report(e); });
-};
+}
+export function run(argv, preset) {
+    main(argv, preset).then((code) => {
+        process.exitCode = code;
+    }, (e) => {
+        process.exitCode = report(e);
+    });
+}