@newly/cli 0.1.2 → 0.1.91

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.91';

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "@newly/cli",
-  "version": "0.1.2",
+  "version": "0.1.91",
   "description": "Develop, provision, and deploy Newly backends from your terminal",
   "license": "UNLICENSED",
   "type": "module",
   "bin": {
     "newly": "dist/index.js",
-    "newly-dev": "dist/newly-dev.js",
-    "runcloud": "dist/run-cloud.js"
+    "newly-dev": "dist/newly-dev.js"
   },
   "files": [
     "dist"
@@ -16,22 +15,29 @@
     "node": ">=20"
   },
   "scripts": {
-    "prebuild": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
+    "prebuild": "node scripts/sync-version.mjs && node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
     "build": "tsc",
-    "build:run-cloud": "tsc && node dist/run-cloud.js --help >/dev/null",
+    "build:run-cloud": "bun run build && node dist/run-cloud.js --help >/dev/null",
+    "package:runcloud": "bun run build:run-cloud && node scripts/prepare-runcloud-package.mjs",
+    "publish:runcloud": "bun run lint && bun run test && bun run package:runcloud && npm publish .publish/runcloud --access public",
     "dev": "tsx src/index.ts",
     "lint": "eslint src",
     "test": "vitest run",
-    "prepublishOnly": "pnpm lint && pnpm test && pnpm build"
+    "prepublishOnly": "bun run lint && bun run test && bun run build",
+    "sync-version": "node scripts/sync-version.mjs",
+    "test:tty": "node scripts/test-tty-login.mjs"
   },
   "dependencies": {
     "commander": "^12.1.0",
+    "esbuild": "0.25.12",
     "google-auth-library": "^9.15.0",
-    "tar": "^7.4.3"
+    "tar": "^7.4.3",
+    "ws": "^8.21.0"
   },
   "devDependencies": {
     "@eslint/js": "^9.0.0",
     "@types/node": "^20.0.0",
+    "@types/ws": "^8.18.1",
     "eslint": "^9.0.0",
     "tsx": "^4.0.0",
     "typescript": "^5.0.0",