beehaven 0.8.16

package/dist/commands/d1.js

@@ -0,0 +1,253 @@
+/**
+ * beehaven d1 — Cloudflare D1 wrapper
+ *
+ * Reads D1 bindings from wrangler.toml/wrangler.jsonc so devs don't have
+ * to pass --database-id every call. Shells out to wrangler under the hood
+ * for the actual operations.
+ *
+ * Subcommands:
+ *   list                          List configured D1 bindings
+ *   exec <db> "SQL" [--local]     Run a SQL statement (defaults to --remote)
+ *   dump <db> <table>             Dump a table to JSON/CSV
+ *   migrate <db> apply [--local]  wrangler d1 migrations apply
+ *   migrate <db> list             wrangler d1 migrations list
+ *   migrate <db> create <name>    wrangler d1 migrations create
+ */
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { dirname, join, resolve } from 'path';
+import { spawn } from 'child_process';
+import { color, spinner, table } from '../spinner.js';
+function findWranglerConfig(start = process.cwd()) {
+    let dir = resolve(start);
+    while (true) {
+        for (const name of ['wrangler.toml', 'wrangler.jsonc', 'wrangler.json']) {
+            const p = join(dir, name);
+            if (existsSync(p))
+                return { path: p, d1: parseD1Bindings(p) };
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+function parseD1Bindings(configPath) {
+    const text = readFileSync(configPath, 'utf-8');
+    if (configPath.endsWith('.toml'))
+        return parseD1Toml(text);
+    return parseD1Json(text);
+}
+function parseD1Toml(text) {
+    const bindings = [];
+    const re = /\[\[d1_databases\]\][\s\S]*?(?=\n\[\[|\n\[|$)/g;
+    let match;
+    while ((match = re.exec(text)) !== null) {
+        const block = match[0];
+        const get = (k) => block.match(new RegExp(`${k}\\s*=\\s*"([^"]+)"`))?.[1];
+        const binding = get('binding');
+        const database_name = get('database_name');
+        const database_id = get('database_id');
+        if (binding && database_name)
+            bindings.push({ binding, database_name, database_id });
+    }
+    return bindings;
+}
+function parseD1Json(text) {
+    const stripped = text.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+    const cfg = JSON.parse(stripped);
+    const raw = cfg.d1_databases ?? cfg.d1 ?? [];
+    return raw.map((b) => ({
+        binding: b.binding,
+        database_name: b.database_name,
+        database_id: b.database_id,
+    }));
+}
+function resolveDbName(cfg, input) {
+    return cfg.d1.find((b) => b.database_name === input || b.binding === input) ?? null;
+}
+function runWrangler(args, opts = {}) {
+    return new Promise((resolveP) => {
+        const cwd = opts.cwd ?? dirname(findWranglerConfig()?.path ?? process.cwd());
+        const proc = spawn('npx', ['wrangler', ...args], {
+            cwd,
+            stdio: opts.capture ? ['inherit', 'pipe', 'pipe'] : 'inherit',
+            env: { ...process.env },
+        });
+        let stdout = '';
+        let stderr = '';
+        if (opts.capture) {
+            proc.stdout?.on('data', (d) => (stdout += d.toString()));
+            proc.stderr?.on('data', (d) => (stderr += d.toString()));
+        }
+        proc.on('close', (code) => resolveP({ stdout, stderr, code: code ?? 1 }));
+        proc.on('error', () => resolveP({ stdout, stderr, code: 1 }));
+    });
+}
+function extractJson(stdout) {
+    const idx = stdout.indexOf('[');
+    if (idx === -1) {
+        const objIdx = stdout.indexOf('{');
+        if (objIdx === -1)
+            return null;
+        try {
+            return JSON.parse(stdout.slice(objIdx));
+        }
+        catch {
+            return null;
+        }
+    }
+    try {
+        return JSON.parse(stdout.slice(idx));
+    }
+    catch {
+        return null;
+    }
+}
+export async function d1(opts) {
+    const cfg = findWranglerConfig();
+    if (!cfg) {
+        console.error(color.red('No wrangler.toml/wrangler.jsonc found in cwd or any parent.'));
+        console.error(color.dim('Run from your worker project directory.'));
+        process.exit(1);
+    }
+    const sub = opts.subcommand ?? 'list';
+    const remoteFlag = opts.local ? '--local' : '--remote';
+    const envFlag = opts.env ? ['--env', opts.env] : [];
+    switch (sub) {
+        case 'list': {
+            if (cfg.d1.length === 0) {
+                console.log(color.dim(`No D1 bindings declared in ${cfg.path}.`));
+                return;
+            }
+            console.log('');
+            console.log(`  D1 databases ${color.dim('— ' + cfg.path)}`);
+            console.log('');
+            const rows = cfg.d1.map((b) => [
+                color.cyan(b.binding),
+                b.database_name,
+                b.database_id ? color.dim(b.database_id.slice(0, 8) + '…') : color.yellow('(unset)'),
+            ]);
+            console.log(table(['Binding', 'Name', 'ID'], rows));
+            console.log('');
+            console.log(color.dim('  beehaven d1 exec <name> "SELECT …"'));
+            return;
+        }
+        case 'exec': {
+            const dbInput = opts.positionals[0];
+            const query = opts.positionals[1];
+            if (!dbInput || !query) {
+                console.error('Usage: beehaven d1 exec <db> "<sql>" [--local] [--json]');
+                process.exit(1);
+            }
+            const db = resolveDbName(cfg, dbInput);
+            if (!db) {
+                console.error(color.red(`Unknown D1 db "${dbInput}". Known: ${cfg.d1.map((b) => b.database_name).join(', ')}`));
+                process.exit(1);
+            }
+            const s = spinner(`Running on ${db.database_name} (${opts.local ? 'local' : 'remote'})…`).start();
+            const { stdout, stderr, code } = await runWrangler(['d1', 'execute', db.database_name, remoteFlag, '--json', '--command', query, ...envFlag], { capture: true });
+            if (code !== 0) {
+                s.fail(`wrangler exited ${code}`);
+                if (stderr)
+                    console.error(color.dim(stderr));
+                if (stdout)
+                    console.error(color.dim(stdout));
+                process.exit(code);
+            }
+            const parsed = extractJson(stdout);
+            const results = Array.isArray(parsed) ? parsed[0]?.results : parsed?.results;
+            const meta = Array.isArray(parsed) ? parsed[0]?.meta : parsed?.meta;
+            s.succeed(`${results?.length ?? 0} rows${meta?.duration ? ` in ${meta.duration.toFixed(1)}ms` : ''}`);
+            if (!results || results.length === 0) {
+                console.log(color.dim('(no rows)'));
+                return;
+            }
+            if (opts.json) {
+                console.log(JSON.stringify(results, null, 2));
+                return;
+            }
+            const cols = Object.keys(results[0]);
+            console.log(table(cols, results.map((r) => cols.map((c) => String(r[c] ?? '')))));
+            return;
+        }
+        case 'dump': {
+            const dbInput = opts.positionals[0];
+            const tableName = opts.positionals[1];
+            if (!dbInput || !tableName) {
+                console.error('Usage: beehaven d1 dump <db> <table> [--out file.json] [--json]');
+                process.exit(1);
+            }
+            const db = resolveDbName(cfg, dbInput);
+            if (!db) {
+                console.error(color.red(`Unknown D1 db "${dbInput}". Known: ${cfg.d1.map((b) => b.database_name).join(', ')}`));
+                process.exit(1);
+            }
+            const s = spinner(`Dumping ${tableName} from ${db.database_name}…`).start();
+            const { stdout, code } = await runWrangler([
+                'd1',
+                'execute',
+                db.database_name,
+                remoteFlag,
+                '--json',
+                '--command',
+                `SELECT * FROM ${tableName}`,
+                ...envFlag,
+            ], { capture: true });
+            if (code !== 0) {
+                s.fail(`wrangler exited ${code}`);
+                process.exit(code);
+            }
+            const parsed = extractJson(stdout);
+            const results = Array.isArray(parsed) ? parsed[0]?.results : parsed?.results;
+            s.succeed(`${results?.length ?? 0} rows`);
+            const payload = JSON.stringify(results ?? [], null, 2);
+            if (opts.out) {
+                writeFileSync(opts.out, payload);
+                console.log(color.green(`✓ Wrote ${opts.out}`));
+            }
+            else {
+                console.log(payload);
+            }
+            return;
+        }
+        case 'migrate': {
+            const dbInput = opts.positionals[0];
+            const action = opts.positionals[1] ?? 'list';
+            const name = opts.positionals[2];
+            if (!dbInput) {
+                console.error('Usage: beehaven d1 migrate <db> <apply|list|create> [name]');
+                process.exit(1);
+            }
+            const db = resolveDbName(cfg, dbInput);
+            if (!db) {
+                console.error(color.red(`Unknown D1 db "${dbInput}"`));
+                process.exit(1);
+            }
+            const wranglerArgs = ['d1', 'migrations'];
+            switch (action) {
+                case 'apply':
+                    wranglerArgs.push('apply', db.database_name, remoteFlag, ...envFlag);
+                    break;
+                case 'list':
+                    wranglerArgs.push('list', db.database_name, remoteFlag, ...envFlag);
+                    break;
+                case 'create':
+                    if (!name) {
+                        console.error('Usage: beehaven d1 migrate <db> create <name>');
+                        process.exit(1);
+                    }
+                    wranglerArgs.push('create', db.database_name, name);
+                    break;
+                default:
+                    console.error(`Unknown migrate action: ${action}. Use apply | list | create.`);
+                    process.exit(1);
+            }
+            const { code } = await runWrangler(wranglerArgs);
+            process.exit(code);
+        }
+        default:
+            console.error(`Unknown d1 subcommand: ${sub}`);
+            console.error('Use: list | exec | dump | migrate');
+            process.exit(1);
+    }
+}

package/dist/commands/daemon-cmd.js

@@ -0,0 +1,162 @@
+/**
+ * `beehaven daemon <start|stop|status>` and `beehaven start --headless` —
+ * run the daemon WITHOUT the Hive Mac app (opt-in standalone mode).
+ *
+ * The daemon entry (`daemon-entry.js`) ships inside this package, so we can fork
+ * it directly. This is deliberately OPT-IN: the default `beehaven start` still
+ * opens the Mac tray app (Hive 1.0 single-spawn rule). Headless mode is for CI,
+ * servers, and agents on machines without the desktop app.
+ *
+ * Auth: the forked daemon runs with BEEHAVEN_NO_REPL=1 (no prompt), so a token
+ * must already be on disk — run `beehaven login` first. Voice/avatar/mood are
+ * desktop-only and stay unavailable headless; cloud + canvas control + DO ops work.
+ */
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { findLiveDaemons, resolveRelayUrlForDaemon } from '../daemon.js';
+/** dist/daemon-entry.js — sibling of dist/cli.js (this file is dist/commands/). */
+function daemonEntryPath() {
+    return join(dirname(fileURLToPath(import.meta.url)), '..', 'daemon-entry.js');
+}
+/**
+ * Fork the standalone daemon. The ONE spawn path — `beehaven start --headless`,
+ * `beehaven daemon start` and `beehaven restart` all route here.
+ *
+ * They did not always. `restart` used to inline its own `spawn()` that set
+ * BEEHAVEN_NO_REPL but NOT BEEHAVEN_HEADLESS, so every `beehaven restart`
+ * produced a daemon that printed a cheerful PID and then silently suicided ~3s
+ * later when the parent-death watchdog fired. The user saw "Daemon restarted
+ * (PID 13766)" followed by "Cannot connect to daemon" on the very next command.
+ * One spawn path means that divergence cannot come back.
+ */
+export function spawnStandaloneDaemon(values) {
+    const entry = daemonEntryPath();
+    if (!existsSync(entry)) {
+        console.error(`  daemon-entry.js not found at ${entry} — reinstall/rebuild the CLI (npm run build).`);
+        process.exit(1);
+    }
+    const devMode = !!(values.dev || values['dev-mode'] || process.env.HIVE_DEV_MODE);
+    const relayUrl = resolveRelayUrlForDaemon();
+    const child = spawn(process.execPath, [entry], {
+        detached: true,
+        stdio: 'ignore',
+        // BEEHAVEN_HEADLESS=1 is REQUIRED, not optional: daemon-entry.ts runs a
+        // parent-death watchdog (polls process.ppid, self-exits ~3s after the parent
+        // is gone) to enforce the tray-coupled lifecycle. A detached CLI-spawned
+        // daemon's parent (this process) exits immediately, so without HEADLESS the
+        // daemon would suicide ~3s later — "headless" never actually stayed up.
+        // Setting it disables that watchdog so the standalone daemon persists.
+        env: {
+            ...process.env,
+            BEEHAVEN_NO_REPL: '1',
+            BEEHAVEN_HEADLESS: '1',
+            BEEHAVEN_CLI_OWNED_DAEMON: '1',
+            BEEHAVEN_RELAY_URL: relayUrl,
+            ...(devMode ? { HIVE_DEV_MODE: '1' } : {}),
+        },
+    });
+    child.unref();
+    return child.pid;
+}
+/**
+ * How long `start --headless` waits for the new daemon's socket. The old code printed "confirms in
+ * ~2s", so ~2s is the observed startup; 12s is generous enough for a loaded machine (a deploy
+ * running alongside it, which is exactly when this bit) without hanging a script.
+ */
+const DAEMON_READY_TIMEOUT_MS = 12_000;
+const DAEMON_POLL_MS = 250;
+export async function startHeadlessDaemon(values) {
+    const existing = findLiveDaemons();
+    if (existing.length > 0) {
+        // A live PID is NOT proof the daemon is usable. If its socket was removed or
+        // it wedged, `start` says "already running" while every `call` says "cannot
+        // connect" — two commands contradicting each other with no way out named in
+        // either. Probe the socket and, when it's dead, say the one thing that fixes
+        // it. (This exact standoff cost a real session ~20 minutes.)
+        const { isDaemonRunning } = await import('../daemon-client.js');
+        if (await isDaemonRunning()) {
+            const { daemonRpc } = await import('../daemon-client.js');
+            let activeRelay = null;
+            try {
+                const status = await daemonRpc('daemon:status', {});
+                activeRelay = status?.relay?.endpoint ?? null;
+            }
+            catch { /* status is advisory; the socket probe already succeeded */ }
+            const configuredRelay = resolveRelayUrlForDaemon();
+            if (activeRelay && activeRelay.replace(/\/$/, '') !== configuredRelay.replace(/\/$/, '')) {
+                console.error(`  Daemon is running on ${activeRelay}, but the configured environment is ${configuredRelay}.\n` +
+                    `  The environment switch is NOT active. Apply it with:\n\n` +
+                    `      beehaven restart\n`);
+                process.exitCode = 2;
+                return;
+            }
+            console.log(`  Daemon already running (PID ${existing.join(', ')}). 'beehaven status' shows state.`);
+        }
+        else {
+            console.error(`  Daemon process is alive (PID ${existing.join(', ')}) but its IPC socket is NOT responding —\n` +
+                `  every 'beehaven call' will fail until it is replaced. Fix it with:\n\n` +
+                `      beehaven stop && beehaven start --headless\n`);
+            process.exitCode = 1;
+        }
+        return;
+    }
+    const devMode = !!(values.dev || values['dev-mode'] || process.env.HIVE_DEV_MODE);
+    const pid = spawnStandaloneDaemon(values);
+    /**
+     * ⚠⚠ WAIT FOR IT TO BE USABLE — RETURNING EARLY IS A RACE THAT LOOKS LIKE A BROKEN INSTALL.
+     *
+     * `stop` scrubs the IPC token on shutdown (`clearIpcAuthToken`, daemon.ts) and this spawn is
+     * DETACHED, so `beehaven stop && beehaven start --headless && beehaven call …` had a window in
+     * which no token existed on disk: the old one deleted, the new one not yet minted. Every command
+     * in that window failed with **"Cannot find IPC auth token"**, whose own text then blamed the
+     * daemon and advised a restart — which deletes the token again and re-enters the race.
+     *
+     * ⚠ THE OLD LINE ADMITTED IT: *"'beehaven status' confirms in ~2s"*. That is this function
+     * telling the caller to do the waiting, in a sentence, on a path every script uses.
+     *
+     * ⚠ IT POLLS FOR A USABLE SOCKET, NOT FOR THE TOKEN FILE. The token appearing is necessary and
+     * not sufficient — `isDaemonRunning` is the same probe `startHeadlessDaemon` already trusts above
+     * to tell a live PID from a wedged one.
+     *
+     * ⚠ AND IT NEVER FAILS THE COMMAND. A daemon that is slow to come up has still been started; the
+     * caller is told what state it is in rather than handed an error for something that is working.
+     */
+    const { isDaemonRunning } = await import('../daemon-client.js');
+    const deadline = Date.now() + DAEMON_READY_TIMEOUT_MS;
+    let ready = false;
+    while (Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, DAEMON_POLL_MS));
+        if (await isDaemonRunning()) {
+            ready = true;
+            break;
+        }
+    }
+    console.log(`  🐝 Headless daemon started (PID ${pid})${devMode ? ' [dev scope]' : ''}.`);
+    console.log(ready
+        ? `     Ready — socket answering.`
+        : `     Started, but not answering yet after ${Math.round(DAEMON_READY_TIMEOUT_MS / 1000)}s. 'beehaven status' shows state.`);
+}
+export async function cmdDaemon(sub, values) {
+    switch (sub) {
+        case 'start':
+            return startHeadlessDaemon(values);
+        case 'status': {
+            const live = findLiveDaemons();
+            console.log(live.length
+                ? `  Daemon running (PID ${live.join(', ')}).`
+                : '  No daemon running. Start one: beehaven daemon start');
+            return;
+        }
+        case 'stop':
+        case 'restart':
+            // Defer to the existing top-level stop/restart machinery.
+            console.log(`  Run: beehaven ${sub}`);
+            return;
+        default:
+            console.log('Usage: beehaven daemon <start|stop|status>   (start = headless, no Mac app)');
+            console.log('  Standalone daemon for CI / servers / agents. Run `beehaven login` first.');
+            return;
+    }
+}

package/dist/commands/deploy.js

@@ -0,0 +1,164 @@
+/**
+ * beehaven deploy — Deploy to Cloudflare.
+ *
+ * Discovers buildings from the app entry point (src/hive.ts), generates
+ * wrangler.toml + worker.ts, then runs wrangler deploy.
+ *
+ * Features:
+ *   - Pre-deploy checks: tsc --noEmit + vitest run (DEPLOY-03)
+ *   - Production confirmation gate (DEPLOY-02)
+ *   - Rollback and version listing (DEPLOY-01)
+ *   - Dry-run mode
+ */
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { spawn, execSync } from 'child_process';
+import { discoverBuildings, generateWrangler, generateWorker } from './dev-generate.js';
+import { spinner, color } from '../spinner.js';
+/**
+ * Run pre-deploy checks: TypeScript type checking and tests.
+ * Returns true if all checks pass, false otherwise.
+ */
+function runPreDeployChecks(cwd) {
+    console.log('  Running pre-deploy checks...\n');
+    // 1. TypeScript type check
+    const tscSpinner = spinner('Running type check...').start();
+    try {
+        execSync('npx tsc --noEmit', { cwd, stdio: 'pipe' });
+        tscSpinner.succeed('Type check passed');
+    }
+    catch (err) {
+        tscSpinner.fail('Type check failed');
+        if (err.stdout)
+            console.error(err.stdout.toString());
+        if (err.stderr)
+            console.error(err.stderr.toString());
+        console.error(`\n  Deploy aborted. Fix type errors or use ${color.bold('--skip-checks')} to bypass.\n`);
+        return false;
+    }
+    // 2. Run tests
+    const testSpinner = spinner('Running tests...').start();
+    try {
+        execSync('npx vitest run', { cwd, stdio: 'pipe', timeout: 120_000 });
+        testSpinner.succeed('Tests passed');
+    }
+    catch (err) {
+        testSpinner.fail('Tests failed');
+        if (err.stdout)
+            console.error(err.stdout.toString().slice(-2000));
+        if (err.stderr)
+            console.error(err.stderr.toString().slice(-2000));
+        console.error(`\n  Deploy aborted. Fix test failures or use ${color.bold('--skip-checks')} to bypass.\n`);
+        return false;
+    }
+    console.log(`\n  ${color.green('All pre-deploy checks passed.')}\n`);
+    return true;
+}
+export async function deploy(cwd, opts = {}) {
+    const appEntryPath = join(cwd, 'src', 'hive.ts');
+    if (!existsSync(appEntryPath)) {
+        console.error('  No src/hive.ts found. Run `beehaven init` first.');
+        process.exit(1);
+    }
+    if (opts.managed) {
+        console.log('\n  Managed deployment coming soon.');
+        console.log('  Use `beehaven deploy` (self-host via wrangler) for now.\n');
+        return;
+    }
+    // DEPLOY-02: Production confirmation gate
+    if (opts.env === 'production' && !opts.force && !opts.confirm) {
+        console.error('\n  \x1b[33m⚠ Production deployment requires confirmation.\x1b[0m');
+        console.error(`  Add --force or --confirm to deploy to production.`);
+        console.error(`  Example: beehaven deploy --env production --force\n`);
+        process.exit(1);
+    }
+    // DEPLOY-03: Pre-deploy checks
+    if (!opts.skipChecks && !opts.dryRun) {
+        const checksPass = runPreDeployChecks(cwd);
+        if (!checksPass) {
+            process.exit(1);
+        }
+    }
+    const deploySpinner = spinner('Deploying to Cloudflare...').start();
+    // Discover buildings from app entry
+    const buildings = discoverBuildings(cwd);
+    deploySpinner.update(`Deploying ${buildings.length} building(s) to Cloudflare...`);
+    console.log(`  Buildings: ${buildings.map((b) => `${b.name} (${b.className})`).join(', ')}`);
+    // Generate wrangler.toml + worker.ts
+    const genDir = join(cwd, '.beehaven', 'generated');
+    if (!existsSync(genDir))
+        mkdirSync(genDir, { recursive: true });
+    writeFileSync(join(genDir, 'wrangler.toml'), generateWrangler(cwd, buildings, 8787));
+    writeFileSync(join(genDir, 'worker.ts'), generateWorker(buildings));
+    // DEPLOY-02: Dry-run mode
+    if (opts.dryRun) {
+        console.log('\n  \x1b[36m[DRY RUN]\x1b[0m Would deploy with:');
+        console.log(`    wrangler.toml: ${join(genDir, 'wrangler.toml')}`);
+        console.log(`    worker.ts:     ${join(genDir, 'worker.ts')}`);
+        console.log(`    environment:   ${opts.env ?? 'default'}`);
+        console.log(`    buildings:     ${buildings.map((b) => b.name).join(', ')}`);
+        console.log('\n  No deployment executed.\n');
+        return;
+    }
+    deploySpinner.stop();
+    console.log(`  Buildings: ${buildings.map((b) => `${b.name} (${b.className})`).join(', ')}`);
+    const args = ['wrangler', 'deploy', '--config', join(genDir, 'wrangler.toml')];
+    if (opts.env)
+        args.push('--env', opts.env);
+    const wrangler = spawn('npx', args, {
+        cwd,
+        stdio: 'inherit',
+        shell: true,
+    });
+    wrangler.on('error', (err) => {
+        console.error(`  ${color.red('✗')} Failed to deploy: ${err.message}`);
+        process.exit(1);
+    });
+    wrangler.on('exit', (code) => {
+        if (code === 0) {
+            console.log(`\n  ${color.green('✓')} Deployed successfully!\n`);
+        }
+        process.exit(code || 0);
+    });
+}
+// DEPLOY-01: Rollback command
+export async function rollback(cwd, opts = {}) {
+    console.log('\n  Rolling back to previous deployment version...\n');
+    const args = ['wrangler', 'rollback'];
+    if (opts.env)
+        args.push('--env', opts.env);
+    const wrangler = spawn('npx', args, {
+        cwd,
+        stdio: 'inherit',
+        shell: true,
+    });
+    wrangler.on('error', (err) => {
+        console.error('  Rollback failed:', err.message);
+        process.exit(1);
+    });
+    wrangler.on('exit', (code) => {
+        if (code === 0) {
+            console.log('\n  Rollback complete.\n');
+        }
+        process.exit(code || 0);
+    });
+}
+// DEPLOY-01: Versions command
+export async function versions(cwd, opts = {}) {
+    console.log('\n  Listing deployment versions...\n');
+    const args = ['wrangler', 'versions', 'list'];
+    if (opts.env)
+        args.push('--env', opts.env);
+    const wrangler = spawn('npx', args, {
+        cwd,
+        stdio: 'inherit',
+        shell: true,
+    });
+    wrangler.on('error', (err) => {
+        console.error('  Failed to list versions:', err.message);
+        process.exit(1);
+    });
+    wrangler.on('exit', (code) => {
+        process.exit(code || 0);
+    });
+}