windows-development-sandbox 1.4.0 → 1.4.3

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

@@ -2,7 +2,7 @@
 import { GB } from '../../../core/disk.js';
 import { ENABLE_COMMAND } from './facts.js';
 /** Windows Sandbox needs Pro, Enterprise or Education (build 18305+); Home ("Core*") and Server cannot run it. */
-export const editionSupport = (edition) => {
+export function editionSupport(edition) {
     if (!edition)
         return 'unknown';
     if (/^Core/i.test(edition))
@@ -10,13 +10,24 @@ export const editionSupport = (edition) => {
     if (/^Server/i.test(edition))
         return 'unsupported';
     return /^(Professional|Enterprise|Education|IoTEnterprise)/i.test(edition) ? 'supported' : 'unknown';
-};
-export const nodeMajor = (version) => Number(/^v?(\d+)/.exec(version.trim())?.[1] ?? 0);
+}
+export function nodeMajor(version) {
+    return 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';
-const check = (name, status, detail) => ({ name, status, detail });
-const editionCheck = (f) => {
+export function canEnableFeature(f) {
+    return (f.feature !== 'enabled' &&
+        f.feature !== 'pending' &&
+        !f.sandboxExe &&
+        ['supported', 'unknown'].includes(editionSupport(f.edition)));
+}
+function formatGb(bytes) {
+    return (bytes / GB).toFixed(1) + ' GB';
+}
+function check(name, status, detail) {
+    return { name, status, detail };
+}
+function editionCheck(f) {
     const support = editionSupport(f.edition);
     const edition = (f.edition ?? 'unknown edition') + (f.build ? ', build ' + f.build : '');
     const name = 'Windows edition';
@@ -29,17 +40,17 @@ const editionCheck = (f) => {
     if (support === 'supported')
         return check(name, 'action', edition + ': too old; Windows Sandbox needs Windows 10 version 1903 or newer.');
     return check(name, 'warn', edition + ': not sure this edition has Windows Sandbox (it needs Pro, Enterprise or Education).');
-};
-const virtualizationCheck = (f) => {
+}
+function virtualizationCheck(f) {
     const name = 'CPU virtualization';
     const virt = f.hypervisorPresent || f.virtualizationFirmware;
     if (virt)
         return check(name, 'ok', f.hypervisorPresent ? 'on (hypervisor running)' : 'on');
     if (virt === false)
-        return check(name, 'action', 'off. Turn on Intel VT-x / AMD-V (SVM) in your PC\'s BIOS/UEFI settings, then run this again.');
+        return check(name, 'action', "off. Turn on Intel VT-x / AMD-V (SVM) in your PC's BIOS/UEFI settings, then run this again.");
     return check(name, 'warn', 'could not tell; if Windows Sandbox will not start, turn on VT-x / AMD-V in the BIOS/UEFI.');
-};
-const featureCheck = (f) => {
+}
+function featureCheck(f) {
     const name = 'Windows Sandbox feature';
     if (f.feature === 'enabled' && f.sandboxExe)
         return check(name, 'ok', 'enabled');
@@ -48,16 +59,16 @@ const featureCheck = (f) => {
     if (f.sandboxExe)
         return check(name, 'ok', 'installed');
     return check(name, 'action', 'not enabled. In an admin PowerShell: ' + ENABLE_COMMAND + ', then restart.');
-};
-const memoryCheck = (f) => {
+}
+function memoryCheck(f) {
     const gb = formatGb(f.totalRamBytes);
     if (f.totalRamBytes < 4 * GB)
         return check('Memory', 'action', gb + ': Windows Sandbox needs at least 4 GB.');
     if (f.totalRamBytes < 8 * GB)
         return check('Memory', 'warn', gb + ': works, but 8 GB or more is recommended.');
     return check('Memory', 'ok', gb);
-};
-const diskCheck = (f) => {
+}
+function diskCheck(f) {
     if (f.freeDiskBytes === null)
         return check('Free disk', 'warn', 'could not check the drive of ' + f.storageRoot);
     const free = formatGb(f.freeDiskBytes) + ' free for ' + f.storageRoot;
@@ -66,6 +77,12 @@ const diskCheck = (f) => {
     if (f.freeDiskBytes < 20 * GB)
         return check('Free disk', 'warn', free + ': getting low; toolchains and caches can use several GB.');
     return check('Free disk', 'ok', free);
-};
-const nodeCheck = (f) => nodeMajor(f.nodeVersion) >= 20 ? check('Node.js', 'ok', f.nodeVersion) : check('Node.js', 'action', f.nodeVersion + ': needs 20 or newer (winget install OpenJS.NodeJS.LTS).');
-export const buildChecks = (f) => [editionCheck(f), virtualizationCheck(f), featureCheck(f), memoryCheck(f), diskCheck(f), nodeCheck(f)];
+}
+function nodeCheck(f) {
+    return nodeMajor(f.nodeVersion) >= 20
+        ? check('Node.js', 'ok', f.nodeVersion)
+        : check('Node.js', 'action', f.nodeVersion + ': needs 20 or newer (winget install OpenJS.NodeJS.LTS).');
+}
+export function buildChecks(f) {
+    return [editionCheck(f), virtualizationCheck(f), featureCheck(f), memoryCheck(f), diskCheck(f), nodeCheck(f)];
+}

package/dist/cli/commands/setup/facts.d.ts

@@ -16,16 +16,16 @@ export interface MachineFacts {
 }
 export declare const ENABLE_COMMAND: string;
 /** `reg query <key>` output to { valueName: data }. */
-export declare const parseRegQuery: (text: string) => Record<string, string>;
+export declare function parseRegQuery(text: string): Record<string, string>;
 /** The "State : ..." line of `Dism /Get-FeatureInfo` (English output only; anything else is unknown). */
-export declare const parseDismState: (text: string) => FeatureState;
+export declare function parseDismState(text: string): FeatureState;
 /** Win32_OptionalFeature.InstallState: 1 enabled, 2 disabled, 3 absent. */
-export declare const featureFromInstallState: (state: number | null | undefined) => FeatureState;
-declare const Probe: z.ZodObject<{
+export declare function featureFromInstallState(state: number | null | undefined): FeatureState;
+declare const ProbeSchema: z.ZodObject<{
     virtualizationFirmware: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
     hypervisorPresent: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
     installState: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
 }, z.core.$strip>;
-export declare const parseProbe: (text: string) => z.infer<typeof Probe>;
-export declare const gatherFacts: (storageRoot: string) => MachineFacts;
+export declare function parseProbe(text: string): z.infer<typeof ProbeSchema>;
+export declare function gatherFacts(storageRoot: string): MachineFacts;
 export {};

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

@@ -3,23 +3,29 @@ import os from 'node:os';
 import _ from 'lodash';
 import { z } from 'zod';
 import { freeBytesAt } from '../../../core/disk.js';
-import { captureOutput, fileExists } from '../../../core/util.js';
+import { captureOutput, fileExists } from '../../../core/util/index.js';
 import { SYSTEM, system32 } from '../../../shared/system.js';
 const FEATURE = 'Containers-DisposableClientVM';
 export const ENABLE_COMMAND = 'Enable-WindowsOptionalFeature -Online -FeatureName ' + FEATURE + ' -All -NoRestart';
 /** `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))));
+export function parseRegQuery(text) {
+    return Object.fromEntries(_.compact(text
+        .split(/\r?\n/)
+        .map((line) => /^\s+(\S+)\s+REG_\w+\s+(.*)$/.exec(line)?.slice(1, 3))));
+}
 /** The "State : ..." line of `Dism /Get-FeatureInfo` (English output only; anything else is unknown). */
-export const parseDismState = (text) => {
+export function 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 function featureFromInstallState(state) {
+    return state === 1 ? 'enabled' : state === 2 || state === 3 ? 'disabled' : 'unknown';
+}
 // Fixed script (no outside data): CPU/hypervisor facts and the feature state, readable without admin rights.
 const PROBE = [
     '$ErrorActionPreference = "SilentlyContinue"',
@@ -31,16 +37,22 @@ const PROBE = [
     '$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) => {
+const ProbeSchema = z
+    .object({
+    virtualizationFirmware: z.boolean().nullable(),
+    hypervisorPresent: z.boolean().nullable(),
+    installState: z.number().nullable(),
+})
+    .partial();
+export function parseProbe(text) {
     try {
-        return Probe.parse(JSON.parse(_.last(text.trim().split(/\r?\n/)) ?? ''));
+        return ProbeSchema.parse(JSON.parse(_.last(text.trim().split(/\r?\n/)) ?? ''));
     }
     catch {
         return {};
     }
-};
-export const gatherFacts = (storageRoot) => {
+}
+export function gatherFacts(storageRoot) {
     const reg = parseRegQuery(captureOutput(SYSTEM.reg(), ['query', 'HKLM\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion']));
     const probe = parseProbe(captureOutput(SYSTEM.powershell(), ['-NoProfile', '-NonInteractive', '-Command', PROBE]));
     // DISM knows about a pending restart but needs admin rights; the CIM state works for everyone.
@@ -57,4 +69,4 @@ export const gatherFacts = (storageRoot) => {
         storageRoot,
         nodeVersion: process.version,
     };
-};
+}

package/dist/cli/commands/setup/index.d.ts

@@ -1,2 +1,2 @@
 import { type Context } from '../context.js';
-export declare const setup: (ctx: Context) => Promise<number>;
+export declare function setup(ctx: Context): Promise<number>;

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);
+    });
+}