agent-dev-env 0.1.0

package/dist/commands/delete.js

@@ -0,0 +1,179 @@
+// commands/delete.ts — `agent-dev-env delete <platform> [--yes]
+// [--pristine]`: stop the sandbox (delegating to the same flow as
+// `stop`), then remove the VM/state. macOS: `tart delete` the working VM
+// (+ the pristine image with --pristine). VMware (Ubuntu + Windows) and
+// QEMU (Windows): `rm -rf` the state dir (extracted base + working clone
+// or overlay/TPM/NVRAM + pulled cache) — the next run re-pulls and
+// re-clones.
+import { existsSync, rmSync } from 'node:fs';
+import { run } from '../lib/exec.js';
+import { logger } from '../lib/logger.js';
+import { imageRootDir } from '../lib/paths.js';
+import { qemuStateDir } from '../lib/qemu.js';
+import { deleteVm, stopVm, tartAvailable, vmExists, vmState } from '../lib/tart.js';
+import { findVmrun } from '../lib/vmrun.js';
+import { confirm } from '../lib/prompt.js';
+import { resolveRunOptions } from '../runners/options.js';
+import { stopMacos, stopQemuSandbox, stopVmware } from './stop.js';
+/** Deletes a sandbox platform.
+ *
+ * @param platform - The platform to delete.
+ * @param options - --yes / --pristine flags.
+ * @returns The process exit code.
+ */
+export async function deleteCmd(platform, options) {
+    if (platform === 'macos') {
+        await deleteMacos(options);
+        return 0;
+    }
+    if (platform === 'windows-qemu') {
+        await deleteQemu(options);
+        return 0;
+    }
+    await deleteVmware(platform, options);
+    return 0;
+}
+/** The macOS delete flow (working VM, optionally the pristine image). */
+async function deleteMacos(options) {
+    if (!tartAvailable()) {
+        logger.die("tart is not installed — run 'brew install cirruslabs/cli/tart' first.");
+    }
+    const runOptions = resolveRunOptions('macos', { yes: options.yes });
+    const { vm, image } = runOptions;
+    const yes = options.yes === true;
+    logger.title(`Deleting macOS sandbox: ${vm}`);
+    logger.step('Stopping the sandbox');
+    await stopMacos();
+    logger.step('Deleting the working VM');
+    if (await vmExists(vm)) {
+        const ask = `Delete the working VM '${vm}'? This stops and removes it — the next ` +
+            `run re-clones it from '${image}'.`;
+        if (yes || (await confirm(ask, { default: 'y' }))) {
+            logger.cmd(`tart delete ${vm}`);
+            const res = await deleteVm(vm);
+            if (res.code === 0) {
+                if (await vmExists(vm)) {
+                    logger.warn(`VM '${vm}' still exists after 'tart delete'.`);
+                }
+                logger.ok(`Working VM '${vm}' deleted.`);
+            }
+            else {
+                logger.warn(`'tart delete ${vm}' failed — is it running?`);
+            }
+        }
+        else {
+            logger.info(`Kept '${vm}' — nothing was deleted.`);
+        }
+    }
+    else {
+        logger.info(`Working VM '${vm}' does not exist (already deleted?) — nothing to delete.`);
+    }
+    await maybeDeletePristine(image, yes, options.pristine === true);
+    logger.step('Sandbox deleted');
+    logger.info(`Working VM: ${vm} — deleted if it existed (next run re-clones from '${image}').`);
+    logger.info('Pristine image: ' + image + ' — kept or deleted per the flags above.');
+    logger.info('Next run: agent-dev-env run macos');
+}
+/** The VMware delete flow — stop first, then remove the state dir
+ *  (shared by the Ubuntu and Windows backends).
+ *
+ * @param platform - The VMware platform to delete.
+ * @param options - --yes flag.
+ */
+async function deleteVmware(platform, options) {
+    if (!findVmrun()) {
+        logger.die('vmrun not found — install VMware Fusion (free for personal use) or set FUSION_APP_PATH.');
+    }
+    const runOptions = resolveRunOptions(platform, { yes: options.yes });
+    const stateDir = imageRootDir(platform, runOptions.image);
+    const yes = options.yes === true;
+    const label = platform === 'ubuntu-vmware' ? 'Ubuntu' : 'Windows';
+    logger.title(`Deleting ${label} VMware sandbox: ${runOptions.image}`);
+    logger.step('Stopping the sandbox');
+    await stopVmware(platform);
+    logger.step('Deleting the state');
+    if (!existsSync(stateDir)) {
+        logger.info(`No state at ${stateDir} (already deleted?) — nothing to delete.`);
+    }
+    else {
+        const size = await dirSizeHuman(stateDir);
+        const ask = `Delete the sandbox state at '${stateDir}' (${size}; re-pulled on the next run)? ` +
+            `This removes the pristine base and the working clone of '${runOptions.image}'.`;
+        if (yes || (await confirm(ask, { default: 'y' }))) {
+            logger.cmd(`rm -rf ${stateDir}`);
+            rmSync(stateDir, { recursive: true, force: true });
+            logger.ok(`State deleted: ${stateDir} (${size} freed).`);
+            logger.warn("Fusion's VM library may still list the deleted working VM — remove the stale entry in the Fusion UI (harmless).");
+        }
+        else {
+            logger.info(`Kept '${stateDir}' — nothing was deleted.`);
+        }
+    }
+    logger.step('Sandbox deleted');
+    logger.info(`State: ${stateDir}`);
+    logger.info(`Next run: agent-dev-env run ${platform} (re-pulls the archive)`);
+}
+/** The QEMU delete flow — stop first (delegating to the stop flow), then
+ *  remove the state dir (working disk overlay + TPM + EFI NVRAM + the
+ *  pulled image cache). The next run re-pulls the image and starts fresh.
+ *
+ * @param options - --yes flag.
+ */
+async function deleteQemu(options) {
+    const runOptions = resolveRunOptions('windows-qemu', { yes: options.yes });
+    const stateDir = qemuStateDir(runOptions.image);
+    const yes = options.yes === true;
+    logger.title(`Deleting Windows QEMU sandbox: ${runOptions.image}`);
+    logger.step('Stopping the sandbox');
+    await stopQemuSandbox();
+    logger.step('Deleting the state');
+    if (!existsSync(stateDir)) {
+        logger.info(`No state at ${stateDir} (already deleted?) — nothing to delete.`);
+    }
+    else {
+        const size = await dirSizeHuman(stateDir);
+        const ask = `Delete the sandbox state at '${stateDir}' (${size}; re-pulled on the next run)? ` +
+            `This removes the working overlay + TPM + EFI NVRAM and the pulled image of '${runOptions.image}'.`;
+        if (yes || (await confirm(ask, { default: 'y' }))) {
+            logger.cmd(`rm -rf ${stateDir}`);
+            rmSync(stateDir, { recursive: true, force: true });
+            logger.ok(`State deleted: ${stateDir} (${size} freed).`);
+        }
+        else {
+            logger.info(`Kept '${stateDir}' — nothing was deleted.`);
+        }
+    }
+    logger.step('Sandbox deleted');
+    logger.info(`State: ${stateDir}`);
+    logger.info(`Next run: agent-dev-env run windows-qemu (re-pulls the image)`);
+}
+/** @internal — `du -sh`-style human size ("12G", "812M"); '?' on failure. */
+export async function dirSizeHuman(dir) {
+    const res = await run('du', ['-sh', dir]);
+    return res.code === 0 ? res.stdout.trim().split('\t')[0] : '?';
+}
+/** The pristine-image deletion — always opt-in (never implied). */
+async function maybeDeletePristine(image, yes, pristine) {
+    const ask = `Also delete the pristine image '${image}' (frees ~50 GB; re-pulled from ` +
+        'GHCR on the next run)?';
+    if (!pristine && !(yes || (await confirm(ask, { default: 'n' })))) {
+        logger.info(`Kept the pristine image '${image}'.`);
+        return;
+    }
+    if (!(await vmExists(image))) {
+        logger.info(`Pristine image '${image}' does not exist — nothing to delete.`);
+        return;
+    }
+    if ((await vmState(image)) === 'running') {
+        logger.cmd(`tart stop ${image}`);
+        await stopVm(image);
+    }
+    logger.cmd(`tart delete ${image}`);
+    const res = await deleteVm(image);
+    if (res.code === 0) {
+        logger.ok(`Pristine image '${image}' deleted.`);
+    }
+    else {
+        logger.warn(`'tart delete ${image}' failed — is it running?`);
+    }
+}

package/dist/commands/doctor.js

@@ -0,0 +1,165 @@
+// commands/doctor.ts — `agent-dev-env doctor [--platform P]`: prereq table
+// with install hints and a free-disk estimate (against the vars files'
+// disk_size + the ~50 GB base image for macOS builds). Supersedes the
+// scattered require_cmd blocks; read-only.
+//
+// Exit code: 1 when any required check fails, 0 otherwise. Optional
+// (bridge/build-only) tooling is reported as such and does not fail the
+// check.
+import { statfsSync } from 'node:fs';
+import { listImages, varsFor } from '../lifecycle/catalog.js';
+import { commandExists } from '../lib/exec.js';
+import { logger } from '../lib/logger.js';
+import { PLATFORM_DEFAULTS, PLATFORMS } from '../lib/platform.js';
+import { findVmrun } from '../lib/vmrun.js';
+/** Overhead for the macOS base image (~50 GB, pulled for the build). */
+const BASE_IMAGE_GB = 50;
+/** Runs the prerequisite + free-disk check for one or all platforms.
+ *
+ * @param options - Platform scoping (all platforms by default).
+ * @returns Exit code: 0 when all required checks pass, 1 otherwise.
+ */
+export async function doctorCmd(options = {}) {
+    const targets = options.platform ? [options.platform] : [...PLATFORMS];
+    let anyFailed = false;
+    for (const [i, platform] of targets.entries()) {
+        if (i > 0) {
+            logger.out('');
+        }
+        anyFailed = (await printDoctor(platform)) || anyFailed;
+    }
+    return anyFailed ? 1 : 0;
+}
+async function printDoctor(platform) {
+    logger.title(`Doctor: ${platform} (${PLATFORM_DEFAULTS[platform].image})`);
+    const checks = await checksFor(platform);
+    const width = Math.max(...checks.map((c) => c.label.length), 'Requirement'.length);
+    const statusText = (c) => (c.ok ? 'ok' : c.required ? 'missing' : 'optional');
+    logger.out(`    ${'Requirement'.padEnd(width)}  Status  Hint`);
+    for (const check of checks) {
+        const status = statusText(check);
+        const colored = status === 'ok'
+            ? logger.color('green') + status + logger.reset()
+            : logger.color('red') + status + logger.reset();
+        const line = `${check.label.padEnd(width)}  ${colored.padEnd(status.length)}  ${check.hint}`;
+        logger.out(line.replace(/\s+$/, ''));
+    }
+    const failed = checks.filter((c) => c.required && !c.ok);
+    if (failed.length === 0) {
+        logger.ok('All checks passed.');
+    }
+    else {
+        logger.warn(`${failed.length} required check(s) failed.`);
+    }
+    return failed.length > 0;
+}
+async function checksFor(platform) {
+    const platformChecks = platform === 'macos'
+        ? macosChecks()
+        : platform === 'windows-qemu'
+            ? qemuChecks()
+            : vmwareChecks();
+    return [...hostChecks(platform), ...platformChecks];
+}
+/** Checks shared by every platform: host, arch, free disk. */
+function hostChecks(platform) {
+    const needed = diskNeededGb(platform);
+    const free = freeDiskGb();
+    return [
+        {
+            label: 'macOS host',
+            ok: process.platform === 'darwin',
+            required: true,
+            hint: 'the sandbox runners run on macOS only',
+        },
+        {
+            label: 'Apple Silicon',
+            ok: process.arch === 'arm64',
+            required: true,
+            hint: 'Tart/QEMU/Fusion can only virtualize ARM64 guests (Intel unsupported)',
+        },
+        {
+            label: 'free disk',
+            ok: free !== undefined && free >= needed,
+            required: true,
+            hint: free === undefined
+                ? 'could not determine free disk'
+                : `free ${free.toFixed(0)} GB vs ${needed.toFixed(0)} GB needed ` +
+                    `(disk_size + ~${BASE_IMAGE_GB} GB base image)`,
+        },
+    ];
+}
+function macosChecks() {
+    return [
+        {
+            label: 'tart',
+            ok: commandExists('tart'),
+            required: true,
+            hint: 'brew install cirruslabs/cli/tart',
+        },
+    ];
+}
+function qemuChecks() {
+    return [
+        {
+            label: 'qemu',
+            ok: commandExists('qemu-system-aarch64'),
+            required: true,
+            hint: 'brew install qemu',
+        },
+        {
+            label: 'qemu-img',
+            ok: commandExists('qemu-img'),
+            required: true,
+            hint: 'brew install qemu',
+        },
+        { label: 'swtpm', ok: commandExists('swtpm'), required: true, hint: 'brew install swtpm' },
+        {
+            label: 'oras',
+            ok: commandExists('oras'),
+            required: true,
+            hint: 'brew install oras — needed to pull images',
+        },
+    ];
+}
+function vmwareChecks() {
+    return [
+        {
+            label: 'vmrun',
+            ok: findVmrun() !== undefined,
+            required: true,
+            hint: 'install VMware Fusion (free for personal use) or set FUSION_APP_PATH',
+        },
+        {
+            label: 'oras',
+            ok: commandExists('oras'),
+            required: true,
+            hint: 'brew install oras — needed to pull images',
+        },
+    ];
+}
+/** Largest disk_size among the platform's images + the base-image
+ *  overhead. */
+function diskNeededGb(platform) {
+    let maxSize = 0;
+    try {
+        const sizes = listImages()
+            .filter((image) => image.platform === platform)
+            .map((image) => varsFor(image).disk_size)
+            .filter((size) => typeof size === 'number');
+        maxSize = sizes.length > 0 ? Math.max(...sizes) : 0;
+    }
+    catch {
+        // no image in the catalog — fall back to the default estimate
+    }
+    return (maxSize || 100) + BASE_IMAGE_GB;
+}
+function freeDiskGb() {
+    try {
+        const s = statfsSync('/');
+        return (s.bavail * s.bsize) / 1e9;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/commands/list.js

@@ -0,0 +1,38 @@
+// commands/list.ts — `agent-dev-env list`: the bundled images (name,
+// platform, image_version) from the per-image vars files, replacing
+// list_images()/find_vars_file() in build.sh/deploy.sh/tag.sh.
+import { imageVersion, listImages } from '../lifecycle/catalog.js';
+import { logger } from '../lib/logger.js';
+/** Prints the bundled images as a NAME / PLATFORM / VERSION table.
+ *
+ * @returns Exit code: 0 on success, 1 when no images are in the catalog.
+ */
+export async function listCmd() {
+    const images = listImages();
+    if (images.length === 0) {
+        logger.warn('No images found: no vars files under images/*/vars/.');
+        return 1;
+    }
+    const header = ['NAME', 'PLATFORM', 'VERSION'];
+    const rows = images.map((image) => {
+        let version = '?';
+        try {
+            version = imageVersion(image);
+        }
+        catch {
+            // vars file without image_version — show '?' and let the caller
+            // (deploy/tag) fail with the precise error.
+        }
+        return [image.name, image.platform, version];
+    });
+    const widths = header.map((h, i) => Math.max(h.length, ...rows.map((row) => row[i].length)));
+    const fmt = (cols) => cols
+        .map((c, i) => c.padEnd(widths[i]))
+        .join('  ')
+        .replace(/\s+$/, '');
+    logger.out(fmt(header));
+    for (const row of rows) {
+        logger.out(fmt(row));
+    }
+    return 0;
+}

package/dist/commands/not-yet.js

@@ -0,0 +1,15 @@
+// commands/not-yet.ts — the placeholder for the remaining unsupported
+// command/platform combo: `sync` on the Windows platforms (the settings
+// copy is tart/ssh2-based, like macOS/Ubuntu, and Windows has no such
+// transport yet).
+import { logger } from '../lib/logger.js';
+/** Reports that a command is not supported for the platform.
+ *
+ * @param command - The command name (run/stop/delete/sync).
+ * @param platform - The platform that is not supported.
+ * @returns The exit code to use (1).
+ */
+export function notYet(command, platform) {
+    logger.warn(`${command} is not supported for '${platform}'.`);
+    return 1;
+}

package/dist/commands/register.js

@@ -0,0 +1,150 @@
+// commands/register.ts — the commander surface. Splitting the CLI into
+// small register functions keeps every function under the oxlint
+// max-lines-per-function gate (mirrors src/cli/register-commands.ts in
+// ameshkov/mcp-compress-router).
+import { deleteCmd } from './delete.js';
+import { doctorCmd } from './doctor.js';
+import { listCmd } from './list.js';
+import { runCmd } from './run.js';
+import { statusCmd } from './status.js';
+import { stopCmd } from './stop.js';
+import { syncCmd } from './sync.js';
+import { buildCmd } from '../lifecycle/build.js';
+import { deployCmd } from '../lifecycle/deploy.js';
+import { tagCmd } from '../lifecycle/tag.js';
+import { watchBuildCmd } from '../lifecycle/watch-build.js';
+import { logger } from '../lib/logger.js';
+import { isPlatform } from '../lib/platform.js';
+const PLATFORM_CHOICE = 'macos|windows-qemu|windows-vmware|ubuntu-vmware';
+/** Validates the platform argument, dying when unknown (same message shape
+ *  as the shell's per-script usage errors). */
+function parsePlatform(value) {
+    if (!isPlatform(value)) {
+        logger.die(`unknown platform '${value}' (expected ${PLATFORM_CHOICE})`);
+    }
+    return value;
+}
+/** Registers run/stop/delete/sync — the per-platform VM commands.
+ *
+ * @param program - The commander program to wire commands onto.
+ */
+export function registerVmCommands(program) {
+    program
+        .command('run')
+        .argument('<platform>', PLATFORM_CHOICE, parsePlatform)
+        .description('Run (and wire up) a sandbox VM: macos | windows-qemu | windows-vmware | ubuntu-vmware')
+        .option('--headless', 'run without a window (tart run --no-graphics)')
+        .option('--foreground', 'keep the terminal attached and block until the VM stops')
+        .option('--no-agent', 'skip the SSH agent bridge setup')
+        .option('--no-docker', 'skip the Docker engine bridge setup')
+        .option('--no-settings', 'skip copying the host user settings into the guest')
+        .option('--work-dir <path>', 'host dir to share into the guest (SANDBOX_WORK_DIR)')
+        .option('--reset', 'delete the working VM first (fresh clone on this run)')
+        .option('--image <image>', 'pristine image VM to pull/clone from (SANDBOX_IMAGE)')
+        .option('--owner <owner>', 'GHCR owner for pulls (GHCR_OWNER)')
+        .option('--yes', 'skip confirmation prompts')
+        .action(async (platform, options) => {
+        process.exitCode = await runCmd(platform, options);
+    });
+    program
+        .command('stop')
+        .argument('<platform>', PLATFORM_CHOICE, parsePlatform)
+        .description('Stop the sandbox VM and its host bridges')
+        .action(async (platform) => {
+        process.exitCode = await stopCmd(platform);
+    });
+    program
+        .command('delete')
+        .argument('<platform>', PLATFORM_CHOICE, parsePlatform)
+        .option('--yes', 'do not ask for confirmation')
+        .option('--pristine', 'also delete the pristine image (macOS only, with tart delete)')
+        .description('Delete the sandbox VM/state (pristine image too with --pristine)')
+        .action(async (platform, options) => {
+        process.exitCode = await deleteCmd(platform, options);
+    });
+    program
+        .command('sync')
+        .argument('<platform>', PLATFORM_CHOICE, parsePlatform)
+        .option('--yes', 'do not ask for confirmation')
+        .description('Copy the host user settings into the guest (macos | ubuntu-vmware)')
+        .action(async (platform, options) => {
+        process.exitCode = await syncCmd(platform, options);
+    });
+}
+/** Registers status/list — the live-info commands (implemented).
+ *
+ * @param program - The commander program to wire commands onto.
+ */
+export function registerStatusCommands(program) {
+    program
+        .command('status')
+        .argument('[platform]', PLATFORM_CHOICE, parsePlatform)
+        .description('Live status of one or all platforms')
+        .action(async (platform) => {
+        process.exitCode = await statusCmd(platform);
+    });
+    program
+        .command('list')
+        .description('Bundled images: name, platform, image_version')
+        .action(async () => {
+        process.exitCode = await listCmd();
+    });
+}
+/** Registers build/deploy/tag — the image lifecycle (Phase 7).
+ *
+ * @param program - The commander program to wire commands onto.
+ */
+export function registerLifecycleCommands(program) {
+    program
+        .command('build')
+        .argument('[image...]', 'image names')
+        .option('--force', 'force a rebuild (packer -force)')
+        .option('--no-watchdog', 'skip the VNC build watchdog')
+        .description('Build sandbox images with Packer')
+        .action(async (images, options) => {
+        process.exitCode = await buildCmd(images, {
+            force: options.force,
+            watchdog: options.watchdog !== false,
+        });
+    });
+    program
+        .command('deploy')
+        .argument('[image...]', 'image names')
+        .option('--owner <owner>', 'GHCR owner override')
+        .description('Push locally built images to GHCR')
+        .action(async (images, options) => {
+        process.exitCode = await deployCmd(images, { owner: options.owner });
+    });
+    program
+        .command('tag')
+        .argument('[image...]', 'image names')
+        .option('--repo <path>', 'repo checkout to tag from (default: the current checkout)')
+        .description('Create and push the git release tag')
+        .action(async (images, options) => {
+        process.exitCode = await tagCmd(images, { repo: options.repo });
+    });
+}
+/** Registers doctor — plus the hidden build watch-build command.
+ *
+ * @param program - The commander program to wire commands onto.
+ */
+export function registerDoctorCommands(program) {
+    program
+        .command('doctor')
+        .option('--platform <platform>', PLATFORM_CHOICE, parsePlatform)
+        .description('Prerequisite + disk check for one or all platforms')
+        .action(async (options) => {
+        process.exitCode = await doctorCmd({ platform: options.platform });
+    });
+    program
+        .command('watch-build', { hidden: true })
+        .argument('<vnc-port>', 'VNC port of the Packer build (builder pins 5901)')
+        .argument('[outdir]', 'frame/output directory')
+        .option('--no-ocr', 'skip the optional macOS OCR fallback')
+        .description('Drive a VNC build watchdog against a build window')
+        .action(async (vncPort, outdir, options) => {
+        process.exitCode = await watchBuildCmd(Number.parseInt(vncPort, 10), outdir, {
+            noOcr: options.noOcr,
+        });
+    });
+}

package/dist/commands/run.js

@@ -0,0 +1,65 @@
+// commands/run.ts — `agent-dev-env run <platform>`: resolve the options
+// (flags > SANDBOX_* env > platform defaults), pick the backend, run the
+// shared flow (runners/framework.ts). Phase 3 shipped the macOS backend,
+// Phase 4 the Ubuntu VMware backend, Phase 5 the Windows VMware backend,
+// Phase 6 the Windows QEMU backend — all four platforms are green.
+import { logger } from '../lib/logger.js';
+import { runSandbox } from '../runners/framework.js';
+import { macosBackend } from '../runners/macos.js';
+import { resolveRunOptions } from '../runners/options.js';
+import { ubuntuBackend } from '../runners/ubuntu.js';
+import { windowsBackend } from '../runners/windows.js';
+import { windowsQemuBackend } from '../runners/windows-qemu.js';
+/** Runs a sandbox VM platform.
+ *
+ * @param platform - The platform to run.
+ * @param flags - The `run` command flags.
+ * @returns The process exit code.
+ */
+export async function runCmd(platform, flags) {
+    const options = resolveRunOptions(platform, flags);
+    const context = buildContext(options);
+    const title = platform === 'macos'
+        ? `macOS sandbox: ${context.vm} (image: ${context.image}, ` +
+            `${options.headless ? 'headless' : 'gui'} mode)`
+        : platform === 'windows-vmware'
+            ? `Windows VMware sandbox: ${context.vm} (image: ${context.image})`
+            : platform === 'windows-qemu'
+                ? `Windows QEMU sandbox: ${context.vm} (image: ${context.image})`
+                : `Ubuntu VMware sandbox: ${context.vm} (image: ${context.image})`;
+    logger.title(title);
+    const backend = platform === 'macos'
+        ? macosBackend
+        : platform === 'windows-vmware'
+            ? windowsBackend
+            : platform === 'windows-qemu'
+                ? windowsQemuBackend
+                : ubuntuBackend;
+    await runSandbox(backend, context);
+    return 0;
+}
+/** @internal — folds the resolved options into the runner context (the
+ *  guest mount path is the per-platform convention: Tart's
+ *  /Volumes/My Shared Files/ on macOS, /mnt/hgfs/work on VMware). */
+export function buildContext(options) {
+    const guestMount = options.platform === 'macos'
+        ? `/Volumes/My Shared Files/${options.mountName}`
+        : '/mnt/hgfs/work';
+    return {
+        platform: options.platform,
+        options,
+        vm: options.vm,
+        image: options.image,
+        workDir: options.workDir,
+        mountName: options.mountName,
+        guestMount,
+        agentPort: options.agentPort,
+        dockerPort: options.dockerPort,
+        openchamberPort: options.openchamberPort,
+        sshPort: options.sshPort,
+        rdpPort: options.rdpPort,
+        winrmPort: options.winrmPort,
+        cpuCount: options.cpuCount,
+        memoryMb: options.memoryMb,
+    };
+}