windows-development-sandbox 1.4.1 → 1.4.3

package/config.example.json

@@ -88,7 +88,9 @@
       "components": [],
       "targets": [],
       "crates": [],
-      "targetDir": "separate"
+      "targetDir": "separate",
+      "linker": "lld",
+      "linkSlots": "auto"
     },
     "msvc": {
       "enabled": "auto",

package/dist/api.js

@@ -1,31 +1,42 @@
-// Programmatic API: `import { sandbox } from 'windows-development-sandbox'`. Same safety model as the CLI: the host only sends the
-// request kinds the guest daemon accepts, and everything coming back is validated data.
+// Programmatic API: `import { sandbox } from 'windows-development-sandbox'`. Same safety model as the CLI: the host
+// only sends the request kinds the guest daemon accepts, and everything coming back is validated data.
 import path from 'node:path';
-import { attachTerminal } from './host/attach.js';
-import { execInSandbox, pickSession, pingSandbox, requestSession, restartSessions, waitForReady, waitForSession } from './host/channel.js';
-import { loadConfig } from './core/config.js';
-import { listSessions, readSandboxStatus } from './shared/rundir.js';
-import { isSandboxRunning } from './host/platform.js';
-import { expandPath, fail } from './core/util.js';
+import { attachTerminal, SandboxChannel } from './host/channel/index.js';
+import { loadConfig } from './core/config/index.js';
+import { RunDir } from './shared/channel/index.js';
+import { isSandboxRunning } from './host/sandbox/index.js';
+import { expandPath, fail } from './core/util/index.js';
 export const sandbox = (options = {}) => {
     const loaded = loadConfig(options.config);
     const dataPath = path.join(expandPath(loaded.config.storage.root, loaded.base), 'data', loaded.config.storage.dataName);
     const alive = isSandboxRunning;
+    const channel = new SandboxChannel(dataPath, alive);
     // async: no sandbox is a rejected promise like every other failure, not a synchronous throw.
-    const ready = async () => (alive() ? waitForReady(dataPath, null, alive) : fail('No Windows Sandbox is running.', 'Start one first, e.g. sandbox claude --headless.'));
+    const ready = async () => alive()
+        ? channel.waitForReady(null)
+        : fail('No Windows Sandbox is running.', 'Start one first, e.g. sandbox claude --headless.');
     return {
         isRunning: alive,
-        status: () => readSandboxStatus(dataPath),
+        status: () => new RunDir(dataPath).readSandboxStatus(),
         ready,
-        sessions: () => listSessions(dataPath),
-        exec: async (command, o = {}) => execInSandbox(dataPath, command, o.cwd ?? (await ready()).guestWorkspace, o.timeoutSeconds ?? 600, alive),
+        sessions: () => new RunDir(dataPath).listSessions(),
+        exec: async (command, o = {}) => channel.exec(command, o.cwd ?? (await ready()).guestWorkspace, o.timeoutSeconds ?? 600),
         startSession: async (o = {}) => {
             const status = await ready();
-            return waitForSession(dataPath, requestSession(dataPath, o.harness ?? loaded.config.defaultHarness, o.args ?? [], o.cwd ?? status.guestWorkspace), alive);
+            return channel.waitForSession(channel.requestSession(o.harness ?? loaded.config.defaultHarness, o.args ?? [], o.cwd ?? status.guestWorkspace));
+        },
+        restart: async (harness) => {
+            await ready();
+            return channel.restart(harness ?? null);
+        },
+        ping: async () => {
+            await ready();
+            return channel.ping();
+        },
+        attach: async (sessionId) => {
+            await ready();
+            return attachTerminal(channel.pickSession(sessionId));
         },
-        restart: async (harness) => { await ready(); return restartSessions(dataPath, harness ?? null, alive); },
-        ping: async () => { await ready(); return pingSandbox(dataPath, alive); },
-        attach: async (sessionId) => { await ready(); return attachTerminal(pickSession(dataPath, sessionId)); },
     };
 };
 export { main } from './cli/index.js';

package/dist/cli/args.d.ts

@@ -40,16 +40,14 @@ export interface SessionWant {
     args?: string[];
 }
 /** Splits a command line like a shell: "quoted words" and 'quoted words' stay together. */
-export declare const splitArgs: (text: string) => string[];
+export declare function splitArgs(text: string): string[];
 /**
  * `<agent>@<folder>` (the folder may contain '@': only the first one splits), `<agent>` alone = the current folder,
  * and `|<arguments>` for that session's agent only ('|' cannot be in a Windows path). Folders become absolute against
  * `cwd`. Pure; validate.ts checks that the agent and folder exist.
  */
-export declare const parseSessionWant: (input: string, cwd?: string) => SessionWant;
-/** This package's version (this file is dist/cli/args.js, two folders below package.json). */
-export declare const packageVersion: () => string;
+export declare function parseSessionWant(input: string, cwd?: string): SessionWant;
 /** Every command, its options and help text, from manifest.ts. Actions only record what was parsed. */
-export declare const buildProgram: (record: (name: string, cmd: Command) => void) => Command;
+export declare function buildProgram(record: (name: string, cmd: Command) => void): Command;
 /** Parses argv into the command name and options. Throws commander errors for unknown commands/options. */
-export declare const parseCli: (argv: string[], wrapper?: boolean) => CliOptions;
+export declare function parseCli(argv: string[], wrapper?: boolean): CliOptions;

package/dist/cli/args.js

@@ -1,20 +1,22 @@
 // Command-line parsing with commander. parseCli() only parses (no side effects), so it is easy to test; cli/index.ts
-// dispatches the result. sandbox claude & co parse as `launch`: every option launch does not own goes to the agent, in order.
+// dispatches the result. sandbox claude & co parse as `launch`: every option launch does not own goes to the agent, in
+// order.
 import path from 'node:path';
-import { fileURLToPath } from 'node:url';
 import { Command, InvalidArgumentError, Option } from 'commander';
-import { z } from 'zod';
-import { fail, tryReadJson } from '../core/util.js';
-import { c } from './colors.js';
+import { fail } from '../core/util/index.js';
+import { c } from './output/index.js';
 import { COMMANDS } from './manifest.js';
+import { packageVersion } from '../core/package-info.js';
 /** Splits a command line like a shell: "quoted words" and 'quoted words' stay together. */
-export const splitArgs = (text) => [...text.matchAll(/"([^"]*)"|'([^']*)'|(\S+)/g)].map((m) => m[1] ?? m[2] ?? m[3]);
+export function splitArgs(text) {
+    return [...text.matchAll(/"([^"]*)"|'([^']*)'|(\S+)/g)].map((m) => m[1] ?? m[2] ?? m[3]);
+}
 /**
  * `<agent>@<folder>` (the folder may contain '@': only the first one splits), `<agent>` alone = the current folder,
  * and `|<arguments>` for that session's agent only ('|' cannot be in a Windows path). Folders become absolute against
  * `cwd`. Pure; validate.ts checks that the agent and folder exist.
  */
-export const parseSessionWant = (input, cwd = process.cwd()) => {
+export function parseSessionWant(input, cwd = process.cwd()) {
     const bar = input.indexOf('|');
     const text = bar < 0 ? input : input.slice(0, bar);
     const args = bar < 0 ? [] : splitArgs(input.slice(bar + 1));
@@ -24,23 +26,20 @@ export const parseSessionWant = (input, cwd = process.cwd()) => {
     if (!harness)
         fail('--session "' + text + '" names no agent.', 'Use --session <agent>@<folder>, e.g. --session claude@C:\\code\\api (the folder defaults to this one).');
     return { harness, folder: path.resolve(cwd, folder || '.'), ...(args.length ? { args } : {}) };
-};
-/** This package's version (this file is dist/cli/args.js, two folders below package.json). */
-export const packageVersion = () => {
-    const file = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..', 'package.json');
-    return z.object({ version: z.string() }).safeParse(tryReadJson(file)).data?.version ?? 'unknown';
-};
+}
 /** Reserved spelling for our launch options that can never clash with an agent's flags: --sbx-terminal, ... */
 const SBX_PREFIX = '--sbx-';
-const positiveNumber = (value) => {
+function positiveNumber(value) {
     const n = Number(value);
     if (!Number.isFinite(n) || n <= 0)
         throw new InvalidArgumentError('expected a positive number');
     return n;
-};
-const collect = (value, previous = []) => [...previous, value];
+}
+function collect(value, previous = []) {
+    return [...previous, value];
+}
 /** One commander option from its manifest entry. */
-const toOption = (o) => {
+function toOption(o) {
     const flags = (o.short ? o.short + ', ' : '') + o.flag + (o.type === 'boolean' ? '' : ' <' + (o.value ?? 'value') + '>');
     const option = new Option(flags, o.description);
     if (o.type === 'number')
@@ -50,19 +49,24 @@ const toOption = (o) => {
     if (o.default !== undefined)
         option.default(o.default);
     return option;
-};
+}
 /** Every command, its options and help text, from manifest.ts. Actions only record what was parsed. */
-export const buildProgram = (record) => {
+export function buildProgram(record) {
     const program = new Command('sandbox')
         .description('A disposable Windows Sandbox for development, with or without an AI agent, for the folder you are in. Run it with no arguments for the menu.')
         .version(packageVersion(), '-v, --version', 'show the version')
         .enablePositionalOptions()
         .showHelpAfterError('  Fix:  run the command with --help to see how to use it.')
-        .configureOutput({ outputError: (text, write) => write(c.red('Error: ') + text.replace(/^error: /, '').replace(/^./, (ch) => ch.toUpperCase())) })
+        .configureOutput({
+        outputError: (text, write) => write(c.red('Error: ') + text.replace(/^error: /, '').replace(/^./, (ch) => ch.toUpperCase())),
+    })
         .addHelpText('after', '\nPut --config <file> before or after the command to use another settings file.\nExamples:\n  sandbox                       the menu\n  sandbox claude -t             start Claude and attach this terminal\n  sandbox data clean logs       delete the saved logs\n  sandbox exec -- npm test      run a command in the running sandbox')
         .exitOverride();
     for (const spec of COMMANDS) {
-        const cmd = program.command(spec.name, { hidden: spec.hidden }).description(spec.summary).option('--config <file>', 'config file (default: ~/.agent-sandbox/config.json)');
+        const cmd = program
+            .command(spec.name, { hidden: spec.hidden })
+            .description(spec.summary)
+            .option('--config <file>', 'config file (default: ~/.agent-sandbox/config.json)');
         for (const option of spec.options)
             cmd.addOption(toOption(option));
         if (spec.json)
@@ -76,9 +80,9 @@ export const buildProgram = (record) => {
         cmd.action((...args) => record(spec.name, args[args.length - 1]));
     }
     return program;
-};
+}
 /** Turns `--sbx-<option>` into `--<option>` (only for options launch knows; anything else is an error). */
-const expandReserved = (argv, known) => {
+function expandReserved(argv, known) {
     const end = argv.indexOf('--');
     return argv.map((token, i) => {
         if ((end !== -1 && i > end) || !token.startsWith(SBX_PREFIX))
@@ -89,12 +93,17 @@ const expandReserved = (argv, known) => {
             fail('Unknown option: ' + flag, 'Reserved --sbx- options: ' + [...known].map((o) => o.replace('--', SBX_PREFIX)).join(', '));
         return value === undefined ? option : option + '=' + value;
     });
-};
+}
 /** Parses argv into the command name and options. Throws commander errors for unknown commands/options. */
-export const parseCli = (argv, wrapper = false) => {
+export function parseCli(argv, wrapper = false) {
     let parsed = null;
-    const program = buildProgram((name, cmd) => { parsed = { name, cmd }; });
-    const launchFlags = new Set(program.commands.find((c) => c.name() === 'launch').options.map((o) => o.long).filter(Boolean));
+    const program = buildProgram((name, cmd) => {
+        parsed = { name, cmd };
+    });
+    const launchFlags = new Set(program.commands
+        .find((c) => c.name() === 'launch')
+        .options.map((o) => o.long)
+        .filter(Boolean));
     const args = expandReserved(wrapper ? ['launch', ...argv] : argv, launchFlags);
     program.parse(args, { from: 'user' });
     if (!parsed)
@@ -102,7 +111,8 @@ export const parseCli = (argv, wrapper = false) => {
     const { name, cmd } = parsed;
     const o = { ...program.opts(), ...cmd.opts() };
     const forAgent = ['launch', 'start', 'generate', 'host-claude'].includes(name);
-    // Commander keeps our `--` separator among the operands when unknown options are allowed; it is ours, not the agent's.
+    // Commander keeps our `--` separator among the operands when unknown options are allowed; it is ours, not the
+    // agent's.
     const separator = forAgent ? cmd.args.indexOf('--') : -1;
     const operands = separator === -1 ? cmd.args : [...cmd.args.slice(0, separator), ...cmd.args.slice(separator + 1)];
     return {
@@ -118,7 +128,10 @@ export const parseCli = (argv, wrapper = false) => {
         node: o.node,
         python: o.python,
         scripts: o.script ?? [],
-        databases: (o.database ?? []).flatMap((d) => d.split(',')).map((d) => d.trim()).filter(Boolean),
+        databases: (o.database ?? [])
+            .flatMap((d) => d.split(','))
+            .map((d) => d.trim())
+            .filter(Boolean),
         headless: o.window ? false : o.headless ? true : undefined,
         terminal: Boolean(o.terminal),
         newSession: Boolean(o.new),
@@ -138,8 +151,28 @@ export const parseCli = (argv, wrapper = false) => {
         kind: o.kind,
         grep: o.grep,
     };
-};
-const defaults = () => ({
-    command: '', positionals: [], passthrough: [], scripts: [], databases: [], terminal: false, newSession: false, noAgent: false, trustConfig: false, noLocalConfig: false,
-    personal: false, fromHost: false, noRestart: false, follow: false, json: false, yes: false, all: false, sessions: [], timeout: 600, days: 7,
-});
+}
+function defaults() {
+    return {
+        command: '',
+        positionals: [],
+        passthrough: [],
+        scripts: [],
+        databases: [],
+        terminal: false,
+        newSession: false,
+        noAgent: false,
+        trustConfig: false,
+        noLocalConfig: false,
+        personal: false,
+        fromHost: false,
+        noRestart: false,
+        follow: false,
+        json: false,
+        yes: false,
+        all: false,
+        sessions: [],
+        timeout: 600,
+        days: 7,
+    };
+}

package/dist/cli/argv.d.ts

@@ -0,0 +1,9 @@
+/** `--config <file>` right after the command name (where every command accepts it); argv unchanged without a config. */
+export declare function 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 function hoistConfig(argv: string[]): string[];
+/** argv without `--config <file>` / `--config=<file>`. */
+export declare function withoutConfig(argv: string[]): string[];

package/dist/cli/argv.js

@@ -0,0 +1,22 @@
+/** `--config <file>` right after the command name (where every command accepts it); argv unchanged without a config. */
+export function withConfig(argv, config) {
+    return 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 function 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];
+}
+/** argv without `--config <file>` / `--config=<file>`. */
+export function withoutConfig(argv) {
+    return argv.filter((a, i) => a !== '--config' && argv[i - 1] !== '--config' && !a.startsWith('--config='));
+}

package/dist/cli/commands/accounts.d.ts

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

package/dist/cli/commands/accounts.js

@@ -1,52 +1,67 @@
 // `account list | save | use | default | remove`
-import { activateAccount, listAccounts, removeAccount, saveAccount, setDefaultAccount } from '../../host/accounts.js';
-import { restartSessions, runningSessions } from '../../host/channel.js';
-import { hostClaudeDir, hostGlobalStateFile } from '../../host/claude-profile.js';
-import { isSandboxRunning } from '../../host/platform.js';
-import { fail, safeText } from '../../core/util.js';
-import { printJson, sandboxAlive, table } from './context.js';
-const label = (a) => '"' + a.name + '"' + (a.email ? ' (' + a.email + ')' : '');
+import { AccountStore, hostClaudeDir, hostGlobalStateFile } from '../../host/profile/index.js';
+import { SandboxChannel } from '../../host/channel/index.js';
+import { isSandboxRunning } from '../../host/sandbox/index.js';
+import { fail, safeText } from '../../core/util/index.js';
+import { printJson, table } from '../output/index.js';
+function label(a) {
+    return '"' + a.name + '"' + (a.email ? ' (' + a.email + ')' : '');
+}
 /** This PC's Claude login location (config folder + global state file). */
-const hostLogin = (ctx) => {
+function hostLogin(ctx) {
     const profile = ctx.loaded.config.claudeProfile;
     return { claudeDir: hostClaudeDir(profile), globalStateFile: hostGlobalStateFile(profile) };
-};
-const list = (ctx) => {
-    const rows = listAccounts(ctx.storageRoot, ctx.dataPath);
+}
+function list(ctx) {
+    const rows = new AccountStore(ctx.storageRoot).list(ctx.dataPath);
     if (printJson(ctx, rows))
         return 0;
     if (rows.length === 0) {
-        console.log('No saved accounts. Sign in inside the sandbox, then: sandbox account save <name>   (or --from-host to save this PC\'s login)');
+        console.log("No saved accounts. Sign in inside the sandbox, then: sandbox account save <name>   (or --from-host to save this PC's login)");
         return 0;
     }
-    table([['', 'NAME', 'EMAIL', 'SAVED'], ...rows.map((a) => [(a.isActive ? '*' : ' ') + (a.isDefault ? 'D' : ' '), a.name, a.email ?? '-', a.savedAt.slice(0, 16).replace('T', ' ')])]);
+    table([
+        ['', 'NAME', 'EMAIL', 'SAVED'],
+        ...rows.map((a) => [
+            (a.isActive ? '*' : ' ') + (a.isDefault ? 'D' : ' '),
+            a.name,
+            a.email ?? '-',
+            a.savedAt.slice(0, 16).replace('T', ' '),
+        ]),
+    ]);
     console.log('\n* = active in the sandbox   D = default for new launches');
     return 0;
-};
-const use = async (ctx, name) => {
-    console.log('Sandbox now uses ' + label(activateAccount(ctx.storageRoot, ctx.dataPath, name)) + '.');
-    const claudeRunning = isSandboxRunning() && runningSessions(ctx.dataPath).some((s) => s.harness === 'claude');
+}
+async function use(ctx, name) {
+    console.log('Sandbox now uses ' + label(new AccountStore(ctx.storageRoot).activate(ctx.dataPath, name)) + '.');
+    const claudeRunning = isSandboxRunning() && new SandboxChannel(ctx.dataPath).runningSessions().some((s) => s.harness === 'claude');
     if (claudeRunning && !ctx.options.noRestart)
-        console.log(safeText((await restartSessions(ctx.dataPath, 'claude', sandboxAlive)).message) + ' with --continue; the conversation carries on under the new account.');
+        console.log(safeText((await new SandboxChannel(ctx.dataPath).restart('claude')).message) +
+            ' with --continue; the conversation carries on under the new account.');
     return 0;
-};
-export const account = async (ctx) => {
+}
+export async function account(ctx) {
     const [action = 'list', name] = ctx.options.positionals;
     const needName = () => name ?? fail('Missing account name.', 'Usage: sandbox account ' + action + ' <name>');
     switch (action) {
-        case 'list': return list(ctx);
+        case 'list':
+            return list(ctx);
         case 'save':
-            console.log('Saved account ' + label(saveAccount(ctx.storageRoot, ctx.dataPath, needName(), ctx.options.fromHost ? hostLogin(ctx) : null)) + '.');
+            console.log('Saved account ' +
+                label(new AccountStore(ctx.storageRoot).save(ctx.dataPath, needName(), ctx.options.fromHost ? hostLogin(ctx) : null)) +
+                '.');
             return 0;
-        case 'use': return use(ctx, needName());
+        case 'use':
+            return use(ctx, needName());
         case 'default':
-            setDefaultAccount(ctx.storageRoot, needName());
+            new AccountStore(ctx.storageRoot).setDefault(needName());
             console.log('Default account: ' + name);
             return 0;
         case 'remove':
-            removeAccount(ctx.storageRoot, needName());
+            new AccountStore(ctx.storageRoot).remove(needName());
             console.log('Removed account ' + name);
             return 0;
-        default: fail('Unknown account action "' + action + '".', 'Use one of: sandbox account list | save <name> | use <name> | default <name> | remove <name>');
+        default:
+            fail('Unknown account action "' + action + '".', 'Use one of: sandbox account list | save <name> | use <name> | default <name> | remove <name>');
     }
-};
+}

package/dist/cli/commands/agent-commands.d.ts

@@ -1,6 +1,6 @@
 import type { Config } from '../../core/types.js';
-import { type Reconciled } from '../../host/agent-commands.js';
+import { type Reconciled } from '../../host/agent-commands/index.js';
 import { type Context } from './context.js';
 /** Brings this PC in line with agentCommands and says what changed (used after on/off, settings and launch). */
-export declare const syncAgentCommands: (ctx: Context, config: Config, quiet?: boolean) => Reconciled | null;
-export declare const agentCommandsCommand: (ctx: Context) => number;
+export declare function syncAgentCommands(ctx: Context, config: Config, quiet?: boolean): Reconciled | null;
+export declare function agentCommandsCommand(ctx: Context): number;

package/dist/cli/commands/agent-commands.js

@@ -1,40 +1,48 @@
 // `sandbox agent-commands [status|on|off]` (Beta): typing claude, codex ... on this PC starts them in a hidden sandbox.
 import fs from 'node:fs';
 import path from 'node:path';
-import { loadConfig, userConfigPath } from '../../core/config.js';
-import { fail } from '../../core/util.js';
-import { agentCommands, commandsDir, reconcileAgentCommands } from '../../host/agent-commands.js';
-import { insideSandbox } from '../../host/platform.js';
-import { writeFileAtomic } from '../../shared/rundir.js';
-import { c } from '../colors.js';
-import { editConfigText } from '../menu/settings/config-file.js';
-import { table } from './context.js';
-const entryOf = (ctx) => path.join(ctx.packageRoot, 'dist', 'bin', 'sandbox.js');
+import { loadConfig, userConfigPath } from '../../core/config/index.js';
+import { fail } from '../../core/util/index.js';
+import { agentCommands, commandsDir, reconcileAgentCommands, } from '../../host/agent-commands/index.js';
+import { insideSandbox } from '../../host/sandbox/index.js';
+import { writeFileAtomic } from '../../shared/io/index.js';
+import { c, table } from '../output/index.js';
+import { editConfigText } from '../menu/settings/index.js';
+function entryOf(ctx) {
+    return path.join(ctx.packageRoot, 'dist', 'bin', 'sandbox.js');
+}
 /** Brings this PC in line with agentCommands and says what changed (used after on/off, settings and launch). */
-export const syncAgentCommands = (ctx, config, quiet = false) => {
+export function syncAgentCommands(ctx, config, quiet = false) {
     if (insideSandbox())
         return null;
     const result = reconcileAgentCommands(config, ctx.storageRoot, process.execPath, entryOf(ctx));
     if (!result.changed || quiet)
         return result;
     if (result.on) {
-        console.log('Agent commands (Beta) are on for: ' + (result.commands.map((a) => a.command).join(', ') || 'no installed agents found'));
+        console.log('Agent commands (Beta) are on for: ' +
+            (result.commands.map((a) => a.command).join(', ') || 'no installed agents found'));
         console.log(c.dim('Open a new terminal, then type e.g. claude in any project folder. Run the real one: set SANDBOX_AGENT_DIRECT=1'));
     }
     else
         console.log('Agent commands are off: claude, codex ... run on this PC again (open a new terminal).');
     return result;
-};
-export const agentCommandsCommand = (ctx) => {
+}
+export function agentCommandsCommand(ctx) {
     if (insideSandbox())
-        fail('Agent commands change your PC\'s PATH, so they are set up from your PC, not inside the sandbox.', 'Run sandbox agent-commands on in a terminal on your PC.');
+        fail("Agent commands change your PC's PATH, so they are set up from your PC, not inside the sandbox.", 'Run sandbox agent-commands on in a terminal on your PC.');
     const action = ctx.options.positionals[0] ?? 'status';
     if (action === 'status') {
         const config = ctx.loaded.config;
         const found = agentCommands(config, ctx.storageRoot);
-        console.log('Agent commands (Beta): ' + (config.agentCommands.enabled ? c.green('on') : 'off') + c.dim('  (' + commandsDir(ctx.storageRoot) + ')'));
+        console.log('Agent commands (Beta): ' +
+            (config.agentCommands.enabled ? c.green('on') : 'off') +
+            c.dim('  (' + commandsDir(ctx.storageRoot) + ')'));
         if (found.length)
-            table(found.map((a) => [a.command, 'sandboxed ' + a.harness + (config.agentCommands.enabled ? '' : ' when on'), c.dim('real: ' + a.real)]));
+            table(found.map((a) => [
+                a.command,
+                'sandboxed ' + a.harness + (config.agentCommands.enabled ? '' : ' when on'),
+                c.dim('real: ' + a.real),
+            ]));
         else
             console.log(c.dim('No agents found on this PC (claude, codex, gemini ... on your PATH).'));
         if (!config.agentCommands.enabled)
@@ -51,11 +59,12 @@ export const agentCommandsCommand = (ctx) => {
     writeFileAtomic(file, edited.text);
     const result = syncAgentCommands(ctx, loadConfig(file).config, true);
     if (result?.on) {
-        console.log('Agent commands (Beta) are on: ' + (result.commands.map((a) => a.command).join(', ') || 'no installed agents found yet'));
+        console.log('Agent commands (Beta) are on: ' +
+            (result.commands.map((a) => a.command).join(', ') || 'no installed agents found yet'));
         console.log(c.dim('Open a new terminal, then type e.g. claude in a project folder: it starts in a hidden sandbox and attaches.'));
         console.log(c.dim('Run the real one on this PC: set SANDBOX_AGENT_DIRECT=1 (PowerShell: $env:SANDBOX_AGENT_DIRECT=1). Turn off: sandbox agent-commands off'));
     }
     else
         console.log('Agent commands are off: claude, codex ... run on this PC again. Open a new terminal.');
     return 0;
-};
+}

package/dist/cli/commands/context.d.ts

@@ -8,16 +8,14 @@ export interface Context {
     storageRoot: string;
     dataPath: string;
 }
-export declare const createContext: (packageRoot: string, entry: string, options: CliOptions) => Context;
-/** Prints rows as aligned columns (the last column is not padded). */
-export declare const table: (rows: string[][]) => void;
-/** Prints `value` as JSON when --json was given; returns whether it did. */
-export declare const printJson: (ctx: Context, value: unknown) => boolean;
-export declare const sandboxAlive: () => boolean;
+export declare function createContext(packageRoot: string, entry: string, options: CliOptions): Context;
 /** For commands that control the sandbox from your PC: inside the sandbox they make no sense. */
-export declare const requireOnPc: (what: string) => void;
-export declare const requireRunning: (hint?: string) => void;
-/** Maps a folder on this PC to its path inside the running sandbox (only folders inside the mapped workspace exist there). */
-export declare const guestPathFor: (hostDir: string, workspaceHost: string, guestWorkspace: string) => string;
+export declare function requireOnPc(what: string): void;
+export declare function requireRunning(hint?: string): void;
+/**
+ * Maps a folder on this PC to its path inside the running sandbox (only folders inside the mapped workspace exist
+ * there).
+ */
+export declare function guestPathFor(hostDir: string, workspaceHost: string, guestWorkspace: string): string;
 /** The guest folder for the current directory (or --workspace) in the running sandbox. */
-export declare const currentGuestDir: (ctx: Context, workspaceHost: string, guestWorkspace: string) => string;
+export declare function currentGuestDir(ctx: Context, workspaceHost: string, guestWorkspace: string): string;

package/dist/cli/commands/context.js

@@ -1,12 +1,11 @@
 // What every command receives, plus the small helpers they share.
 import fs from 'node:fs';
 import path from 'node:path';
-import _ from 'lodash';
-import { loadConfig, userDir } from '../../core/config.js';
-import { expandPath, fail, isInsideOrEqual } from '../../core/util.js';
-import { GUEST_DATA_DIR, insideSandbox, isSandboxRunning } from '../../host/platform.js';
+import { loadConfig, userDir } from '../../core/config/index.js';
+import { expandPath, fail, isInsideOrEqual } from '../../core/util/index.js';
+import { GUEST_DATA_DIR, insideSandbox, isSandboxRunning } from '../../host/sandbox/index.js';
 /** Keeps ~/.agent-sandbox/*.schema.json in step with the installed version (local schema paths editors trust). */
-const refreshSchemas = (packageRoot) => {
+function refreshSchemas(packageRoot) {
     const source = path.join(packageRoot, 'schemas');
     if (!fs.existsSync(source))
         return;
@@ -19,40 +18,44 @@ const refreshSchemas = (packageRoot) => {
                 fs.writeFileSync(target, text, 'utf8');
         }
     }
-    catch { /* editor help only; never block a command over it */ }
-};
-export const createContext = (packageRoot, entry, options) => {
+    catch {
+        /* editor help only; never block a command over it */
+    }
+}
+export function createContext(packageRoot, entry, options) {
     refreshSchemas(packageRoot);
     const loaded = loadConfig(options.config);
     const storageRoot = expandPath(loaded.config.storage.root, loaded.base);
     // Inside a sandbox, the sandbox's own data folder is the one to talk to.
-    return { packageRoot, entry, options, loaded, storageRoot, dataPath: insideSandbox() ? GUEST_DATA_DIR : path.join(storageRoot, 'data', loaded.config.storage.dataName) };
-};
-/** Prints rows as aligned columns (the last column is not padded). */
-export const table = (rows) => {
-    const widths = _.range(_.max(rows.map((r) => r.length)) ?? 0).map((i) => _.max(rows.map((r) => (r[i] ?? '').length)) ?? 0);
-    for (const row of rows)
-        console.log(row.map((cell, i) => (i === row.length - 1 ? cell : _.padEnd(cell, widths[i] + 2))).join(''));
-};
-/** Prints `value` as JSON when --json was given; returns whether it did. */
-export const printJson = (ctx, value) => {
-    // JSON.stringify leaves C1 controls (U+0080-U+009F) as they are; text from the sandbox must not reach a terminal raw.
-    if (ctx.options.json)
-        console.log(JSON.stringify(value, null, 2).replace(/[\u0080-\u009f]/g, (ch) => '\\u' + ch.charCodeAt(0).toString(16).padStart(4, '0')));
-    return ctx.options.json;
-};
-export const sandboxAlive = () => isSandboxRunning();
+    return {
+        packageRoot,
+        entry,
+        options,
+        loaded,
+        storageRoot,
+        dataPath: insideSandbox() ? GUEST_DATA_DIR : path.join(storageRoot, 'data', loaded.config.storage.dataName),
+    };
+}
 /** For commands that control the sandbox from your PC: inside the sandbox they make no sense. */
-export const requireOnPc = (what) => { if (insideSandbox())
-    fail('You are inside the sandbox already, so "sandbox ' + what + '" has nothing to control.', 'Run it from a terminal on your PC.'); };
-export const requireRunning = (hint = '') => { if (!isSandboxRunning())
-    fail('No Windows Sandbox is running.', hint || 'Start one with sandbox claude.'); };
-/** Maps a folder on this PC to its path inside the running sandbox (only folders inside the mapped workspace exist there). */
-export const guestPathFor = (hostDir, workspaceHost, guestWorkspace) => {
+export function requireOnPc(what) {
+    if (insideSandbox())
+        fail('You are inside the sandbox already, so "sandbox ' + what + '" has nothing to control.', 'Run it from a terminal on your PC.');
+}
+export function requireRunning(hint = '') {
+    if (!isSandboxRunning())
+        fail('No Windows Sandbox is running.', hint || 'Start one with sandbox claude.');
+}
+/**
+ * Maps a folder on this PC to its path inside the running sandbox (only folders inside the mapped workspace exist
+ * there).
+ */
+export function guestPathFor(hostDir, workspaceHost, guestWorkspace) {
     if (!isInsideOrEqual(workspaceHost, hostDir))
         fail('The running sandbox works on ' + workspaceHost + ', and Windows Sandbox cannot add folders while it runs.', 'Run from inside that folder, or stop the sandbox (sandbox stop) and launch again from ' + hostDir + '.');
     const rel = path.relative(workspaceHost, hostDir);
     return rel ? path.win32.join(guestWorkspace, rel) : guestWorkspace;
-};
+}
 /** The guest folder for the current directory (or --workspace) in the running sandbox. */
-export const currentGuestDir = (ctx, workspaceHost, guestWorkspace) => guestPathFor(path.resolve(ctx.options.workspace ?? process.cwd()), workspaceHost, guestWorkspace);
+export function currentGuestDir(ctx, workspaceHost, guestWorkspace) {
+    return guestPathFor(path.resolve(ctx.options.workspace ?? process.cwd()), workspaceHost, guestWorkspace);
+}

package/dist/cli/commands/data/clean.d.ts

@@ -11,5 +11,5 @@ export interface CleanTarget {
  * Turns `sandbox data clean` arguments into folders. Pure (no disk access); throws a UserError for anything that is
  * not a plain relative target inside the data folder: absolute paths, drive letters, `..`, wildcards, unknown areas.
  */
-export declare const resolveCleanTargets: (inputs: string[], dataPath: string, storageRoot: string) => CleanTarget[];
-export declare const dataClean: (ctx: Context) => Promise<number>;
+export declare function resolveCleanTargets(inputs: string[], dataPath: string, storageRoot: string): CleanTarget[];
+export declare function dataClean(ctx: Context): Promise<number>;