runcloud 0.1.6 → 0.1.9

package/dist/commands/sandbox.js

@@ -1,5 +1,14 @@
+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 { requireCredentials } from '../config.js';
+import { runSandboxShell } from '../shellSession.js';
+import { registerBoxAccessCommands } from './boxAccess.js';
+const MAX_SANDBOX_DISK_GIB = 2048;
+const DEFAULT_BOX_CPU_CORES = 2;
+const DEFAULT_BOX_MEMORY_MIB = 24 * 1024;
 function runCloudApi() {
     const credentials = requireCredentials();
     return new ApiClient(credentials.apiUrl, credentials.token);
@@ -36,23 +45,87 @@ async function run(fn) {
 function withOutput(cmd) {
     return cmd.option('--json', 'output JSON', false);
 }
+function parseCpuCores(value) {
+    const n = Number(value);
+    if (!Number.isFinite(n) || n <= 0) {
+        throw new InvalidArgumentError('--cpu must be a positive number of cores, e.g. 0.5');
+    }
+    return n;
+}
+function parseMemoryMb(value) {
+    const n = Number(value);
+    if (!Number.isInteger(n) || n <= 0) {
+        throw new InvalidArgumentError('--memory must be a positive integer of MiB, e.g. 1024');
+    }
+    return n;
+}
+function parseDiskGb(value) {
+    const n = Number(value);
+    if (!Number.isSafeInteger(n) || n <= 0 || n > MAX_SANDBOX_DISK_GIB) {
+        throw new InvalidArgumentError(`--disk must be an integer from 1 to ${MAX_SANDBOX_DISK_GIB} GiB`);
+    }
+    return n;
+}
+function parseIdlePauseSeconds(value) {
+    const n = Number(value);
+    if (!Number.isInteger(n) || n < 0) {
+        throw new InvalidArgumentError('--idle-pause must be a non-negative integer of seconds');
+    }
+    return n;
+}
+function parsePort(value) {
+    const n = Number(value);
+    if (!Number.isInteger(n) || n < 1 || n > 65535) {
+        throw new InvalidArgumentError('--port must be an integer from 1 to 65535');
+    }
+    return n;
+}
+function parseCoordinate(value) {
+    const n = Number(value);
+    if (!Number.isSafeInteger(n) || n < 0) {
+        throw new InvalidArgumentError('coordinates must be non-negative integers');
+    }
+    return n;
+}
+export function openBrowserUrl(url, platform = process.platform) {
+    if (platform === 'darwin') {
+        execFileSync('open', [url], { stdio: 'ignore' });
+        return;
+    }
+    if (platform === 'win32') {
+        execFileSync('cmd', ['/c', 'start', '', url], { stdio: 'ignore' });
+        return;
+    }
+    execFileSync('xdg-open', [url], { stdio: 'ignore' });
+}
 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', 'newly/agent-base')
-        .option('--size <class>', 'size preset', 's-2')
+        .option('--image <ref>', 'base image', 'runcloud/agent-base')
         .option('--region <region>', 'placement region')
         .option('--name <name>', 'human-readable name')
-        .option('--org <id>', 'billing and ownership organization')).action((opts) => run(async () => {
-        const body = { size: opts.size, image: opts.image };
+        .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 };
         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;
+        if (opts.disk !== undefined)
+            body.disk = opts.disk;
+        if (opts.idlePause !== undefined)
+            body.idlePauseSeconds = opts.idlePause;
         print(await runCloudApi().post('/run-cloud/sandboxes', body), opts);
     }));
     withOutput(sandbox.command('list').description('List sandboxes').option('--state <state>', 'filter by state')).action((opts) => run(async () => {
@@ -79,6 +152,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)')
@@ -99,9 +184,183 @@ export function registerSandbox(program) {
         process.stdout.write(r.stdout ?? '');
         process.stderr.write(r.stderr ?? '');
     }));
+    withOutput(sandbox
+        .command('desktop')
+        .description('Open a signed browser desktop for a runcloud/desktop sandbox')
+        .argument('<id>', 'sandbox id')
+        .option('--url', 'print the signed noVNC URL instead of opening it', false)
+        .option('--view-only', 'disable keyboard and pointer input', false)).action((id, opts) => run(async () => {
+        const desktop = await runCloudApi().post(`/run-cloud/sandboxes/${encodeURIComponent(id)}/desktop`, { viewOnly: opts.viewOnly });
+        if (typeof desktop?.url !== 'string' || !desktop.url.startsWith('https://')) {
+            throw new Error('sandbox desktop response did not include a secure URL');
+        }
+        if (opts.url) {
+            console.log(desktop.url);
+            return;
+        }
+        if (opts.json) {
+            print(desktop, opts);
+            return;
+        }
+        openBrowserUrl(desktop.url);
+        console.log(`Opened ${opts.viewOnly ? 'view-only ' : ''}desktop for ${id}`);
+    }));
+    withOutput(sandbox
+        .command('screenshot')
+        .description('Capture the sandbox desktop as a PNG')
+        .argument('<id>', 'sandbox id')
+        .option('--output <path>', 'PNG output path', 'screen.png')).action((id, opts) => run(async () => {
+        const result = await runCloudApi().post(`/run-cloud/sandboxes/${encodeURIComponent(id)}/computer`, { action: 'screenshot' });
+        if (typeof result?.image !== 'string' || !result.image) {
+            throw new Error('sandbox screenshot response did not include a PNG image');
+        }
+        const image = Buffer.from(result.image, 'base64');
+        const pngSignature = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+        if (image.length < pngSignature.length ||
+            !image.subarray(0, pngSignature.length).equals(pngSignature)) {
+            throw new Error('sandbox screenshot response was not a valid PNG');
+        }
+        const output = resolve(opts.output);
+        writeFileSync(output, image, { mode: 0o600 });
+        print({ sandboxId: id, output, bytes: image.length }, opts);
+    }));
+    withOutput(sandbox
+        .command('click')
+        .description('Click a desktop pixel coordinate')
+        .argument('<id>', 'sandbox id')
+        .argument('<x>', 'horizontal pixel coordinate', parseCoordinate)
+        .argument('<y>', 'vertical pixel coordinate', parseCoordinate)).action((id, x, y, opts) => run(async () => {
+        const result = await runCloudApi().post(`/run-cloud/sandboxes/${encodeURIComponent(id)}/computer`, { action: 'click', x, y });
+        print(result ?? { ok: true }, opts);
+    }));
+    withOutput(sandbox
+        .command('type')
+        .description('Type text into the sandbox desktop')
+        .argument('<id>', 'sandbox id')
+        .argument('<text>', 'text to type')).action((id, text, opts) => run(async () => {
+        const result = await runCloudApi().post(`/run-cloud/sandboxes/${encodeURIComponent(id)}/computer`, { action: 'type', text });
+        print(result ?? { ok: true }, opts);
+    }));
+    withOutput(sandbox
+        .command('key')
+        .description('Send an xdotool key chord to the sandbox desktop')
+        .argument('<id>', 'sandbox id')
+        .argument('<keys>', 'key or chord, e.g. ctrl+l')).action((id, keys, opts) => run(async () => {
+        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)}`);
         if (!opts.json)
             console.log(`destroyed ${id}`);
     }));
+    const snapshot = sandbox.command('snapshot').description('Capture and manage sandbox snapshots');
+    withOutput(snapshot
+        .command('create')
+        .description('Snapshot a sandbox for later restore')
+        .argument('<id>', 'sandbox id to snapshot')
+        .option('--label <label>', 'human-readable label')).action((id, opts) => run(async () => {
+        const body = {};
+        if (opts.label)
+            body.label = opts.label;
+        print(await runCloudApi().post(`/run-cloud/sandboxes/${encodeURIComponent(id)}/snapshots`, body), opts);
+    }));
+    withOutput(snapshot
+        .command('list')
+        .description('List snapshots')
+        .option('--sandbox <id>', 'only snapshots taken from this sandbox')).action((opts) => run(async () => {
+        const qs = opts.sandbox ? `?sandbox_id=${encodeURIComponent(opts.sandbox)}` : '';
+        const data = await runCloudApi().get(`/run-cloud/snapshots${qs}`);
+        print(data?.items ?? [], opts);
+    }));
+    withOutput(snapshot.command('rm').description('Delete a snapshot').argument('<id>', 'snapshot id')).action((id, opts) => run(async () => {
+        await runCloudApi().delete(`/run-cloud/snapshots/${encodeURIComponent(id)}`);
+        if (!opts.json)
+            console.log(`deleted ${id}`);
+    }));
+    withOutput(sandbox
+        .command('restore')
+        .description('Fork a new sandbox from a snapshot (warm start)')
+        .argument('<snapshot-id>', 'snapshot id to restore from')
+        .option('--name <name>', 'human-readable name for the new sandbox')
+        .option('--disk <gb>', 'root disk capacity in GiB (may only grow)', parseDiskGb)
+        .option('--region <region>', 'placement region')).action((snapshotId, opts) => run(async () => {
+        const body = {};
+        if (opts.name)
+            body.name = opts.name;
+        if (opts.disk !== undefined)
+            body.disk = opts.disk;
+        if (opts.region)
+            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');
+    withOutput(box
+        .command('create')
+        .description('Create a persistent box or attach a hostname to an existing sandbox')
+        .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)
+        .option('--image <ref>', 'base image for a new sandbox (runcloud/box or runcloud/box-agent)', 'runcloud/box')
+        .option('--region <region>', 'placement region for a new sandbox')
+        .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);
+    }));
+    withOutput(box
+        .command('port')
+        .description('Move a box hostname to another guest 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);
+    }));
+    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);
+    }));
+    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);
 }

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',
@@ -105,10 +101,6 @@ export function requireCredentials() {
     if (!creds) {
         throw new Error(`Not logged in (or session expired). Run: ${loginCommandName()}`);
     }
-    if (isRunCloud() && !creds.token.startsWith('rc_live_')) {
-        throw new Error('Legacy run.cloud credentials are no longer supported. Run `runcloud login` to sign in ' +
-            'with Better Auth.');
-    }
     return creds;
 }
 export function writeProjectLink(dir, link) {

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);

package/dist/runCloudAuth.js

@@ -0,0 +1,79 @@
+const SESSION_TOKEN_HEADER = 'set-auth-token';
+export class AuthError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = 'AuthError';
+    }
+}
+function apiBase(apiUrl) {
+    return apiUrl.replace(/\/+$/, '');
+}
+async function readError(response) {
+    const body = await response.text();
+    try {
+        const parsed = JSON.parse(body);
+        return parsed.error ?? parsed.message ?? body.slice(0, 200);
+    }
+    catch {
+        return body.slice(0, 200) || response.statusText;
+    }
+}
+async function post(apiUrl, path, body, token) {
+    const response = await fetch(`${apiBase(apiUrl)}${path}`, {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/json',
+            ...(token ? { authorization: `Bearer ${token}` } : {}),
+        },
+        body: JSON.stringify(body),
+    });
+    if (!response.ok)
+        throw new AuthError(await readError(response), response.status);
+    const sessionToken = response.headers.get(SESSION_TOKEN_HEADER);
+    const text = await response.text();
+    const data = (text ? JSON.parse(text) : {});
+    return { data, sessionToken: sessionToken?.trim() || null };
+}
+export async function fetchProviders(apiUrl) {
+    const response = await fetch(`${apiBase(apiUrl)}/auth/web/providers`);
+    if (!response.ok)
+        throw new AuthError(await readError(response), response.status);
+    const payload = (await response.json());
+    return {
+        emailOtp: payload.emailOtp === true,
+        google: payload.google === true,
+        github: payload.github === true,
+        apple: payload.apple === true,
+    };
+}
+export async function sendEmailCode(apiUrl, email) {
+    await post(apiUrl, '/api/auth/email-otp/send-verification-otp', { email, type: 'sign-in' });
+}
+export async function verifyEmailCode(apiUrl, email, otp) {
+    const { data, sessionToken } = await post(apiUrl, '/api/auth/sign-in/email-otp', { email, otp, name: email.split('@')[0] || 'Run Cloud user' });
+    if (!sessionToken) {
+        throw new AuthError(`${apiUrl} accepted the code but did not return a session token.`, 502);
+    }
+    return {
+        user: { id: data.user?.id ?? '', email: data.user?.email ?? email },
+        sessionToken,
+    };
+}
+export async function createApiKey(apiUrl, sessionToken, name) {
+    const { data } = await post(apiUrl, '/run-cloud/api-keys', { name }, sessionToken);
+    const key = data.apiKey?.key;
+    if (!key)
+        throw new AuthError(`${apiUrl} did not return an API key.`, 502);
+    return key;
+}
+export function isValidEmail(value) {
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value.trim());
+}
+export function normalizeOtp(value) {
+    return value.replace(/[\s-]/g, '');
+}
+export function isValidOtp(value) {
+    return /^\d{6}$/.test(normalizeOtp(value));
+}

package/dist/{environmentShell.js → shellSession.js}

@@ -1,9 +1,9 @@
 import WebSocket from 'ws';
-export async function runEnvironmentDatabaseShell(input) {
+export async function runShellSession(input) {
     const stdin = input.stdin ?? process.stdin;
     const stdout = input.stdout ?? process.stdout;
     const stderr = input.stderr ?? process.stderr;
-    const url = new URL(`/environment-databases/${encodeURIComponent(input.databaseId)}/shell`, input.apiUrl);
+    const url = new URL(input.path, input.apiUrl);
     url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
     const createWebSocket = input.createWebSocket ?? ((address, options) => new WebSocket(address, options));
     const socket = createWebSocket(url.toString(), {
@@ -60,7 +60,7 @@ export async function runEnvironmentDatabaseShell(input) {
         socket.once('close', (code, reason) => {
             restore();
             if (code >= 4400) {
-                reject(new Error(reason.toString() || `Database shell rejected (${code})`));
+                reject(new Error(reason.toString() || `${input.label} rejected (${code})`));
             }
             else {
                 resolve(exitCode);
@@ -68,3 +68,17 @@ export async function runEnvironmentDatabaseShell(input) {
         });
     });
 }
+export function runEnvironmentDatabaseShell(input) {
+    return runShellSession({
+        ...input,
+        path: `/environment-databases/${encodeURIComponent(input.databaseId)}/shell`,
+        label: 'Database shell',
+    });
+}
+export function runSandboxShell(input) {
+    return runShellSession({
+        ...input,
+        path: `/run-cloud/sandboxes/${encodeURIComponent(input.sandboxId)}/exec/stream`,
+        label: 'Sandbox shell',
+    });
+}

package/dist/version.js

@@ -0,0 +1 @@
+export const CLI_VERSION = '0.1.9';

package/examples/eight-device-mosaic/README.md

@@ -12,7 +12,7 @@ interrupted local process.
 - `runcloud` 0.1.3 or newer: `npm install -g runcloud`
 - A simulator account authenticated either with `runcloud login` or with both
   `RUN_CLOUD_API_KEY` and `RUN_CLOUD_API_URL`
-- run.cloud simulator access, capacity, and enough balance for eight sessions
+- run.cloud simulator access, capacity, and enough organization credit for eight sessions
 
 The local viewer binds only to `127.0.0.1`. Signed simulator URLs remain in the
 viewer process and are not printed to the terminal.

package/examples/eight-device-mosaic/demo.mjs

@@ -73,7 +73,7 @@ function escapeHtml(value) {
 
 function embedUrl(value) {
   const url = new URL(value);
-  url.searchParams.set('loadingGuard', '1');
+  url.searchParams.set('embed', '1');
   return url.toString();
 }