@newly/cli 0.1.2 → 0.1.27

package/dist/commands/sandboxOutput.js

@@ -0,0 +1,70 @@
+import { formatAge, formatCpu, formatMib, formatSeconds, formatState, renderDetails, renderTable, shortDigest, style, } from '../terminal.js';
+function resources(record) {
+    const memory = formatMib(record.mem_mb);
+    const disk = formatMib(record.disk_mb);
+    return [
+        formatCpu(record.milli_cpu),
+        memory ? `${memory} memory` : undefined,
+        disk ? `${disk} disk` : undefined,
+    ]
+        .filter(Boolean)
+        .join(' · ') || undefined;
+}
+function hostname(record) {
+    const host = record.hostname ?? record.box?.hostname;
+    const port = record.exposedPort ?? record.box?.port;
+    return host && port ? `${host}:${port}` : host;
+}
+function title(record, verb) {
+    if (verb === 'details')
+        return 'Sandbox';
+    if (record.state === 'running')
+        return `✓ Sandbox ${verb === 'restored' ? 'restored' : 'ready'}`;
+    if (record.state === 'building_image')
+        return '◐ Sandbox is building its image';
+    if (record.state === 'paused' || record.state === 'archived')
+        return '○ Sandbox paused';
+    return verb === 'restored' ? 'Sandbox restored' : 'Sandbox created';
+}
+export function renderSandbox(record, verb = 'details') {
+    const next = verb === 'details'
+        ? undefined
+        : record.state === 'running'
+            ? `${style.dim('Next:')}  runcloud sandbox shell ${record.id}`
+            : `${style.dim('Follow:')}  runcloud sandbox get ${record.id}`;
+    return renderDetails(title(record, verb), [
+        { label: 'ID', value: record.id },
+        { label: 'Name', value: record.name },
+        { label: 'State', value: formatState(record.state) },
+        { label: 'Image', value: record.image },
+        { label: 'Resources', value: resources(record) },
+        { label: 'Idle pause', value: formatSeconds(record.idle_pause_seconds) },
+        { label: 'Timeout', value: formatSeconds(record.timeout_seconds) },
+        { label: 'Hostname', value: hostname(record) },
+        { label: 'Image digest', value: shortDigest(record.image_digest) },
+        { label: 'Created', value: formatAge(record.created_at) },
+        { label: 'Last active', value: verb === 'details' ? formatAge(record.last_active_at) : undefined },
+    ], next);
+}
+export function renderSandboxList(records) {
+    if (records.length === 0) {
+        return `${style.bold('Sandboxes')}\n\nNo sandboxes found.\n\n${style.dim('Create one:')}  runcloud sandbox create`;
+    }
+    return renderTable(`Sandboxes (${records.length})`, [
+        { key: 'id', label: 'ID', maxWidth: 24 },
+        { key: 'name', label: 'NAME / HOSTNAME', maxWidth: 20 },
+        { key: 'state', label: 'STATE', maxWidth: 14 },
+        { key: 'image', label: 'IMAGE', maxWidth: 20 },
+        { key: 'resources', label: 'CPU / MEMORY', maxWidth: 18 },
+        { key: 'age', label: 'AGE' },
+    ], records.map((record) => ({
+        id: record.id,
+        name: hostname(record) ?? record.name ?? '—',
+        state: formatState(record.state),
+        image: record.image ?? '—',
+        resources: [formatCpu(record.milli_cpu)?.replace(' CPU', ''), formatMib(record.mem_mb)]
+            .filter(Boolean)
+            .join(' / ') || '—',
+        age: formatAge(record.created_at) ?? '—',
+    })));
+}

package/dist/commands/secrets.js

@@ -0,0 +1,203 @@
+import { readFileSync } from 'node:fs';
+import { ApiClient, friendlyApiError } from '../api.js';
+import { requireCredentials } from '../config.js';
+import { promptHidden } from '../prompt.js';
+function api() {
+    const credentials = requireCredentials();
+    return new ApiClient(credentials.apiUrl, credentials.token);
+}
+async function run(fn) {
+    try {
+        await fn();
+    }
+    catch (err) {
+        console.error(friendlyApiError(err));
+        process.exitCode = 1;
+    }
+}
+function orgQuery(org, extra = {}) {
+    const params = new URLSearchParams(extra);
+    if (org)
+        params.set('orgId', org);
+    const qs = params.toString();
+    return qs ? `?${qs}` : '';
+}
+export function parseDotenv(text) {
+    const entries = {};
+    for (const raw of text.split('\n')) {
+        const line = raw.trim();
+        if (!line || line.startsWith('#'))
+            continue;
+        const withoutExport = line.startsWith('export ') ? line.slice('export '.length).trim() : line;
+        const eq = withoutExport.indexOf('=');
+        if (eq <= 0)
+            continue;
+        const name = withoutExport.slice(0, eq).trim();
+        let value = withoutExport.slice(eq + 1).trim();
+        if ((value.startsWith('"') && value.endsWith('"') && value.length >= 2) ||
+            (value.startsWith("'") && value.endsWith("'") && value.length >= 2)) {
+            value = value.slice(1, -1);
+        }
+        entries[name] = value;
+    }
+    return entries;
+}
+export function parseJsonEntries(text) {
+    const parsed = JSON.parse(text);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('--from-json needs a JSON object of name → value');
+    }
+    const entries = {};
+    for (const [name, value] of Object.entries(parsed)) {
+        if (typeof value !== 'string') {
+            throw new Error(`--from-json: "${name}" is not a string; secrets are strings`);
+        }
+        entries[name] = value;
+    }
+    return entries;
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(Buffer.from(chunk));
+    return Buffer.concat(chunks).toString('utf8');
+}
+export function registerSecrets(program) {
+    const groups = program
+        .command('secret-group')
+        .description('Create and manage secret groups a sandbox can attach');
+    groups
+        .command('create')
+        .description('Create a group together with its contents')
+        .argument('<group>', 'group name, e.g. aws')
+        .argument('[unsupported...]', 'not accepted: a value cannot be passed as an argument')
+        .option('--from-dotenv <path>', 'read KEY=VALUE lines from a .env file')
+        .option('--from-json <path>', 'read a JSON object of name → value')
+        .option('--key <name>', 'prompt for this value (hidden); repeatable', collect, [])
+        .option('--force', 'replace the group if it already exists', false)
+        .option('--org <id>', 'organization to store it in')
+        .action((group, unsupported, opts) => run(async () => {
+        if (unsupported.length > 0) {
+            throw new Error(`values cannot be passed as arguments (got "${unsupported[0]?.split('=')[0]}=…"). ` +
+                'An argument lands in your shell history, in `ps` output, and in CI logs. ' +
+                'Use --from-dotenv <path>, --from-json <path>, or --key <name> for a hidden prompt.');
+        }
+        const entries = {};
+        if (opts.fromDotenv)
+            Object.assign(entries, parseDotenv(readFileSync(opts.fromDotenv, 'utf8')));
+        if (opts.fromJson)
+            Object.assign(entries, parseJsonEntries(readFileSync(opts.fromJson, 'utf8')));
+        for (const name of opts.key) {
+            entries[name] = await promptHidden(`${name}: `);
+        }
+        if (Object.keys(entries).length === 0) {
+            throw new Error('nothing to store: pass --from-dotenv <path>, --from-json <path>, or --key <name>. ' +
+                'A value cannot be given as an argument — it would land in your shell history.');
+        }
+        const body = { entries };
+        if (opts.force)
+            body.force = true;
+        await api().put(`/run-cloud/secret-groups/${encodeURIComponent(group)}${orgQuery(opts.org)}`, body);
+        console.log(`secret group ${group}: ${Object.keys(entries).length} secret(s) stored`);
+    }));
+    groups
+        .command('list')
+        .description('List secret groups')
+        .option('--json', 'output JSON', false)
+        .option('--org <id>', 'organization to read from')
+        .action((opts) => run(async () => {
+        const data = await api().get(`/run-cloud/secret-groups${orgQuery(opts.org)}`);
+        const rows = (data?.groups ?? []);
+        if (opts.json) {
+            console.log(JSON.stringify(rows, null, 2));
+            return;
+        }
+        if (rows.length === 0) {
+            console.log('no secret groups yet — runcloud secret-group create <name> --from-dotenv <path>');
+            return;
+        }
+        for (const row of rows)
+            console.log(`${row.group}\t${row.secretCount} secret(s)\t${row.updatedAt}`);
+    }));
+    groups
+        .command('show')
+        .description('List the names in a group (never values)')
+        .argument('<group>', 'group name')
+        .option('--json', 'output JSON', false)
+        .option('--org <id>', 'organization to read from')
+        .action((group, opts) => run(async () => {
+        const data = await api().get(`/run-cloud/secrets${orgQuery(opts.org)}`);
+        const rows = (data?.secrets ?? []).filter((row) => row.group === group);
+        if (opts.json) {
+            console.log(JSON.stringify(rows, null, 2));
+            return;
+        }
+        if (rows.length === 0) {
+            console.log(`no secret group ${group}`);
+            return;
+        }
+        for (const row of rows) {
+            console.log(row.kind === 'file' ? `${row.name}\tfile → ${row.filePath}` : `${row.name}\tenv`);
+        }
+    }));
+    groups
+        .command('rm')
+        .description('Delete a group and every secret in it')
+        .argument('<group>', 'group name')
+        .option('--org <id>', 'organization to delete from')
+        .action((group, opts) => run(async () => {
+        await api().delete(`/run-cloud/secret-groups/${encodeURIComponent(group)}${orgQuery(opts.org)}`);
+        console.log(`secret group ${group} deleted`);
+    }));
+    const secrets = program
+        .command('secrets')
+        .description('Set and remove individual secrets inside a group');
+    secrets
+        .command('set')
+        .description('Store one environment-variable secret, reading the value from stdin')
+        .argument('<name>', 'secret name, e.g. AWS_SESSION_TOKEN')
+        .requiredOption('--group <group>', 'group to store it in')
+        .option('--stdin', 'read the value from stdin', false)
+        .option('--org <id>', 'organization to store it in')
+        .action((name, opts) => run(async () => {
+        const value = opts.stdin ? (await readStdin()).replace(/\n$/, '') : await promptHidden(`${name}: `);
+        if (!value)
+            throw new Error(`no value read for ${name}`);
+        await api().put(`/run-cloud/secrets/${encodeURIComponent(name)}${orgQuery(opts.org)}`, {
+            group: opts.group,
+            value,
+            kind: 'env',
+        });
+        console.log(`${opts.group}/${name} stored`);
+    }));
+    secrets
+        .command('set-file')
+        .description('Store a file secret, written into the sandbox at --path')
+        .argument('<name>', 'secret name, e.g. sa.json')
+        .requiredOption('--group <group>', 'group to store it in')
+        .requiredOption('--path <path>', 'path inside the sandbox, relative to its home')
+        .requiredOption('--from-file <path>', 'local file to read the contents from')
+        .option('--org <id>', 'organization to store it in')
+        .action((name, opts) => run(async () => {
+        await api().put(`/run-cloud/secrets/${encodeURIComponent(name)}${orgQuery(opts.org)}`, {
+            group: opts.group,
+            value: readFileSync(opts.fromFile, 'utf8'),
+            kind: 'file',
+            filePath: opts.path,
+        });
+        console.log(`${opts.group}/${name} stored → ${opts.path}`);
+    }));
+    secrets
+        .command('rm')
+        .description('Remove one secret from a group')
+        .argument('<name>', 'secret name')
+        .requiredOption('--group <group>', 'group it lives in')
+        .option('--org <id>', 'organization to delete from')
+        .action((name, opts) => run(async () => {
+        await api().delete(`/run-cloud/secrets/${encodeURIComponent(name)}${orgQuery(opts.org, { group: opts.group })}`);
+        console.log(`${opts.group}/${name} deleted`);
+    }));
+}
+function collect(value, previous) {
+    return [...previous, value];
+}

package/dist/config.js

@@ -1,14 +1,13 @@
 import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { basename, join } from 'node:path';
+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;
-    const invoked = basename(process.argv[1] ?? '');
-    if (invoked === 'runcloud' || invoked === 'run-cloud.js')
-        return join(homedir(), '.run-cloud');
+    if (isRunCloud())
+        return process.env.RUN_CLOUD_HOME ?? join(homedir(), '.run-cloud');
     return process.env.NEWLY_HOME ?? join(homedir(), '.newly');
 }
 function credentialsPath() {
@@ -19,13 +18,11 @@ export function credentialsDisplayPath() {
     const home = homedir();
     return path.startsWith(home) ? `~${path.slice(home.length)}` : path;
 }
-function loginCommandName() {
-    const invoked = basename(process.argv[1] ?? '');
-    return invoked === 'runcloud' || invoked === 'run-cloud.js' ? 'runcloud login' : 'newly login';
+export function loginCommandName() {
+    return isRunCloud() ? 'runcloud login' : 'newly login';
 }
 export function normalizeApiUrl(url) {
-    const trimmed = url.replace(/\/+$/, '');
-    return trimmed.endsWith('/api') ? trimmed : `${trimmed}/api`;
+    return url.replace(/\/+$/, '');
 }
 export function saveCredentials(creds) {
     mkdirSync(credentialsHome(), { recursive: true, mode: 0o700 });
@@ -34,13 +31,21 @@ export function saveCredentials(creds) {
     chmodSync(credentialsPath(), 0o600);
 }
 export function loadCredentials() {
-    const envToken = process.env.NEWLY_API_TOKEN ?? process.env.NEWLY_CLI_TOKEN;
-    const envApiUrl = process.env.NEWLY_API_URL ?? process.env.NEWLY_API_HOST ?? process.env.NEXT_PUBLIC_API_HOST;
-    if (envToken?.trim() && envApiUrl?.trim()) {
+    const envToken = isRunCloud()
+        ? process.env.RUN_CLOUD_API_TOKEN ??
+            process.env.RUN_CLOUD_API_KEY ??
+            process.env.RUN_CLOUD_CI_ENVIRONMENT_TOKEN
+        : process.env.NEWLY_API_TOKEN ?? process.env.NEWLY_CLI_TOKEN;
+    const envApiUrl = isRunCloud()
+        ? process.env.RUN_CLOUD_API_URL
+        : process.env.NEWLY_API_URL;
+    if (envToken?.trim() && (isRunCloud() || envApiUrl?.trim())) {
         return {
             token: envToken.trim(),
-            apiUrl: normalizeApiUrl(envApiUrl.trim()),
-            appUrl: process.env.NEWLY_APP_URL ?? 'https://newly.dev',
+            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',
             expiresAt: Number.MAX_SAFE_INTEGER,
         };
     }
@@ -56,6 +61,40 @@ export function loadCredentials() {
         return null;
     }
 }
+function environmentSelectionPath(dir) {
+    return join(dir, '.newly', 'environment.json');
+}
+export function writeEnvironmentSelection(dir, selection) {
+    const selectionDir = join(dir, '.newly');
+    mkdirSync(selectionDir, { recursive: true });
+    const gitignorePath = join(selectionDir, '.gitignore');
+    if (!existsSync(gitignorePath))
+        writeFileSync(gitignorePath, '*\n');
+    writeFileSync(environmentSelectionPath(dir), JSON.stringify(selection, null, 2) + '\n');
+}
+export function readEnvironmentSelection(dir) {
+    try {
+        const parsed = JSON.parse(readFileSync(environmentSelectionPath(dir), 'utf8'));
+        if (!parsed.id || !parsed.name || !parsed.projectId)
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export function clearEnvironmentSelection(dir) {
+    rmSync(environmentSelectionPath(dir), { force: true });
+}
+export function requireEnvironmentSelection(dir, projectId) {
+    const selection = readEnvironmentSelection(dir);
+    if (!selection)
+        throw new Error('No environment selected. Run `newly env use <name>` first.');
+    if (selection.projectId !== projectId) {
+        throw new Error('The selected environment belongs to a different linked project. Run `newly env clear`.');
+    }
+    return selection;
+}
 export function clearCredentials() {
     rmSync(credentialsPath(), { force: true });
 }

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/index.js

@@ -16,6 +16,9 @@ import { registerWebsite } from './commands/website.js';
 import { registerDomains } from './commands/domains.js';
 import { registerDns } from './commands/dns.js';
 import { registerDiagnose } from './diagnose.js';
+import { registerDesktop } from './commands/desktop.js';
+import { registerEnvironment } from './commands/environment.js';
+import { registerAppStore } from './commands/appStore.js';
 const program = new Command('newly')
     .description('Develop, provision, and deploy Newly backends')
     .version('0.1.0');
@@ -35,4 +38,7 @@ registerWebsite(program);
 registerDomains(program);
 registerDns(program);
 registerDiagnose(program);
+registerDesktop(program);
+registerEnvironment(program);
+registerAppStore(program);
 await program.parseAsync(process.argv);

package/dist/prompt.js

@@ -0,0 +1,196 @@
+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');
+        input.on('error', () => {
+        });
+        return {
+            io: { input, output: process.stdout },
+            close: () => {
+                try {
+                    input.setRawMode?.(false);
+                    input.destroy();
+                }
+                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();
+    }
+}
+export async function promptHidden(label) {
+    const acquired = acquirePromptIO();
+    if (!acquired) {
+        const chunks = [];
+        for await (const chunk of process.stdin)
+            chunks.push(Buffer.from(chunk));
+        return chunks.join('').replace(/\n$/, '');
+    }
+    const { io, close } = acquired;
+    const input = io.input;
+    const output = io.output;
+    output.write(label);
+    input.setRawMode?.(true);
+    emitKeypressEvents(input);
+    input.resume();
+    return await new Promise((resolve, reject) => {
+        let value = '';
+        const finish = (fn) => {
+            input.setRawMode?.(false);
+            input.pause();
+            input.removeListener('keypress', onKeypress);
+            output.write('\n');
+            close();
+            fn();
+        };
+        function onKeypress(_str, key) {
+            if (key.ctrl && key.name === 'c') {
+                finish(() => reject(new Error('cancelled')));
+                return;
+            }
+            if (key.name === 'return' || key.name === 'enter') {
+                finish(() => resolve(value));
+                return;
+            }
+            if (key.name === 'backspace') {
+                value = value.slice(0, -1);
+                return;
+            }
+            if (key.sequence && !key.ctrl && !key.meta)
+                value += key.sequence;
+        }
+        input.on('keypress', onKeypress);
+    });
+}

package/dist/run-cloud.js

@@ -1,10 +1,17 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
+import { registerImage } from './commands/image.js';
 import { registerLogin } from './commands/login.js';
 import { registerRunCloud } from './commands/run-cloud.js';
+import { registerSandbox } from './commands/sandbox.js';
+import { registerSecrets } from './commands/secrets.js';
+import { CLI_VERSION } from './version.js';
 const program = new Command('runcloud')
-    .description('Create and control remote iOS simulator sessions')
-    .version('0.1.0');
+    .description('Create and control remote mobile simulators and microVM sandboxes')
+    .version(CLI_VERSION);
 registerLogin(program);
 registerRunCloud(program);
+registerSandbox(program);
+registerSecrets(program);
+registerImage(program);
 await program.parseAsync(process.argv);