runcloud 0.1.8 → 0.1.10

package/dist/commands/sandbox.js

@@ -2,9 +2,10 @@ import { InvalidArgumentError } from 'commander';
 import { execFileSync } from 'node:child_process';
 import { writeFileSync } from 'node:fs';
 import { resolve } from 'node:path';
-import { ApiClient, friendlyApiError } from '../api.js';
+import { ApiClient, ApiError, friendlyApiError } from '../api.js';
 import { requireCredentials } from '../config.js';
-import { registerBoxAccessCommands } from './boxAccess.js';
+import { runSandboxShell } from '../shellSession.js';
+import { noteDeprecated, registerAccessCommands } from './boxAccess.js';
 const MAX_SANDBOX_DISK_GIB = 2048;
 const DEFAULT_BOX_CPU_CORES = 2;
 const DEFAULT_BOX_MEMORY_MIB = 24 * 1024;
@@ -97,40 +98,126 @@ export function openBrowserUrl(url, platform = process.platform) {
     }
     execFileSync('xdg-open', [url], { stdio: 'ignore' });
 }
+async function findBoxForSandbox(api, sandboxId) {
+    const data = await api.get('/run-cloud/boxes');
+    return (data?.items ?? []).find((box) => box.sandboxId === sandboxId);
+}
+function attachHostname(api, sandboxId, name, port) {
+    return api.post('/run-cloud/boxes', { sandboxId, name, port });
+}
 export function registerSandbox(program) {
     const sandbox = program.command('sandbox').description('Spawn and control microVM sandboxes');
     withOutput(sandbox
         .command('create')
         .description('Spawn a microVM sandbox')
-        .option('--image <ref>', 'base image', 'runcloud/agent-base')
+        .option('--image <ref>', 'base image (default runcloud/agent-base, or runcloud/box with --expose)')
         .option('--region <region>', 'placement region')
-        .option('--name <name>', 'human-readable name')
+        .option('--name <name>', 'human-readable name; with --expose, the hostname prefix <name>-box.run.cloud')
         .option('--org <id>', 'billing and ownership organization')
         .option('--cpu <cores>', 'fractional vCPU allocation, e.g. 0.5', parseCpuCores)
         .option('--memory <mb>', 'memory allocation in MiB', parseMemoryMb)
         .option('--disk <gb>', 'root disk capacity in GiB', parseDiskGb)
-        .option('--idle-pause <seconds>', 'pause after inactivity; 0 keeps it running', parseIdlePauseSeconds)).action((opts) => run(async () => {
-        const body = { image: opts.image };
+        .option('--idle-pause <seconds>', 'pause after inactivity; 0 keeps it running', parseIdlePauseSeconds)
+        .option('--persistent', 'never pause when idle (same as --idle-pause 0)', false)
+        .option('--expose <port>', 'publish a guest port at <name>-box.run.cloud; implies --persistent', parsePort)).action((opts) => run(async () => {
+        const exposed = opts.expose !== undefined;
+        if (exposed && !opts.name) {
+            throw new Error('--expose needs --name <name>, the hostname prefix for <name>-box.run.cloud');
+        }
+        if ((exposed || opts.persistent) && opts.idlePause !== undefined && opts.idlePause !== 0) {
+            throw new Error('--persistent and --expose keep the sandbox running; drop the non-zero --idle-pause');
+        }
+        const body = {
+            image: opts.image ?? (exposed ? 'runcloud/box' : 'runcloud/agent-base'),
+        };
         if (opts.name)
             body.name = opts.name;
         if (opts.region)
             body.region = opts.region;
         if (opts.org)
             body.orgId = opts.org;
-        if (opts.cpu !== undefined)
-            body.cpu = opts.cpu;
-        if (opts.memory !== undefined)
-            body.memory = opts.memory;
+        const cpu = opts.cpu ?? (exposed ? DEFAULT_BOX_CPU_CORES : undefined);
+        const memory = opts.memory ?? (exposed ? DEFAULT_BOX_MEMORY_MIB : undefined);
+        if (cpu !== undefined)
+            body.cpu = cpu;
+        if (memory !== undefined)
+            body.memory = memory;
         if (opts.disk !== undefined)
             body.disk = opts.disk;
-        if (opts.idlePause !== undefined)
+        if (exposed || opts.persistent)
+            body.idlePauseSeconds = 0;
+        else if (opts.idlePause !== undefined)
             body.idlePauseSeconds = opts.idlePause;
-        print(await runCloudApi().post('/run-cloud/sandboxes', body), opts);
+        const api = runCloudApi();
+        const created = await api.post('/run-cloud/sandboxes', body);
+        if (!exposed) {
+            print(created, opts);
+            return;
+        }
+        if (typeof created?.id !== 'string')
+            throw new Error('sandbox create response did not include an id');
+        const box = await attachHostname(api, created.id, opts.name, opts.expose);
+        print({ ...created, box }, opts);
     }));
     withOutput(sandbox.command('list').description('List sandboxes').option('--state <state>', 'filter by state')).action((opts) => run(async () => {
         const qs = opts.state ? `?state=${encodeURIComponent(opts.state)}` : '';
-        const data = await runCloudApi().get(`/run-cloud/sandboxes${qs}`);
-        print(data?.items ?? [], opts);
+        const api = runCloudApi();
+        const [data, boxes] = await Promise.all([
+            api.get(`/run-cloud/sandboxes${qs}`),
+            api.get('/run-cloud/boxes'),
+        ]);
+        const bySandbox = new Map((boxes?.items ?? []).map((box) => [box.sandboxId, box]));
+        const items = (data?.items ?? []).map((item) => {
+            const box = bySandbox.get(item.id);
+            return box ? { ...item, hostname: box.hostname, exposedPort: box.port } : item;
+        });
+        print(items, opts);
+    }));
+    withOutput(sandbox
+        .command('get')
+        .description('Inspect a sandbox, including its public hostname when exposed')
+        .argument('<id>', 'sandbox id')).action((id, opts) => run(async () => {
+        const api = runCloudApi();
+        const [record, box] = await Promise.all([
+            api.get(`/run-cloud/sandboxes/${encodeURIComponent(id)}`),
+            findBoxForSandbox(api, id),
+        ]);
+        print(box ? { ...record, box } : record, opts);
+    }));
+    withOutput(sandbox
+        .command('expose')
+        .description('Publish a sandbox guest port at a stable hostname, or change the published port')
+        .argument('<id>', 'sandbox id')
+        .option('--port <port>', 'guest port to publish (default 3000)', parsePort)
+        .option('--name <name>', 'hostname prefix for a first exposure: <name>-box.run.cloud (defaults to the sandbox name)')
+        .option('--reconcile', 'retry or reconcile hostname routing', false)).action((id, opts) => run(async () => {
+        const api = runCloudApi();
+        const existing = await findBoxForSandbox(api, id);
+        if (!existing) {
+            if (opts.reconcile)
+                throw new Error(`sandbox ${id} has no hostname to reconcile`);
+            let name = opts.name;
+            if (!name) {
+                const record = await api.get(`/run-cloud/sandboxes/${encodeURIComponent(id)}`);
+                name = typeof record?.name === 'string' && record.name ? record.name : undefined;
+            }
+            if (!name)
+                throw new Error('this sandbox has no name; pass --name <name> to mint <name>-box.run.cloud');
+            print(await attachHostname(api, id, name, opts.port ?? 3000), opts);
+            return;
+        }
+        if (opts.name && opts.name !== existing.name) {
+            throw new Error(`hostname is fixed at ${existing.hostname}; run 'sandbox rm ${id}' and expose again to rename`);
+        }
+        if (opts.reconcile) {
+            print(await api.post(`/run-cloud/boxes/${encodeURIComponent(existing.id)}/route`), opts);
+            return;
+        }
+        if (opts.port !== undefined) {
+            print(await api.patch(`/run-cloud/boxes/${encodeURIComponent(existing.id)}`, { port: opts.port }), opts);
+            return;
+        }
+        print(existing, opts);
     }));
     withOutput(sandbox
         .command('exec')
@@ -151,6 +238,18 @@ export function registerSandbox(program) {
         }
         process.exitCode = r.exit_code ?? 0;
     }));
+    sandbox
+        .command('shell')
+        .description('Open an interactive shell in a running sandbox')
+        .argument('<id>', 'sandbox id')
+        .action((id) => run(async () => {
+        const credentials = requireCredentials();
+        process.exitCode = await runSandboxShell({
+            apiUrl: credentials.apiUrl,
+            token: credentials.token,
+            sandboxId: id,
+        });
+    }));
     withOutput(sandbox
         .command('logs')
         .description('Show recent sandbox logs (one-shot journalctl tail; streaming is a follow-up)')
@@ -236,8 +335,22 @@ export function registerSandbox(program) {
         const result = await runCloudApi().post(`/run-cloud/sandboxes/${encodeURIComponent(id)}/computer`, { action: 'key', keys });
         print(result ?? { ok: true }, opts);
     }));
-    withOutput(sandbox.command('rm').description('Destroy a sandbox').argument('<id>', 'sandbox id')).action((id, opts) => run(async () => {
-        await runCloudApi().delete(`/run-cloud/sandboxes/${encodeURIComponent(id)}`);
+    withOutput(sandbox
+        .command('rm')
+        .description('Destroy a sandbox, along with its public hostname when exposed')
+        .argument('<id>', 'sandbox id')).action((id, opts) => run(async () => {
+        const api = runCloudApi();
+        try {
+            await api.delete(`/run-cloud/sandboxes/${encodeURIComponent(id)}`);
+        }
+        catch (err) {
+            if (!(err instanceof ApiError) || err.status !== 409)
+                throw err;
+            const box = await findBoxForSandbox(api, id);
+            if (!box)
+                throw err;
+            await api.delete(`/run-cloud/boxes/${encodeURIComponent(box.id)}`);
+        }
         if (!opts.json)
             console.log(`destroyed ${id}`);
     }));
@@ -281,10 +394,13 @@ export function registerSandbox(program) {
             body.region = opts.region;
         print(await runCloudApi().post(`/run-cloud/snapshots/${encodeURIComponent(snapshotId)}/restore`, body), opts);
     }));
-    const box = program.command('box').description('Run a persistent sandbox at a stable public URL');
+    registerAccessCommands(sandbox);
+    const box = program
+        .command('box')
+        .description('Deprecated: a box is a sandbox with --persistent and --expose — use `runcloud sandbox`');
     withOutput(box
         .command('create')
-        .description('Create a persistent box or attach a hostname to an existing sandbox')
+        .description('Deprecated: use `sandbox create --expose <port> --name <name>`')
         .argument('<name>', 'hostname prefix: <name>-box.run.cloud')
         .option('--sandbox <id>', 'attach an existing sandbox created with --idle-pause 0')
         .option('--port <port>', 'guest port to publish', parsePort, 3000)
@@ -293,61 +409,77 @@ export function registerSandbox(program) {
         .option('--org <id>', 'billing and ownership organization for a new sandbox')
         .option('--cpu <cores>', 'vCPU allocation for a new box', parseCpuCores, DEFAULT_BOX_CPU_CORES)
         .option('--memory <mb>', 'memory allocation in MiB for a new box', parseMemoryMb, DEFAULT_BOX_MEMORY_MIB)
-        .option('--disk <gb>', 'root disk capacity in GiB', parseDiskGb)).action((name, opts) => run(async () => {
-        const api = runCloudApi();
-        let sandboxId = opts.sandbox;
-        if (!sandboxId) {
-            const sandboxBody = {
-                image: opts.image,
-                name,
-                idlePauseSeconds: 0,
-            };
-            if (opts.region)
-                sandboxBody.region = opts.region;
-            if (opts.org)
-                sandboxBody.orgId = opts.org;
-            sandboxBody.cpu = opts.cpu;
-            sandboxBody.memory = opts.memory;
-            if (opts.disk !== undefined)
-                sandboxBody.disk = opts.disk;
-            const created = await api.post('/run-cloud/sandboxes', sandboxBody);
-            sandboxId = typeof created?.id === 'string' ? created.id : undefined;
-            if (!sandboxId)
-                throw new Error('sandbox create response did not include an id');
-        }
-        print(await api.post('/run-cloud/boxes', {
-            sandboxId,
-            name,
-            port: opts.port,
-        }), opts);
-    }));
-    withOutput(box.command('list').description('List persistent boxes')).action((opts) => run(async () => {
-        const data = await runCloudApi().get('/run-cloud/boxes');
-        print(data?.items ?? [], opts);
-    }));
-    withOutput(box.command('get').description('Inspect a persistent box').argument('<id>', 'box id')).action((id, opts) => run(async () => {
-        print(await runCloudApi().get(`/run-cloud/boxes/${encodeURIComponent(id)}`), opts);
-    }));
+        .option('--disk <gb>', 'root disk capacity in GiB', parseDiskGb)).action((name, opts) => {
+        noteDeprecated('box create', opts.sandbox
+            ? `sandbox expose ${opts.sandbox} --name ${name}`
+            : `sandbox create --expose ${opts.port} --name ${name}`);
+        return run(async () => {
+            const api = runCloudApi();
+            let sandboxId = opts.sandbox;
+            if (!sandboxId) {
+                const sandboxBody = {
+                    image: opts.image,
+                    name,
+                    idlePauseSeconds: 0,
+                };
+                if (opts.region)
+                    sandboxBody.region = opts.region;
+                if (opts.org)
+                    sandboxBody.orgId = opts.org;
+                sandboxBody.cpu = opts.cpu;
+                sandboxBody.memory = opts.memory;
+                if (opts.disk !== undefined)
+                    sandboxBody.disk = opts.disk;
+                const created = await api.post('/run-cloud/sandboxes', sandboxBody);
+                sandboxId = typeof created?.id === 'string' ? created.id : undefined;
+                if (!sandboxId)
+                    throw new Error('sandbox create response did not include an id');
+            }
+            print(await attachHostname(api, sandboxId, name, opts.port), opts);
+        });
+    });
+    withOutput(box.command('list').description('Deprecated: use `sandbox list`')).action((opts) => {
+        noteDeprecated('box list', 'sandbox list');
+        return run(async () => {
+            const data = await runCloudApi().get('/run-cloud/boxes');
+            print(data?.items ?? [], opts);
+        });
+    });
+    withOutput(box.command('get').description('Deprecated: use `sandbox get <sandbox-id>`').argument('<id>', 'box id')).action((id, opts) => {
+        noteDeprecated('box get', 'sandbox get <sandbox-id>');
+        return run(async () => {
+            print(await runCloudApi().get(`/run-cloud/boxes/${encodeURIComponent(id)}`), opts);
+        });
+    });
     withOutput(box
         .command('port')
-        .description('Move a box hostname to another guest port')
+        .description('Deprecated: use `sandbox expose <sandbox-id> --port <port>`')
         .argument('<id>', 'box id')
-        .argument('<port>', 'guest port', parsePort)).action((id, port, opts) => run(async () => {
-        print(await runCloudApi().patch(`/run-cloud/boxes/${encodeURIComponent(id)}`, { port }), opts);
-    }));
+        .argument('<port>', 'guest port', parsePort)).action((id, port, opts) => {
+        noteDeprecated('box port', `sandbox expose <sandbox-id> --port ${port}`);
+        return run(async () => {
+            print(await runCloudApi().patch(`/run-cloud/boxes/${encodeURIComponent(id)}`, { port }), opts);
+        });
+    });
     withOutput(box
         .command('route')
-        .description('Retry or reconcile a box hostname')
-        .argument('<id>', 'box id')).action((id, opts) => run(async () => {
-        print(await runCloudApi().post(`/run-cloud/boxes/${encodeURIComponent(id)}/route`), opts);
-    }));
+        .description('Deprecated: use `sandbox expose <sandbox-id> --reconcile`')
+        .argument('<id>', 'box id')).action((id, opts) => {
+        noteDeprecated('box route', 'sandbox expose <sandbox-id> --reconcile');
+        return run(async () => {
+            print(await runCloudApi().post(`/run-cloud/boxes/${encodeURIComponent(id)}/route`), opts);
+        });
+    });
     withOutput(box
         .command('rm')
-        .description('Remove a box hostname and destroy its sandbox')
-        .argument('<id>', 'box id')).action((id, opts) => run(async () => {
-        await runCloudApi().delete(`/run-cloud/boxes/${encodeURIComponent(id)}`);
-        if (!opts.json)
-            console.log(`destroyed box ${id}`);
-    }));
-    registerBoxAccessCommands(box);
+        .description('Deprecated: use `sandbox rm <sandbox-id>`')
+        .argument('<id>', 'box id')).action((id, opts) => {
+        noteDeprecated('box rm', 'sandbox rm <sandbox-id>');
+        return run(async () => {
+            await runCloudApi().delete(`/run-cloud/boxes/${encodeURIComponent(id)}`);
+            if (!opts.json)
+                console.log(`destroyed box ${id}`);
+        });
+    });
+    registerAccessCommands(box, { deprecated: true });
 }

package/dist/config.js

@@ -1,17 +1,13 @@
 import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { basename, join } from 'node:path';
-function isRunCloud() {
-    const invoked = basename(process.argv[1] ?? '');
-    return invoked === 'runcloud' || invoked === 'run-cloud.js';
+export function isRunCloud() {
+    const names = [process.argv[1], process.execPath].map((path) => basename(path ?? ''));
+    return names.some((name) => name === 'runcloud' || name === 'run-cloud' || name === 'run-cloud.js');
 }
 function credentialsHome() {
-    if (process.env.RUN_CLOUD_HOME)
-        return process.env.RUN_CLOUD_HOME;
-    if (process.env.NEWLY_HOME)
-        return process.env.NEWLY_HOME;
     if (isRunCloud())
-        return join(homedir(), '.run-cloud');
+        return process.env.RUN_CLOUD_HOME ?? join(homedir(), '.run-cloud');
     return process.env.NEWLY_HOME ?? join(homedir(), '.newly');
 }
 function credentialsPath() {
@@ -22,7 +18,7 @@ export function credentialsDisplayPath() {
     const home = homedir();
     return path.startsWith(home) ? `~${path.slice(home.length)}` : path;
 }
-function loginCommandName() {
+export function loginCommandName() {
     return isRunCloud() ? 'runcloud login' : 'newly login';
 }
 export function normalizeApiUrl(url) {
@@ -44,7 +40,7 @@ export function loadCredentials() {
     if (envToken?.trim() && (isRunCloud() || envApiUrl?.trim())) {
         return {
             token: envToken.trim(),
-            apiUrl: normalizeApiUrl(envApiUrl?.trim() || 'https://api.newly.app'),
+            apiUrl: normalizeApiUrl(envApiUrl?.trim() || 'https://api.run.cloud'),
             appUrl: isRunCloud()
                 ? process.env.RUN_CLOUD_APP_URL ?? 'https://run.cloud'
                 : process.env.NEWLY_APP_URL ?? 'https://newly.app',

package/dist/deviceLogin.js

@@ -0,0 +1,48 @@
+import { normalizeApiUrl } from "./config.js";
+export async function runDeviceLogin(deps) {
+    const fetchFn = deps.fetchFn ?? fetch;
+    const log = deps.log ?? ((m) => console.log(m));
+    const sleep = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const now = deps.now ?? (() => Date.now());
+    const base = normalizeApiUrl(deps.apiUrl);
+    const startRes = await fetchFn(`${base}/run-cloud/cli-auth/device`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: "{}",
+    });
+    if (!startRes.ok)
+        throw new Error(`Could not start login (${startRes.status}).`);
+    const start = (await startRes.json());
+    log(`\nTo authorize this terminal, confirm the code below in your browser:\n\n    ${start.user_code}\n`);
+    log(`Opening ${start.verification_uri} … (if it doesn't open, go there and enter the code)\n`);
+    const approvalUrl = new URL(start.verification_uri_complete);
+    if (deps.provider)
+        approvalUrl.searchParams.set("provider", deps.provider);
+    deps.openBrowser?.(approvalUrl.toString());
+    let intervalMs = Math.max(0, start.interval) * 1000;
+    const deadline = now() + start.expires_in * 1000;
+    for (;;) {
+        if (now() >= deadline)
+            throw new Error("Login timed out. Run `runcloud login` again.");
+        await sleep(intervalMs);
+        const res = await fetchFn(`${base}/run-cloud/cli-auth/token`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ device_code: start.device_code }),
+        });
+        if (res.ok) {
+            const body = (await res.json());
+            return { token: body.token, apiUrl: body.apiUrl, expiresIn: body.expiresIn };
+        }
+        const { error } = (await res.json().catch(() => ({ error: "unknown" })));
+        if (error === "authorization_pending")
+            continue;
+        if (error === "slow_down") {
+            intervalMs += 5000;
+            continue;
+        }
+        if (error === "access_denied")
+            throw new Error("Authorization was denied. Run `runcloud login` again.");
+        throw new Error("The login code expired. Run `runcloud login` again.");
+    }
+}

package/dist/prompt.js

@@ -0,0 +1,150 @@
+import { openSync, closeSync } from 'node:fs';
+import { emitKeypressEvents } from 'node:readline';
+import { ReadStream } from 'node:tty';
+function defaultIO() {
+    return { input: process.stdin, output: process.stdout };
+}
+export function openControllingTerminal() {
+    let fd;
+    try {
+        fd = openSync('/dev/tty', 'r+');
+    }
+    catch {
+        return null;
+    }
+    try {
+        const input = new ReadStream(fd);
+        if (!input.isTTY)
+            throw new Error('/dev/tty is not a terminal');
+        return {
+            io: { input, output: process.stdout },
+            close: () => {
+                try {
+                    input.destroy();
+                    closeSync(fd);
+                }
+                catch {
+                }
+            },
+        };
+    }
+    catch {
+        try {
+            closeSync(fd);
+        }
+        catch {
+        }
+        return null;
+    }
+}
+export function acquirePromptIO() {
+    const stdinIO = defaultIO();
+    if (isInteractive(stdinIO))
+        return { io: stdinIO, close: () => { } };
+    return openControllingTerminal();
+}
+export function isInteractive(io = defaultIO()) {
+    return Boolean(io.input.isTTY && typeof io.input.setRawMode === 'function');
+}
+export function canPrompt() {
+    if (isInteractive())
+        return true;
+    const terminal = openControllingTerminal();
+    if (!terminal)
+        return false;
+    terminal.close();
+    return true;
+}
+export class PromptAbortedError extends Error {
+    constructor() {
+        super('Cancelled.');
+        this.name = 'PromptAbortedError';
+    }
+}
+function render(io, question, choices, selected, first) {
+    if (!first)
+        io.output.write(`\x1b[${choices.length + 1}A\x1b[J`);
+    else
+        io.output.write(`\n${question}\n\n`);
+    if (!first)
+        io.output.write('\n');
+    const width = Math.max(...choices.map((choice) => choice.label.length));
+    for (const [index, choice] of choices.entries()) {
+        const active = index === selected;
+        const marker = active ? '❯' : ' ';
+        const label = active ? `\x1b[36m${choice.label}\x1b[0m` : choice.label;
+        const padding = ' '.repeat(width - choice.label.length + 4);
+        const hint = choice.hint ? `\x1b[90m${padding}${choice.hint}\x1b[0m` : '';
+        io.output.write(`  ${marker} ${label}${hint}\n`);
+    }
+}
+export async function select(question, choices, io = defaultIO()) {
+    if (choices.length === 0)
+        throw new Error('select() needs at least one choice');
+    if (choices.length === 1)
+        return choices[0].value;
+    return new Promise((resolve, reject) => {
+        let selected = 0;
+        let first = true;
+        emitKeypressEvents(io.input);
+        io.input.setRawMode?.(true);
+        io.input.resume();
+        render(io, question, choices, selected, first);
+        first = false;
+        const finish = (action) => {
+            io.input.setRawMode?.(false);
+            io.input.pause();
+            io.input.removeListener('keypress', onKeypress);
+            io.output.write('\n');
+            action();
+        };
+        function onKeypress(chunk, key) {
+            const name = key?.name ?? '';
+            if ((key?.ctrl && name === 'c') || name === 'escape') {
+                finish(() => reject(new PromptAbortedError()));
+                return;
+            }
+            if (name === 'return' || name === 'enter') {
+                finish(() => resolve(choices[selected].value));
+                return;
+            }
+            if (name === 'up' || name === 'k') {
+                selected = (selected - 1 + choices.length) % choices.length;
+            }
+            else if (name === 'down' || name === 'j' || name === 'tab') {
+                selected = (selected + 1) % choices.length;
+            }
+            else if (/^[1-9]$/.test(chunk ?? '')) {
+                const index = Number(chunk) - 1;
+                if (index < choices.length)
+                    selected = index;
+            }
+            else {
+                return;
+            }
+            render(io, question, choices, selected, first);
+        }
+        io.input.on('keypress', onKeypress);
+    });
+}
+export async function ask(question, options = {}) {
+    const { validate, attempts = 3, io = defaultIO() } = options;
+    const { createInterface } = await import('node:readline/promises');
+    const rl = createInterface({ input: io.input, output: io.output });
+    try {
+        for (let attempt = 1; attempt <= attempts; attempt += 1) {
+            const answer = (await rl.question(question)).trim();
+            const problem = validate?.(answer) ?? null;
+            if (!problem)
+                return answer;
+            io.output.write(`  ${problem}\n`);
+            if (attempt === attempts) {
+                throw new Error(`${problem} Giving up after ${attempts} attempts.`);
+            }
+        }
+        throw new Error('unreachable');
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/run-cloud.js

@@ -1,13 +1,12 @@
 #!/usr/bin/env node
-import { readFileSync } from 'node:fs';
 import { Command } from 'commander';
 import { registerLogin } from './commands/login.js';
 import { registerRunCloud } from './commands/run-cloud.js';
 import { registerSandbox } from './commands/sandbox.js';
-const { version } = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+import { CLI_VERSION } from './version.js';
 const program = new Command('runcloud')
     .description('Create and control remote mobile simulators and microVM sandboxes')
-    .version(version);
+    .version(CLI_VERSION);
 registerLogin(program);
 registerRunCloud(program);
 registerSandbox(program);