@newly/cli 0.1.1 → 0.1.27

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

@@ -0,0 +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 mobile simulators and microVM sandboxes')
+    .version(CLI_VERSION);
+registerLogin(program);
+registerRunCloud(program);
+registerSandbox(program);
+registerSecrets(program);
+registerImage(program);
+await program.parseAsync(process.argv);

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

@@ -0,0 +1,91 @@
+import WebSocket from 'ws';
+export function streamExitCode(frame) {
+    const code = frame.code ?? frame.exit_code ?? 0;
+    return Number.isSafeInteger(code) ? code : undefined;
+}
+export function shellCommand(argv) {
+    if (argv.length === 1)
+        return argv[0] ?? '';
+    return argv
+        .map((part) => `'${part.replaceAll("'", "'\"'\"'")}'`)
+        .join(' ');
+}
+export function runSandboxCommand(input) {
+    const url = new URL(`/run-cloud/sandboxes/${encodeURIComponent(input.sandboxId)}/exec/stream?mode=command`, input.apiUrl);
+    url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
+    const socket = input.createSocket?.(url.toString(), {
+        headers: { Authorization: `Bearer ${input.token}` },
+    }) ??
+        new WebSocket(url, {
+            headers: { Authorization: `Bearer ${input.token}` },
+        });
+    return new Promise((resolve, reject) => {
+        const stdout = [];
+        const stderr = [];
+        let exitCode;
+        let settled = false;
+        const finish = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            if (error) {
+                reject(error);
+                return;
+            }
+            if (exitCode === undefined) {
+                reject(new Error('sandbox exec stream closed before reporting an exit code'));
+                return;
+            }
+            resolve({
+                exit_code: exitCode,
+                stdout: Buffer.concat(stdout).toString('utf8'),
+                stderr: Buffer.concat(stderr).toString('utf8'),
+            });
+        };
+        socket.once('open', () => socket.send(JSON.stringify(input.request)));
+        socket.on('message', (raw) => {
+            let frame;
+            try {
+                frame = JSON.parse(raw.toString());
+            }
+            catch {
+                socket.close(1002, 'invalid exec frame');
+                finish(new Error('sandbox exec stream returned invalid JSON'));
+                return;
+            }
+            if (frame.stream === 'stdout' || frame.stream === 'stderr') {
+                if (typeof frame.data !== 'string')
+                    return;
+                const chunk = Buffer.from(frame.data, 'base64');
+                if (frame.stream === 'stdout') {
+                    stdout.push(chunk);
+                    input.onStdout?.(chunk);
+                }
+                else {
+                    stderr.push(chunk);
+                    input.onStderr?.(chunk);
+                }
+                return;
+            }
+            if (frame.stream === 'exit') {
+                const code = streamExitCode(frame);
+                if (code === undefined) {
+                    socket.close(1002, 'invalid exit code');
+                    finish(new Error('sandbox exec stream returned an invalid exit code'));
+                    return;
+                }
+                exitCode = code;
+                socket.close(1000);
+            }
+        });
+        socket.once('error', (error) => finish(error));
+        socket.once('close', (code, reason) => {
+            if (exitCode !== undefined)
+                finish();
+            else {
+                finish(new Error(reason.toString() ||
+                    `sandbox exec stream closed before completion (${code})`));
+            }
+        });
+    });
+}

package/dist/services-manifest.js

@@ -2,7 +2,6 @@ import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 export const DEFAULT_BACKEND_SERVICES = [
     { name: 'api', path: 'api-service', type: 'worker', schema: 'api', secrets: 'api', public: true },
-    { name: 'auth', path: 'auth-service', type: 'worker', schema: 'auth', secrets: 'auth', public: true },
 ];
 const SERVICE_NAME = /^[a-z][a-z0-9-]{0,31}$/;
 export function readBackendServices(dir) {
@@ -33,9 +32,39 @@ export function readBackendServices(dir) {
             schema: entry.schema === undefined ? undefined : entry.schema === null ? null : String(entry.schema),
             secrets: entry.secrets === undefined ? undefined : String(entry.secrets),
             public: entry.public === undefined ? true : Boolean(entry.public),
+            bindings: parseBindings(name, entry.bindings),
         };
     });
 }
+function parseBindings(serviceName, value) {
+    if (value === undefined)
+        return undefined;
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`Service ${serviceName} bindings must be an object`);
+    }
+    const bindings = {};
+    for (const [bindingName, raw] of Object.entries(value)) {
+        if (!/^[A-Z][A-Z0-9_]{0,127}$/.test(bindingName)) {
+            throw new Error(`Invalid binding name for service ${serviceName}: ${bindingName}`);
+        }
+        if (bindingName.startsWith('NEWLY_')) {
+            throw new Error(`Service ${serviceName} cannot override reserved binding ${bindingName}`);
+        }
+        if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+            throw new Error(`Binding ${bindingName} for service ${serviceName} must be an object`);
+        }
+        const entries = Object.entries(raw);
+        if (entries.length !== 1 || !['database', 'secret', 'storage'].includes(entries[0][0])) {
+            throw new Error(`Binding ${bindingName} for service ${serviceName} must declare exactly one database, secret, or storage`);
+        }
+        const [kind, logicalName] = entries[0];
+        if (typeof logicalName !== 'string' || logicalName.length === 0) {
+            throw new Error(`Binding ${bindingName} for service ${serviceName} has an invalid logical name`);
+        }
+        bindings[bindingName] = { [kind]: logicalName };
+    }
+    return bindings;
+}
 export function parseServiceFilter(value) {
     if (!value)
         return [];

package/dist/shellSession.js

@@ -0,0 +1,86 @@
+import WebSocket from 'ws';
+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(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(), {
+        headers: { Authorization: `Bearer ${input.token}` },
+    });
+    const ttyInput = stdin;
+    const ttyOutput = stdout;
+    const wasRaw = ttyInput.isRaw;
+    let exitCode = 1;
+    const sendResize = () => {
+        if (socket.readyState === WebSocket.OPEN && ttyOutput.rows && ttyOutput.columns) {
+            socket.send(JSON.stringify({ stream: 'resize', rows: ttyOutput.rows, cols: ttyOutput.columns }));
+        }
+    };
+    const onInput = (data) => {
+        if (socket.readyState === WebSocket.OPEN) {
+            socket.send(JSON.stringify({ stream: 'stdin', data: Buffer.from(data).toString('base64') }));
+        }
+    };
+    const restore = () => {
+        stdin.off('data', onInput);
+        ttyOutput.off?.('resize', sendResize);
+        if (ttyInput.isTTY && typeof ttyInput.setRawMode === 'function')
+            ttyInput.setRawMode(Boolean(wasRaw));
+        stdin.pause();
+    };
+    return await new Promise((resolve, reject) => {
+        socket.once('open', () => {
+            if (ttyInput.isTTY && typeof ttyInput.setRawMode === 'function')
+                ttyInput.setRawMode(true);
+            stdin.resume();
+            stdin.on('data', onInput);
+            ttyOutput.on?.('resize', sendResize);
+            sendResize();
+        });
+        socket.on('message', (raw) => {
+            try {
+                const frame = JSON.parse(raw.toString());
+                if ((frame.stream === 'stdout' || frame.stream === 'stderr') && typeof frame.data === 'string') {
+                    const target = frame.stream === 'stderr' ? stderr : stdout;
+                    target.write(Buffer.from(frame.data, 'base64'));
+                }
+                else if (frame.stream === 'exit') {
+                    const code = frame.code ?? frame.exit_code ?? 0;
+                    if (Number.isSafeInteger(code))
+                        exitCode = code;
+                }
+            }
+            catch {
+            }
+        });
+        socket.once('error', (error) => {
+            restore();
+            reject(error);
+        });
+        socket.once('close', (code, reason) => {
+            restore();
+            if (code >= 4400) {
+                reject(new Error(reason.toString() || `${input.label} rejected (${code})`));
+            }
+            else {
+                resolve(exitCode);
+            }
+        });
+    });
+}
+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/terminal.js

@@ -0,0 +1,158 @@
+const ANSI_PATTERN = /\u001b\[[0-9;]*m/g;
+function supportsColor(stream) {
+    return stream.isTTY === true && process.env.NO_COLOR === undefined;
+}
+function paint(code, value, stream = process.stdout) {
+    return supportsColor(stream) ? `\u001b[${code}m${value}\u001b[0m` : value;
+}
+export const style = {
+    bold: (value, stream) => paint(1, value, stream),
+    dim: (value, stream) => paint(2, value, stream),
+    red: (value, stream) => paint(31, value, stream),
+    green: (value, stream) => paint(32, value, stream),
+    yellow: (value, stream) => paint(33, value, stream),
+    blue: (value, stream) => paint(34, value, stream),
+    cyan: (value, stream) => paint(36, value, stream),
+};
+function visibleLength(value) {
+    return value.replace(ANSI_PATTERN, '').length;
+}
+function truncate(value, maxWidth) {
+    if (!maxWidth || visibleLength(value) <= maxWidth)
+        return value;
+    if (maxWidth <= 1)
+        return '…';
+    return `${value.slice(0, maxWidth - 1)}…`;
+}
+function pad(value, width) {
+    return `${value}${' '.repeat(Math.max(0, width - visibleLength(value)))}`;
+}
+export function renderTable(title, columns, rows) {
+    if (rows.length === 0)
+        return title;
+    const cells = rows.map((row) => Object.fromEntries(columns.map((column) => [
+        column.key,
+        truncate(row[column.key] === undefined || row[column.key] === null ? '—' : String(row[column.key]), column.maxWidth),
+    ])));
+    const widths = Object.fromEntries(columns.map((column) => [
+        column.key,
+        Math.max(visibleLength(column.label), ...cells.map((row) => visibleLength(row[column.key]))),
+    ]));
+    const line = (row) => columns
+        .map((column, index) => {
+        const value = row[column.key];
+        return index === columns.length - 1 ? value : pad(value, widths[column.key]);
+    })
+        .join('  ')
+        .trimEnd();
+    const header = Object.fromEntries(columns.map((column) => [column.key, style.dim(column.label)]));
+    return `${style.bold(title)}\n\n${line(header)}\n${cells.map((row) => line(row)).join('\n')}`;
+}
+export function renderDetails(title, fields, footer) {
+    const visibleFields = fields.filter(({ value }) => value !== undefined && value !== null && value !== '');
+    const labelWidth = Math.max(...visibleFields.map(({ label }) => label.length), 0);
+    const lines = visibleFields.map(({ label, value }) => `  ${style.dim(pad(label, labelWidth))}  ${String(value)}`);
+    return [style.bold(title), ...lines, footer ? `\n${footer}` : undefined]
+        .filter((value) => value !== undefined)
+        .join('\n');
+}
+export function formatState(state) {
+    const value = typeof state === 'string' && state ? state : 'unknown';
+    if (value === 'running' || value === 'ready')
+        return style.green(value);
+    if (['building', 'building_image', 'pending', 'starting', 'destroying'].includes(value)) {
+        return style.yellow(value.replaceAll('_', ' '));
+    }
+    if (value === 'paused' || value === 'archived' || value === 'stopped') {
+        return style.blue(value);
+    }
+    if (value === 'failed' || value === 'interrupted' || value === 'destroyed') {
+        return style.red(value);
+    }
+    return value.replaceAll('_', ' ');
+}
+function rounded(value, fractionDigits = 1) {
+    return Number.isInteger(value) ? String(value) : value.toFixed(fractionDigits).replace(/\.0$/, '');
+}
+export function formatCpu(milliCpu) {
+    if (typeof milliCpu !== 'number' || !Number.isFinite(milliCpu))
+        return undefined;
+    return `${rounded(milliCpu / 1000, 3)} CPU`;
+}
+export function formatMib(mebibytes) {
+    if (typeof mebibytes !== 'number' || !Number.isFinite(mebibytes))
+        return undefined;
+    if (mebibytes >= 1024)
+        return `${rounded(mebibytes / 1024)} GiB`;
+    return `${rounded(mebibytes)} MiB`;
+}
+export function formatSeconds(seconds) {
+    if (typeof seconds !== 'number' || !Number.isFinite(seconds))
+        return undefined;
+    if (seconds === 0)
+        return 'never';
+    if (seconds < 60)
+        return `${rounded(seconds)}s`;
+    if (seconds < 3600)
+        return `${rounded(seconds / 60)}m`;
+    if (seconds < 86_400)
+        return `${rounded(seconds / 3600)}h`;
+    return `${rounded(seconds / 86_400)}d`;
+}
+export function formatAge(value, now = Date.now()) {
+    if (typeof value !== 'string')
+        return undefined;
+    const timestamp = Date.parse(value);
+    if (!Number.isFinite(timestamp))
+        return value;
+    const seconds = Math.max(0, Math.floor((now - timestamp) / 1000));
+    if (seconds < 5)
+        return 'just now';
+    return `${formatSeconds(seconds)} ago`;
+}
+export function shortDigest(value) {
+    if (typeof value !== 'string' || !value)
+        return undefined;
+    const digest = value.startsWith('sha256:') ? value.slice(7) : value;
+    return digest.slice(0, 12);
+}
+export function printJson(value) {
+    console.log(JSON.stringify(value, null, 2));
+}
+export class StatusLine {
+    lastMessage;
+    frame = 0;
+    update(message) {
+        if (process.stderr.isTTY) {
+            const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+            const prefix = style.cyan(frames[this.frame++ % frames.length], process.stderr);
+            process.stderr.write(`\r\u001b[2K${prefix} ${message}`);
+            this.lastMessage = message;
+            return;
+        }
+        if (message !== this.lastMessage) {
+            process.stderr.write(`→ ${message}\n`);
+            this.lastMessage = message;
+        }
+    }
+    succeed(message) {
+        this.finish(`${style.green('✓', process.stderr)} ${message}`);
+    }
+    fail(message) {
+        this.finish(`${style.red('✗', process.stderr)} ${message}`);
+    }
+    clear() {
+        if (process.stderr.isTTY && this.lastMessage)
+            process.stderr.write('\r\u001b[2K');
+        this.lastMessage = undefined;
+    }
+    finish(message) {
+        if (process.stderr.isTTY && this.lastMessage) {
+            process.stderr.write(`\r\u001b[2K${message}\n`);
+        }
+        else {
+            process.stderr.write(`${message}\n`);
+        }
+        this.lastMessage = undefined;
+    }
+}

package/dist/version.js

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