agent-dev-env 0.1.0

package/dist/lib/ghcr.js

@@ -0,0 +1,82 @@
+// ghcr.ts — GHCR owner resolution and registry refs.
+//
+// Port of the owner discovery in scripts/deploy.sh / the runners, with one
+// planned change: the fallback is the default owner constant (ameshkov)
+// instead of dying — the CLI is a published package and cannot require a
+// checkout.
+//
+// Order: GHCR_OWNER env -> --owner flag -> git remote (inside a checkout)
+//        -> DEFAULT_GHCR_OWNER.
+import { gitConfigGet } from './git.js';
+/** @internal */
+export const DEFAULT_GHCR_OWNER = 'ameshkov';
+/** @internal */
+export const GHCR_REGISTRY = 'ghcr.io';
+/** Extracts the owner from a git remote URL. Mirrors the sed in
+ *  scripts/deploy.sh:
+ *
+ *    s#^(https?://[^/]+/|git@[^:]+:|ssh://[^/]+/)##   (strip the host part)
+ *    s#/[^/]*$##                                     (strip the repo name)
+ */
+/** @internal — Extracts the owner from a git remote URL (sed parity).
+ * @param remoteUrl - The remote.url value.
+ * @returns The owner slug, or undefined when it cannot be extracted.
+ */
+export function ownerFromGitRemote(remoteUrl) {
+    const afterHost = remoteUrl.replace(/^(https?:\/\/[^/]+\/|git@[^:]+:|ssh:\/\/[^/]+\/)/, '');
+    const owner = afterHost.replace(/\/[^/]*$/, '');
+    // A real owner is a plain slug; the sed would emit garbage for a URL
+    // without a path (e.g. "https://github.com" -> "https:/"), which is
+    // never a valid GHCR owner — guard instead of shipping it.
+    return /^[A-Za-z0-9_.-]+$/.test(owner) ? owner : undefined;
+}
+/** @internal — Pure resolution given the three inputs; synchronous and
+ *  testable.
+ * @param input - env / flag owner / remoteUrl.
+ * @returns The resolved owner (defaults to DEFAULT_GHCR_OWNER).
+ */
+export function resolveOwnerFrom(input = {}) {
+    const env = input.env ?? process.env;
+    const parts = [];
+    if (input.owner)
+        parts.push('flag');
+    if (env.GHCR_OWNER)
+        parts.push('env');
+    if (env.GHCR_OWNER) {
+        return env.GHCR_OWNER;
+    }
+    if (input.owner) {
+        return input.owner;
+    }
+    if (input.remoteUrl) {
+        const owner = ownerFromGitRemote(input.remoteUrl);
+        if (owner) {
+            return owner;
+        }
+    }
+    return DEFAULT_GHCR_OWNER;
+}
+/** Full resolution: env -> flag -> git remote in the repo ->
+ *  default.
+ * @param options - Flag owner / repo root / env overrides.
+ * @returns The resolved owner.
+ */
+export async function resolveOwner(options = {}) {
+    const remoteUrl = options.repoRoot
+        ? await gitConfigGet('remote.origin.url', { repoRoot: options.repoRoot })
+        : await gitConfigGet('remote.origin.url');
+    return resolveOwnerFrom({
+        env: options.env ?? process.env,
+        owner: options.owner,
+        remoteUrl,
+    });
+}
+/** ghcr.io/<owner>/<image>:<tag>
+ * @param image - The image name.
+ * @param tag - The tag.
+ * @param owner - The GHCR owner.
+ * @returns The full registry ref.
+ */
+export function registryRef(image, tag, owner) {
+    return `${GHCR_REGISTRY}/${owner}/${image}:${tag}`;
+}

package/dist/lib/git.js

@@ -0,0 +1,100 @@
+// git.ts — git helpers. Phase 1 landed the repo-root walk and git config
+// reads (GHCR owner discovery); Phase 7 adds the release-tag helpers
+// (clean-tree check, annotated tag creation/push, CHANGELOG entry
+// validation) — the port of scripts/tag.sh.
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { run } from './exec.js';
+/** Walks up from startDir to the first directory with a .git entry (a
+ *  checkout or a worktree).
+ *
+ * @param startDir - Directory to start the walk from.
+ * @returns The repo root, or null when nothing found.
+ */
+export function findRepoRoot(startDir = process.cwd()) {
+    let dir = resolve(startDir);
+    for (;;) {
+        if (existsSync(join(dir, '.git'))) {
+            return dir;
+        }
+        const parent = dirname(dir);
+        if (parent === dir) {
+            return null;
+        }
+        dir = parent;
+    }
+}
+/** `git config --get <key>` in the repo, first line;
+ *  undefined when the key is unset or git is unavailable. */
+export async function gitConfigGet(key, options = {}) {
+    const root = options.repoRoot ?? findRepoRoot();
+    if (!root) {
+        return undefined;
+    }
+    const res = await run('git', ['-C', root, 'config', '--get', key]);
+    return res.code === 0 ? res.stdout.trim().split('\n')[0] : undefined;
+}
+/** Whether the repo has no uncommitted changes (worktree and index) —
+ *  `git diff --quiet` + `git diff --cached --quiet`.
+ *
+ * @param repoRoot - The repo to check.
+ * @returns True when the tree is clean.
+ */
+export async function isWorkingTreeClean(repoRoot) {
+    const dirty = await run('git', ['-C', repoRoot, 'diff', '--quiet']);
+    if (dirty.code !== 0) {
+        return false;
+    }
+    const staged = await run('git', ['-C', repoRoot, 'diff', '--cached', '--quiet']);
+    return staged.code === 0;
+}
+/** Whether a tag already exists (`git rev-parse --verify --quiet`).
+ *
+ * @param repoRoot - The repo to check.
+ * @param tag - The tag name.
+ * @returns True when the tag exists.
+ */
+export async function tagExists(repoRoot, tag) {
+    const res = await run('git', [
+        '-C',
+        repoRoot,
+        'rev-parse',
+        '--verify',
+        '--quiet',
+        `refs/tags/${tag}`,
+    ]);
+    return res.code === 0;
+}
+/** The shell's `grep -q "## [<tag>]"` check: the changelog must contain a
+ *  `## [<tag>]` heading line.
+ *
+ * @param changelogContent - The changelog file content.
+ * @param tag - The tag name to look for.
+ * @returns True when the changelog has the entry.
+ */
+export function changelogHasTagEntry(changelogContent, tag) {
+    return changelogContent.includes(`## [${tag}]`);
+}
+/** Creates an annotated tag (`git tag -a <tag> -m <message>`).
+ *
+ * @param repoRoot - The repo to tag.
+ * @param tag - The tag name.
+ * @param message - The annotation message.
+ */
+export async function createAnnotatedTag(repoRoot, tag, message) {
+    const res = await run('git', ['-C', repoRoot, 'tag', '-a', tag, '-m', message]);
+    if (res.code !== 0) {
+        throw new Error(`git tag failed: ${res.stderr.trim() || res.stdout.trim()}`);
+    }
+}
+/** Pushes a tag to origin (`git push origin <tag>`); throws on failure.
+ *
+ * @param repoRoot - The repo with the tag.
+ * @param tag - The tag name to push.
+ */
+export async function pushTag(repoRoot, tag) {
+    const res = await run('git', ['-C', repoRoot, 'push', 'origin', tag]);
+    if (res.code !== 0) {
+        throw new Error(`git push origin ${tag} failed: ${res.stderr.trim() || res.stdout.trim()}`);
+    }
+}

package/dist/lib/logger.js

@@ -0,0 +1,87 @@
+// logger.ts — output helpers for the CLI, ported 1:1 from the shell
+// scripts' shared color/step helpers (scripts/lib/macos-settings.sh and the
+// copies in every runner).
+//
+// Conventions (kept identical to the shell):
+//   - stdout colors: bold, dim, green, yellow, blue, reset
+//   - stderr colors: bold, red, yellow, reset
+//   - colors only when the stream is a TTY and NO_COLOR is unset
+//   - die(): "<name>: <msg>" (bold red) on stderr, exit 1
+//   - warn(): "<name>: warning: <msg>" (bold yellow) on stderr
+//   - title/step/info/cmd/ok() as in the shell runners (info is plain,
+//     4-space indented; cmd is dim; ok is green)
+import { env as processEnv, stderr as processStderr, stdout as processStdout } from 'node:process';
+const ANSI = {
+    bold: '\u001b[1m',
+    dim: '\u001b[2m',
+    green: '\u001b[32m',
+    yellow: '\u001b[33m',
+    blue: '\u001b[34m',
+    red: '\u001b[31m',
+};
+const RESET = '\u001b[0m';
+const DEFAULT_NAME = 'agent-dev-env';
+/** @internal — the public surface is the `logger` instance below. */
+export class Logger {
+    name;
+    stdout;
+    stderr;
+    env;
+    constructor(options = {}) {
+        this.name = options.name ?? DEFAULT_NAME;
+        this.stdout = options.stdout ?? processStdout;
+        this.stderr = options.stderr ?? processStderr;
+        this.env = options.env ?? processEnv;
+    }
+    /** Whether this stream should carry color (TTY + NO_COLOR unset). */
+    enabled(stream) {
+        return Boolean(stream.isTTY) && !this.env.NO_COLOR;
+    }
+    /** ANSI code for the color on the given stream, or '' when disabled. */
+    color(name, stream = this.stdout) {
+        return this.enabled(stream) ? ANSI[name] : '';
+    }
+    /** Reset code for the given stream ('' when disabled). */
+    reset(stream = this.stdout) {
+        return this.enabled(stream) ? RESET : '';
+    }
+    /** Bold text for the default stream — used by prompt() like the shell's
+     *  `${c_bold}${prompt}${c_reset}`. */
+    bold(text) {
+        return `${this.color('bold')}${text}${this.reset()}`;
+    }
+    die(message) {
+        const c = (name) => this.color(name, this.stderr);
+        this.stderr.write(`${c('bold')}${c('red')}${this.name}: ${message}${this.reset(this.stderr)}\n`);
+        process.exit(1);
+    }
+    warn(message) {
+        const c = (name) => this.color(name, this.stderr);
+        this.stderr.write(`${c('bold')}${c('yellow')}${this.name}: warning: ${message}${this.reset(this.stderr)}\n`);
+    }
+    title(message) {
+        this.stdout.write(`${this.color('bold')}${message}${this.reset()}\n`);
+    }
+    step(message) {
+        this.stdout.write(`${this.color('bold')}${this.color('blue')}==> ${message}${this.reset()}\n`);
+    }
+    info(message) {
+        this.stdout.write(`    ${message}\n`);
+    }
+    cmd(message) {
+        this.stdout.write(`${this.color('dim')}    ${message}${this.reset()}\n`);
+    }
+    ok(message) {
+        this.stdout.write(`${this.color('green')}    ${message}${this.reset()}\n`);
+    }
+    /** Raw line on stdout (table output, no indent/color). */
+    out(message) {
+        this.stdout.write(`${message}\n`);
+    }
+    /** Raw line on stderr (diagnostics not prefixed by the script name). */
+    err(message) {
+        this.stderr.write(`${message}\n`);
+    }
+}
+/** The default CLI logger (name: agent-dev-env). */
+export const logger = new Logger();

package/dist/lib/network.js

@@ -0,0 +1,63 @@
+// lib/network.ts — NAT-segment address resolution for the VMware runners
+// (the shell's find_host_alias + the x.y.z.1 fallback). VMware Fusion's
+// NAT is userspace (vmnetd): the guest's gateway is x.y.z.2 and the
+// host's own interface on that segment is x.y.z.1 (a dynamically named
+// bridge — there is no fixed vmnet8 device). The guest reaches the host
+// directly at that address, so the host-side bridges bind it.
+//
+// The resolver is kept pure (ifconfig text in → host IP out) so the
+// parsing is unit-tested with a fixture; the runner wraps it with the
+// ifconfig invocation and the fallback.
+import { run } from './exec.js';
+/** @internal — extracts the first host IPv4 address on the guest's /24
+ *  from `ifconfig` output, excluding the guest IP itself (the awk port:
+ *  scan `inet` lines, keep addresses sharing the first three octets,
+ *  drop the guest's own address, take the first).
+ *
+ * @param output - The raw `ifconfig` output.
+ * @param guestIp - The guest's IP (as reported by vmrun).
+ * @returns The host address, or undefined when none matches.
+ */
+export function hostAliasFromIfconfig(output, guestIp) {
+    const guest = guestIp.split('.');
+    if (guest.length !== 4) {
+        return undefined;
+    }
+    const candidates = new Set();
+    for (const line of output.split('\n')) {
+        if (!/\binet\s/.test(line)) {
+            continue;
+        }
+        const match = /\b(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})\b/.exec(line);
+        if (!match) {
+            continue;
+        }
+        const ip = match[1];
+        const parts = ip.split('.');
+        if (parts[0] === guest[0] && parts[1] === guest[1] && parts[2] === guest[2]) {
+            candidates.add(ip);
+        }
+    }
+    for (const ip of candidates) {
+        if (ip !== guestIp) {
+            return ip;
+        }
+    }
+    return undefined;
+}
+/** The host's address on the guest's NAT segment: scan the host
+ *  interfaces for the /24, fall back to x.y.z.1 (the legacy default when
+ *  no interface matches).
+ *
+ * @param guestIp - The guest's IP.
+ * @returns The host alias, or undefined when the guest IP is not a
+ *   dotted-quad (no segment to derive a host address from).
+ */
+export async function findHostAlias(guestIp) {
+    if (guestIp.split('.').length !== 4) {
+        return undefined;
+    }
+    const res = await run('ifconfig');
+    const alias = res.code === 0 ? hostAliasFromIfconfig(res.stdout, guestIp) : undefined;
+    return alias ?? `${guestIp.split('.').slice(0, 3).join('.')}.1`;
+}

package/dist/lib/paths.js

@@ -0,0 +1,116 @@
+// paths.ts — the on-disk state layout, designed from scratch (XDG-aware,
+// no migration from the legacy agent-sandbox paths).
+//
+// Resolution order (highest first):
+//
+//   1. AGENT_DEV_ENV_DATA_HOME / AGENT_DEV_ENV_LOG_DIR / AGENT_DEV_ENV_CACHE_DIR
+//   2. XDG_DATA_HOME / XDG_STATE_HOME / XDG_CACHE_HOME — when set (on any OS)
+//   3. Platform defaults:
+//
+//        Role   | macOS                                | Linux
+//        ------ | ------------------------------------ | ----------------------------
+//        Data   | ~/Library/Application Support/agent-dev-env | ~/.local/share/agent-dev-env
+//        Logs   | ~/Library/Logs/agent-dev-env               | ~/.local/state/agent-dev-env
+//        Cache  | ~/Library/Caches/agent-dev-env             | ~/.cache/agent-dev-env
+//
+// An empty value counts as unset (the shell's `${VAR:-default}` semantics),
+// so "export XDG_DATA_HOME=" still falls back to the platform default.
+//
+// Data layout under <data> (the plan's canonical layout):
+//
+//   <data>/
+//     build/<platform>/            packer build outputs (built image +
+//                                  packer_cache + staged drivers)
+//     build-context/<platform>/    materialized packer context (writable
+//                                  copy of images/<platform>)
+//     windows-qemu/<image>/        image/ (pristine qcow2), working/ (overlay,
+//                                  efivars.fd, tpm/, pids, socks)
+//     windows-vmware/<image>/      image/, base/, working/
+//     ubuntu-vmware/<image>/       image/, base/, working/
+//
+// macOS has no data footprint by design: Tart owns the image + working VM
+// (github.com/cirruslabs/tart) — only ~/Library/Logs/agent-dev-env/tart-*.log
+// is ours. Guest-side markers (~/.config/agent-dev-env/…) live inside the
+// guests; XDG_CONFIG_HOME is a documented future hook, no host config file
+// yet.
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+function firstNonEmpty(...values) {
+    for (const v of values) {
+        if (v) {
+            return v;
+        }
+    }
+    return undefined;
+}
+/** @internal — Resolves the three roots; deterministic and injectable for
+ *  tests.
+ * @param options - Env / home / platform overrides (tests).
+ * @returns The data, logs, and cache roots.
+ */
+export function resolvePaths(options = {}) {
+    const env = options.env ?? process.env;
+    const home = options.home ?? homedir();
+    const isDarwin = (options.platform ?? process.platform) === 'darwin';
+    const defaultData = isDarwin
+        ? join(home, 'Library', 'Application Support', 'agent-dev-env')
+        : join(home, '.local', 'share', 'agent-dev-env');
+    const defaultLogs = isDarwin
+        ? join(home, 'Library', 'Logs', 'agent-dev-env')
+        : join(home, '.local', 'state', 'agent-dev-env');
+    const defaultCache = isDarwin
+        ? join(home, 'Library', 'Caches', 'agent-dev-env')
+        : join(home, '.cache', 'agent-dev-env');
+    return {
+        data: firstNonEmpty(env.AGENT_DEV_ENV_DATA_HOME, env.XDG_DATA_HOME) ?? defaultData,
+        logs: firstNonEmpty(env.AGENT_DEV_ENV_LOG_DIR, env.XDG_STATE_HOME) ?? defaultLogs,
+        cache: firstNonEmpty(env.AGENT_DEV_ENV_CACHE_DIR, env.XDG_CACHE_HOME) ?? defaultCache,
+    };
+}
+/** The resolved roots for this process. */
+export const paths = resolvePaths();
+/** @internal — <data>/<platform>, the platform's state root (unused by
+ *  macOS).
+ * @param platform - The platform id.
+ * @returns The platform's data dir.
+ */
+export function platformDir(platform) {
+    return join(paths.data, platform);
+}
+/** <data>/build/<platform>: packer build contexts + outputs (deployable
+ *  artifacts; lives under data, not cache, because deploy consumes it).
+ * @param platform - The platform id.
+ * @returns The platform's build dir.
+ */
+export function buildDir(platform) {
+    return join(paths.data, 'build', platform);
+}
+/** <data>/<platform>/<image> — the per-image state root.
+ *
+ * @param platform - The platform id.
+ * @param image - The image name.
+ * @returns The image's state dir.
+ */
+export function imageRootDir(platform, image) {
+    return join(paths.data, platform, image);
+}
+/** <data>/<platform>/<image>/image/<image>.tar.gz — the cached VMware
+ *  archive (the runner's pull cache; status/deploy read it too).
+ *
+ * @param platform - The platform id.
+ * @param image - The image name.
+ * @returns The cached archive path.
+ */
+export function vmwareArchivePath(platform, image) {
+    return join(imageRootDir(platform, image), 'image', `${image}.tar.gz`);
+}
+/** <data>/<platform>/<image>/working/<image>.vmx — the VMware working
+ *  clone (the vmx path the runners/stop/delete flows derive).
+ *
+ * @param platform - The platform id.
+ * @param image - The image name.
+ * @returns The working vmx path.
+ */
+export function workingVmxPath(platform, image) {
+    return join(imageRootDir(platform, image), 'working', `${image}.vmx`);
+}

package/dist/lib/platform.js

@@ -0,0 +1,87 @@
+// platform.ts — the platform registry: platform ids, the images/ directory
+// name for each, and the run-time defaults the shell scripts hardcoded
+// (VM/image names, bridge ports, VM resources, download hints).
+export const PLATFORMS = ['macos', 'windows-qemu', 'windows-vmware', 'ubuntu-vmware'];
+/** images/<dir> name -> platform id. The image-name/platform naming scheme
+ *  is fixed (AGENTS.md conventions); never introduce a separate one. */
+export const PLATFORM_DIR_MAP = {
+    mac: 'macos',
+    'windows-arm64-qemu': 'windows-qemu',
+    'windows-arm64-vmware': 'windows-vmware',
+    'ubuntu-arm64-vmware': 'ubuntu-vmware',
+};
+export const PLATFORM_DEFAULTS = {
+    macos: {
+        image: 'sandbox-macos-tahoe',
+        vmName: 'sandbox-macos',
+        stateDir: 'macos',
+        agentPort: 4100,
+        dockerPort: 4101,
+        openchamberPort: 4000,
+        cpuCount: 8,
+        memoryMb: 16384,
+        workDir: '/Volumes/dev',
+        mountName: 'dev',
+        supportsAgentRules: true,
+        supportsSettings: true,
+        supportsSync: true,
+        supportsPristineDelete: true,
+        downloadHint: '~50 GB',
+    },
+    'windows-qemu': {
+        image: 'sandbox-windows-11-arm64-qemu',
+        vmName: 'sandbox-windows-11-arm64-qemu',
+        stateDir: 'windows-qemu',
+        agentPort: 4200,
+        dockerPort: 4201,
+        openchamberPort: 4000,
+        sshPort: 2222,
+        rdpPort: 3389,
+        winrmPort: 5985,
+        cpuCount: 4,
+        memoryMb: 8192,
+        supportsAgentRules: false,
+        supportsSettings: false,
+        supportsSync: false,
+        supportsPristineDelete: false,
+        downloadHint: '~14 GB',
+    },
+    'windows-vmware': {
+        image: 'sandbox-windows-11-arm64-vmware',
+        vmName: 'agent-sandbox-windows-11-arm64-vmware',
+        stateDir: 'windows-vmware',
+        agentPort: 4300,
+        dockerPort: 4301,
+        openchamberPort: 4000,
+        cpuCount: 4,
+        memoryMb: 8192,
+        supportsAgentRules: false,
+        supportsSettings: false,
+        supportsSync: false,
+        supportsPristineDelete: false,
+        downloadHint: '~20 GB',
+    },
+    'ubuntu-vmware': {
+        image: 'sandbox-ubuntu-24-04-arm64-vmware',
+        vmName: 'agent-sandbox-ubuntu-24-04-arm64-vmware',
+        stateDir: 'ubuntu-vmware',
+        agentPort: 4400,
+        dockerPort: 4401,
+        openchamberPort: 4000,
+        cpuCount: 4,
+        memoryMb: 8192,
+        supportsAgentRules: true,
+        supportsSettings: true,
+        supportsSync: true,
+        supportsPristineDelete: false,
+        downloadHint: '~15 GB',
+    },
+};
+/** Whether the string names a supported platform.
+ *
+ * @param value - The candidate platform id.
+ * @returns True when it is a known platform.
+ */
+export function isPlatform(value) {
+    return PLATFORMS.includes(value);
+}

package/dist/lib/prompt.js

@@ -0,0 +1,66 @@
+// prompt.ts — interactive confirm, ported 1:1 from the shell confirm():
+//
+//   prompt "…" [y|n]   ->   "… [Y/n] "  (or "… [y/N] ")
+//   yes answers: y | Y | yes | YES
+//   empty answer: the default (y -> yes, n -> no)
+//   anything else: no
+//   EOF (non-interactive input that ran dry): no — the shell's `read`
+//   fails, which returns 1 (no), always.
+//
+// The shell also prints a newline right after the prompt when stdin is not
+// a TTY, because nothing will echo it otherwise — kept here.
+import { createInterface } from 'node:readline';
+import { stdin as processStdin, stdout as processStdout } from 'node:process';
+import { logger } from './logger.js';
+const YES_ANSWERS = new Set(['y', 'Y', 'yes', 'YES']);
+/** Asks for a yes/no confirmation; resolves true when the user confirms.
+ *
+ * @param prompt - The question to display.
+ * @param options - Default answer + injectable input/output (tests).
+ * @returns True when confirmed, false otherwise (EOF is always false).
+ */
+export async function confirm(prompt, options = {}) {
+    const def = options.default ?? 'n';
+    const hint = def === 'y' ? 'Y/n' : 'y/N';
+    const output = options.output ?? processStdout;
+    const input = options.input ?? processStdin;
+    output.write(`${logger.bold(prompt)} [${hint}] `);
+    if (!output.isTTY) {
+        output.write('\n');
+    }
+    const rl = createInterface({ input, crlfDelay: Infinity });
+    const answer = await readFirstLine(rl);
+    rl.close();
+    if (answer === null) {
+        return false; // EOF — mirrors `read` failing (no).
+    }
+    if (YES_ANSWERS.has(answer.trim())) {
+        return true;
+    }
+    if (answer.trim() === '') {
+        return def === 'y';
+    }
+    return false;
+}
+/** First line read, or null on EOF. */
+async function readFirstLine(rl) {
+    for await (const line of rl) {
+        return line;
+    }
+    return null;
+}
+/** The `--yes` semantics used by the runners: skip the prompt and accept
+ *  the prompt's default — not an unconditional yes. A default-n prompt
+ *  (e.g. "restart the running VM?") stays a no with --yes.
+ *
+ * @param message - The question to display (when asking).
+ * @param options - Default answer + --yes flag; the rest (injectable
+ *   input/output) is ConfirmOptions for tests.
+ * @returns The (possibly defaulted) answer.
+ */
+export async function confirmDefault(message, options) {
+    if (options.yes) {
+        return options.default === 'y';
+    }
+    return confirm(message, { ...options, default: options.default });
+}