@newly/cli 0.1.1 → 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,23 +1,54 @@
 import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
-function newlyHome() {
+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 (isRunCloud())
+        return process.env.RUN_CLOUD_HOME ?? join(homedir(), '.run-cloud');
     return process.env.NEWLY_HOME ?? join(homedir(), '.newly');
 }
 function credentialsPath() {
-    return join(newlyHome(), 'credentials');
+    return join(credentialsHome(), 'credentials');
+}
+export function credentialsDisplayPath() {
+    const path = credentialsPath();
+    const home = homedir();
+    return path.startsWith(home) ? `~${path.slice(home.length)}` : path;
+}
+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(newlyHome(), { recursive: true, mode: 0o700 });
+    mkdirSync(credentialsHome(), { recursive: true, mode: 0o700 });
     const normalized = { ...creds, apiUrl: normalizeApiUrl(creds.apiUrl) };
     writeFileSync(credentialsPath(), JSON.stringify(normalized, null, 2) + '\n', { mode: 0o600 });
     chmodSync(credentialsPath(), 0o600);
 }
 export function loadCredentials() {
+    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() || '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,
+        };
+    }
     if (!existsSync(credentialsPath()))
         return null;
     try {
@@ -30,13 +61,47 @@ 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 });
 }
 export function requireCredentials() {
     const creds = loadCredentials();
     if (!creds) {
-        throw new Error('Not logged in (or session expired). Run: newly login');
+        throw new Error(`Not logged in (or session expired). Run: ${loginCommandName()}`);
     }
     return creds;
 }

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

@@ -0,0 +1,159 @@
+const DEFAULT_URLS = {
+    dev: {
+        apiOps: 'https://cp-api-ops-dev.newly.app',
+        worker: 'https://cp-worker-dev.newly.app',
+    },
+    prod: {
+        apiOps: 'https://cp-api-ops-prod.newly.app',
+        worker: 'https://cp-worker-prod.newly.app',
+    },
+};
+function stripSlash(url) {
+    return url.replace(/\/+$/, '');
+}
+export function resolveTargets(env) {
+    if (env !== 'dev' && env !== 'prod') {
+        throw new Error(`--env must be dev or prod (got "${env}")`);
+    }
+    const upper = env.toUpperCase();
+    const apiOps = process.env[`DIAGNOSE_CP_API_OPS_URL_${upper}`] ??
+        process.env.DIAGNOSE_CP_API_OPS_URL ??
+        DEFAULT_URLS[env].apiOps;
+    const worker = process.env[`DIAGNOSE_CP_WORKER_URL_${upper}`] ??
+        process.env.DIAGNOSE_CP_WORKER_URL ??
+        DEFAULT_URLS[env].worker;
+    return [
+        { service: 'cp-api', url: stripSlash(apiOps) },
+        { service: 'cp-worker', url: stripSlash(worker) },
+    ];
+}
+function extractAuthorization(headers) {
+    if (headers instanceof Headers) {
+        return headers.get('authorization') ?? undefined;
+    }
+    const h = headers;
+    return h?.Authorization ?? h?.authorization;
+}
+export async function resolveOpsAuthHeader(env = process.env) {
+    const audience = env.DIAGNOSE_OIDC_AUDIENCE ?? 'newly-diagnose-ops';
+    try {
+        const { GoogleAuth } = await import('google-auth-library');
+        const auth = new GoogleAuth();
+        const client = await auth.getIdTokenClient(audience);
+        const authz = extractAuthorization(await client.getRequestHeaders());
+        if (authz) {
+            return authz;
+        }
+    }
+    catch {
+    }
+    const token = env.DIAGNOSE_OPS_TOKEN;
+    if (token) {
+        return `Bearer ${token}`;
+    }
+    throw new Error('No ops credential available. Run `gcloud auth application-default login` (ADC/OIDC), ' +
+        'or export DIAGNOSE_OPS_TOKEN with the break-glass ops token.');
+}
+function truncate(value, max = 200) {
+    const trimmed = value.trim();
+    return trimmed.length > max ? `${trimmed.slice(0, max)}...` : trimmed;
+}
+export async function fetchDiagnose(target, authHeader) {
+    try {
+        const res = await fetch(`${target.url}/diagnose`, { headers: { Authorization: authHeader } });
+        if (!res.ok) {
+            const body = await res.text().catch(() => '');
+            return {
+                service: target.service,
+                error: `HTTP ${res.status}${body ? `: ${truncate(body)}` : ''}`,
+            };
+        }
+        return (await res.json());
+    }
+    catch (e) {
+        return { service: target.service, error: e instanceof Error ? e.message : String(e) };
+    }
+}
+function isDoc(result) {
+    return !('error' in result);
+}
+export function rollupVerdict(services) {
+    const names = Object.keys(services);
+    const down = names.filter((name) => !isDoc(services[name]));
+    if (down.length) {
+        return `DOWN - unreachable: ${down.join(', ')}`;
+    }
+    const degraded = [];
+    for (const name of names) {
+        const doc = services[name];
+        const bad = Object.entries(doc.health)
+            .filter(([, probe]) => !probe.ok)
+            .map(([probeName]) => probeName);
+        if (bad.length) {
+            degraded.push(`${name} (${bad.join(', ')})`);
+        }
+    }
+    if (degraded.length) {
+        return `DEGRADED - ${degraded.join('; ')}`;
+    }
+    return `OK - ${names.length} service(s) healthy`;
+}
+export async function fanoutDiagnose(env) {
+    const targets = resolveTargets(env);
+    const authHeader = await resolveOpsAuthHeader();
+    const results = await Promise.all(targets.map((target) => fetchDiagnose(target, authHeader)));
+    const services = {};
+    results.forEach((result, index) => {
+        services[targets[index].service] = result;
+    });
+    return { rollup: rollupVerdict(services), services };
+}
+export function renderRollup(result, session) {
+    const lines = [result.rollup];
+    if (session) {
+        lines.push(`session: ${session}`);
+    }
+    lines.push('');
+    for (const [name, service] of Object.entries(result.services)) {
+        if (!isDoc(service)) {
+            lines.push(`${name}: UNREACHABLE - ${service.error}`);
+            continue;
+        }
+        const sha = service.deploy.git_sha ?? '(sha unknown)';
+        const revision = service.deploy.revision ?? '(revision unknown)';
+        lines.push(`${name}: ${sha} @ ${revision} [env=${service.env}]`);
+        const badProbes = Object.entries(service.health)
+            .filter(([, probe]) => !probe.ok)
+            .map(([probeName, probe]) => `${probeName}${probe.detail ? ` (${probe.detail})` : ''}`);
+        lines.push(`  health: ${badProbes.length ? `DEGRADED - ${badProbes.join(', ')}` : 'all ok'}`);
+        for (const verdict of service.diagnosis) {
+            lines.push(`  - ${verdict}`);
+        }
+    }
+    return lines.join('\n');
+}
+export function registerDiagnose(program) {
+    program
+        .command('diagnose')
+        .description('Fan out /diagnose across control-plane services and roll up a verdict (dev/ops only)')
+        .option('--env <env>', 'dev or prod', 'dev')
+        .option('--session <id>', 'annotate the rollup with a session id you are investigating')
+        .option('--json', 'emit the merged JSON document instead of the human rollup')
+        .action(async (opts) => {
+        try {
+            if (opts.env !== 'dev' && opts.env !== 'prod') {
+                throw new Error('--env must be dev or prod');
+            }
+            const result = await fanoutDiagnose(opts.env);
+            if (opts.json) {
+                console.log(JSON.stringify({ session: opts.session ?? null, ...result }, null, 2));
+                return;
+            }
+            console.log(renderRollup(result, opts.session));
+        }
+        catch (e) {
+            console.error(e instanceof Error ? e.message : String(e));
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/index.js

@@ -15,6 +15,10 @@ import { registerEmail } from './commands/email.js';
 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');
@@ -33,4 +37,8 @@ registerEmail(program);
 registerWebsite(program);
 registerDomains(program);
 registerDns(program);
+registerDiagnose(program);
+registerDesktop(program);
+registerEnvironment(program);
+registerAppStore(program);
 await program.parseAsync(process.argv);