@nylorun/cli 0.2.0-beta → 0.3.0-beta

package/dist/project/credentials.js

@@ -0,0 +1,64 @@
+import { chmod, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { CliError } from "../errors.js";
+import { credentialsPath, ensureProjectNylorunDir, } from "./link.js";
+export async function readCredentials(projectRoot) {
+    const path = credentialsPath(projectRoot);
+    try {
+        const value = JSON.parse(await readFile(path, "utf8"));
+        if (typeof value?.applicationKey !== "string" ||
+            !/^[0-9a-f]{64}$/.test(value.applicationKey) ||
+            typeof value?.principalId !== "string" ||
+            value.principalId.length === 0) {
+            throw new CliError(`Invalid Project credentials at ${path}. Remove .nylorun/credentials.json and run nylorun dev.`, 1);
+        }
+        const format = value.format === undefined || value.format === 0
+            ? 0
+            : value.format === 1
+                ? 1
+                : undefined;
+        if (format === undefined) {
+            throw new CliError(`Project credentials at ${path} have an unsupported format. Upgrade the CLI.`, 1);
+        }
+        await chmod(path, 0o600);
+        const executors = format === 0 &&
+            value.executors &&
+            typeof value.executors === "object" &&
+            !Array.isArray(value.executors)
+            ? value.executors
+            : undefined;
+        return {
+            format,
+            applicationKey: value.applicationKey,
+            principalId: value.principalId,
+            ...(executors ? { executors } : {}),
+        };
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}
+export async function writeCredentials(projectRoot, credentials) {
+    await ensureProjectNylorunDir(projectRoot);
+    const path = credentialsPath(projectRoot);
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    // Version 1 writes format 1 without executors (D§3.7).
+    const body = `${JSON.stringify({
+        format: credentials.format ?? 1,
+        applicationKey: credentials.applicationKey,
+        principalId: credentials.principalId,
+    }, null, 2)}\n`;
+    try {
+        await writeFile(temporary, body, { mode: 0o600 });
+        await rename(temporary, path);
+        await chmod(path, 0o600);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}
+export async function removeCredentials(projectRoot) {
+    await rm(credentialsPath(projectRoot), { force: true });
+}

package/dist/project/link.d.ts

@@ -0,0 +1,20 @@
+/** Project-local link to a Runtime Host Tenant (D§3.7, format 0|1). */
+export interface ProjectLink {
+    format: 0 | 1;
+    hostUrl: string;
+    hostId: string;
+    tenantId: string;
+}
+export declare function nylorunDir(projectRoot: string): string;
+export declare function linkPath(projectRoot: string): string;
+export declare function credentialsPath(projectRoot: string): string;
+/**
+ * Create `.nylorun/` mode 0700 with a private `.gitignore` containing `*`.
+ * The Project's own `.gitignore` is never edited.
+ */
+export declare function ensureProjectNylorunDir(projectRoot: string): Promise<string>;
+export declare function readLink(projectRoot: string): Promise<ProjectLink | undefined>;
+export declare function writeLink(projectRoot: string, link: Omit<ProjectLink, "format"> & {
+    format?: 0 | 1;
+}): Promise<void>;
+export declare function removeLink(projectRoot: string): Promise<void>;

package/dist/project/link.js

@@ -0,0 +1,77 @@
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { isTenantId } from "@nylorun/agents";
+import { CliError } from "../errors.js";
+export function nylorunDir(projectRoot) {
+    return join(projectRoot, ".nylorun");
+}
+export function linkPath(projectRoot) {
+    return join(nylorunDir(projectRoot), "link.json");
+}
+export function credentialsPath(projectRoot) {
+    return join(nylorunDir(projectRoot), "credentials.json");
+}
+/**
+ * Create `.nylorun/` mode 0700 with a private `.gitignore` containing `*`.
+ * The Project's own `.gitignore` is never edited.
+ */
+export async function ensureProjectNylorunDir(projectRoot) {
+    const dir = nylorunDir(projectRoot);
+    await mkdir(dir, { recursive: true, mode: 0o700 });
+    await writeFile(join(dir, ".gitignore"), "*\n", { mode: 0o600 }).catch(async () => {
+        await writeFile(join(dir, ".gitignore"), "*\n", { mode: 0o600 });
+    });
+    return dir;
+}
+export async function readLink(projectRoot) {
+    try {
+        const value = JSON.parse(await readFile(linkPath(projectRoot), "utf8"));
+        if (typeof value?.hostUrl !== "string" ||
+            typeof value?.hostId !== "string" ||
+            typeof value?.tenantId !== "string" ||
+            !isTenantId(value.tenantId)) {
+            throw new CliError(`Invalid Project link at ${linkPath(projectRoot)}. Remove .nylorun/link.json and run nylorun dev.`, 1);
+        }
+        const format = value.format === undefined || value.format === 0
+            ? 0
+            : value.format === 1
+                ? 1
+                : undefined;
+        if (format === undefined) {
+            throw new CliError(`Project link at ${linkPath(projectRoot)} has an unsupported format. Upgrade the CLI.`, 1);
+        }
+        return {
+            format,
+            hostUrl: value.hostUrl.replace(/\/$/, ""),
+            hostId: value.hostId,
+            tenantId: value.tenantId,
+        };
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}
+export async function writeLink(projectRoot, link) {
+    await ensureProjectNylorunDir(projectRoot);
+    const path = linkPath(projectRoot);
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    const body = `${JSON.stringify({
+        format: link.format ?? 1,
+        hostUrl: link.hostUrl.replace(/\/$/, ""),
+        hostId: link.hostId,
+        tenantId: link.tenantId,
+    }, null, 2)}\n`;
+    try {
+        await writeFile(temporary, body, { mode: 0o600 });
+        await rename(temporary, path);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}
+export async function removeLink(projectRoot) {
+    await rm(linkPath(projectRoot), { force: true });
+}

package/dist/project/root.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The nearest `.nylorun` wins so an initialised Project keeps working from a
+ * subdirectory; otherwise the nearest package.json defines the Project. The
+ * walk stops at the home directory because `~/.nylorun` is the Host root, never
+ * a Project root.
+ */
+export declare function findProjectRoot(cwd?: string): string | undefined;
+/** Require a Project root or throw a usage-oriented error. */
+export declare function requireProjectRoot(cwd?: string): string;

package/dist/project/root.js

@@ -0,0 +1,51 @@
+import { existsSync, realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, parse, resolve } from "node:path";
+/**
+ * The nearest `.nylorun` wins so an initialised Project keeps working from a
+ * subdirectory; otherwise the nearest package.json defines the Project. The
+ * walk stops at the home directory because `~/.nylorun` is the Host root, never
+ * a Project root.
+ */
+export function findProjectRoot(cwd = process.cwd()) {
+    const stop = (() => {
+        try {
+            return realpathSync(homedir());
+        }
+        catch {
+            return homedir();
+        }
+    })();
+    let directory = resolve(cwd);
+    try {
+        directory = realpathSync(directory);
+    }
+    catch {
+        /* unresolvable cwd falls through */
+    }
+    const root = parse(directory).root;
+    let fallback;
+    for (;;) {
+        if (directory === stop)
+            return undefined;
+        if (existsSync(join(directory, ".nylorun")))
+            return directory;
+        if (!fallback && existsSync(join(directory, "package.json")))
+            fallback = directory;
+        if (directory === root)
+            break;
+        const parent = dirname(directory);
+        if (parent === directory)
+            break;
+        directory = parent;
+    }
+    return fallback;
+}
+/** Require a Project root or throw a usage-oriented error. */
+export function requireProjectRoot(cwd = process.cwd()) {
+    const root = findProjectRoot(cwd);
+    if (!root) {
+        throw new Error("No Project found (looked for package.json or .nylorun/). Run this from a Project directory.");
+    }
+    return root;
+}

package/dist/project/seed.d.ts

@@ -0,0 +1,19 @@
+export interface SeedOptions {
+    hostUrl: string;
+    tenantId: string;
+    applicationKey: string;
+    projectRoot: string;
+    /** Pre-loaded env map; when omitted, read `.env` without mutating process.env. */
+    env?: Readonly<Record<string, string>>;
+    fetchImpl?: typeof fetch;
+    signal?: AbortSignal;
+}
+/**
+ * Seed non-secret Tenant config via `PUT /v1/tenant/config/seed`.
+ * Model secrets go through the model route into the Tenant vault (F3).
+ * `.env` is read as a value map only — never written back or applied to process.env.
+ */
+export declare function seedTenantFromProject(options: SeedOptions): Promise<{
+    applied: string[];
+    kept: string[];
+}>;

package/dist/project/seed.js

@@ -0,0 +1,94 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { PROTOCOL_HEADER, PROTOCOL_VERSION, TENANT_HEADER, } from "@nylorun/agents";
+import { CliError } from "../errors.js";
+import { putHostModel } from "../model/host-model.js";
+import { loadProjectEnvironment } from "../environment.js";
+function tenantHeaders(applicationKey, tenantId) {
+    return {
+        authorization: `Bearer ${applicationKey}`,
+        [TENANT_HEADER]: tenantId,
+        [PROTOCOL_HEADER]: String(PROTOCOL_VERSION),
+    };
+}
+/**
+ * Seed non-secret Tenant config via `PUT /v1/tenant/config/seed`.
+ * Model secrets go through the model route into the Tenant vault (F3).
+ * `.env` is read as a value map only — never written back or applied to process.env.
+ */
+export async function seedTenantFromProject(options) {
+    const env = options.env ?? loadProjectEnvironment(options.projectRoot);
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const sandboxRaw = env.NYLORUN_SANDBOX?.trim();
+    const sandbox = sandboxRaw === "auto" ||
+        sandboxRaw === "microsandbox" ||
+        sandboxRaw === "virtual"
+        ? { backend: sandboxRaw }
+        : undefined;
+    let applied = [];
+    let kept = [];
+    if (sandbox) {
+        const response = await fetchImpl(`${options.hostUrl.replace(/\/$/, "")}/v1/tenant/config/seed`, {
+            method: "PUT",
+            headers: {
+                ...tenantHeaders(options.applicationKey, options.tenantId),
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({
+                requestId: randomUUID(),
+                sandbox,
+            }),
+            signal: options.signal ?? AbortSignal.timeout(15_000),
+        });
+        if (!response.ok) {
+            throw new CliError(`Tenant config seed failed (${response.status}): ${await response
+                .text()
+                .catch(() => "")}`, 1);
+        }
+        const body = (await response.json());
+        applied = body.applied ?? [];
+        kept = body.kept ?? [];
+    }
+    if (env.NYLORUN_DEV_MODEL?.trim() !== "fixture") {
+        const seeded = modelFromEnv(env, options.projectRoot);
+        if (seeded) {
+            await putHostModel(options.hostUrl, options.applicationKey, seeded, options.tenantId);
+        }
+    }
+    return { applied, kept };
+}
+function modelFromEnv(env, projectRoot) {
+    const provider = env.MODEL_PROVIDER?.trim();
+    const model = env.MODEL?.trim();
+    if (!provider || !model)
+        return undefined;
+    const baseUrl = env.MODEL_PROVIDER_BASE_URL?.trim();
+    const key = env.MODEL_PROVIDER_API_KEY;
+    if (key) {
+        return {
+            provider,
+            model,
+            ...(baseUrl ? { baseUrl } : {}),
+            auth: { type: "api_key", key },
+        };
+    }
+    for (const relative of [".nylorun/auth.json", ".env/auth.json"]) {
+        try {
+            const all = JSON.parse(readFileSync(join(projectRoot, relative), "utf8"));
+            const credential = all[provider];
+            if (credential?.type === "api_key" || credential?.type === "oauth") {
+                return {
+                    provider,
+                    model,
+                    ...(baseUrl ? { baseUrl } : {}),
+                    auth: credential,
+                };
+            }
+        }
+        catch {
+            /* absent */
+        }
+    }
+    return undefined;
+}

package/dist/runtime/baseline.d.ts

@@ -0,0 +1,2 @@
+/** Frozen map captured when this module first loads. */
+export declare function baselineEnv(): Readonly<Record<string, string | undefined>>;

package/dist/runtime/baseline.js

@@ -0,0 +1,11 @@
+/**
+ * // CLIENTS-CCR: owned by WS-F1 (moves from cli/src/host/baseline.ts).
+ * Snapshot of the process environment at CLI module load.
+ */
+const snapshot = Object.freeze({
+    ...process.env,
+});
+/** Frozen map captured when this module first loads. */
+export function baselineEnv() {
+    return snapshot;
+}

package/dist/runtime/commands.d.ts

@@ -0,0 +1,16 @@
+import { type LauncherHandle, type LauncherOptions } from "./launcher.js";
+export declare const runtimeUsage = "  runtime up [--port <n>]\n  runtime down [--wait] [--force] [--timeout <seconds>]\n  runtime status [--json] [--env]\n  runtime logs [-f|--follow] [-n <lines>] [--tenant <id>|--all]\n  runtime restart [--port <n>] [--allow-downgrade] [--wait|--force]\n  runtime run [--port <n>]\n  up                       alias for \"runtime up\"\n  down                     alias for \"runtime down\"\n  logs                     alias for \"runtime logs\"";
+export interface RuntimeCommandOptions extends LauncherOptions {
+    home?: string;
+    /** Injected launcher handle (tests). */
+    handle?: LauncherHandle;
+    /** Hook for `status --env` (F2 wires Project link exports). */
+    envHook?: () => void | Promise<void>;
+}
+/**
+ * `nylorun runtime …` and the `up` / `down` / `logs` aliases.
+ * Dispatch from `cli.ts` is owned by WS-F2 (one-line import change).
+ */
+export declare function runtimeCommand(args: readonly string[], options?: RuntimeCommandOptions): Promise<void>;
+export { runtimeVersion } from "./version.js";
+export { launcher } from "./launcher.js";

package/dist/runtime/commands.js

@@ -0,0 +1,292 @@
+import { resolve } from "node:path";
+import { CliError } from "../errors.js";
+import { exitCodeForStatusState, } from "./exit-codes.js";
+import { launcher, resolveHome, throwOnLauncherFailure, } from "./launcher.js";
+import { runtimeVersion } from "./version.js";
+export const runtimeUsage = `  runtime up [--port <n>]
+  runtime down [--wait] [--force] [--timeout <seconds>]
+  runtime status [--json] [--env]
+  runtime logs [-f|--follow] [-n <lines>] [--tenant <id>|--all]
+  runtime restart [--port <n>] [--allow-downgrade] [--wait|--force]
+  runtime run [--port <n>]
+  up                       alias for "runtime up"
+  down                     alias for "runtime down"
+  logs                     alias for "runtime logs"`;
+const usageError = (message) => new CliError(message, 2);
+function parseRuntimeFlags(args, allowed = {}) {
+    const booleans = new Set();
+    const values = new Map();
+    const rest = [];
+    const booleanNames = new Set(allowed.booleans ?? []);
+    const valueNames = new Set(allowed.values ?? []);
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (!arg.startsWith("-")) {
+            rest.push(arg);
+            continue;
+        }
+        if (booleanNames.has(arg)) {
+            if (booleans.has(arg))
+                throw usageError(`${arg} may only be supplied once.`);
+            booleans.add(arg);
+            continue;
+        }
+        if (valueNames.has(arg)) {
+            if (values.has(arg))
+                throw usageError(`${arg} may only be supplied once.`);
+            const value = args[++index];
+            if (!value || value.startsWith("-"))
+                throw usageError(`${arg} requires a value.`);
+            values.set(arg, value);
+            continue;
+        }
+        throw usageError(`Unknown flag ${arg}.\n${runtimeUsage}`);
+    }
+    return { rest, booleans, values };
+}
+function parsePort(value) {
+    if (value === undefined)
+        return undefined;
+    const port = Number(value);
+    if (!Number.isInteger(port) || port < 0 || port > 65535)
+        throw usageError("--port must be an integer between 0 and 65535.");
+    return port;
+}
+/**
+ * `nylorun runtime …` and the `up` / `down` / `logs` aliases.
+ * Dispatch from `cli.ts` is owned by WS-F2 (one-line import change).
+ */
+export async function runtimeCommand(args, options = {}) {
+    const home = options.home ??
+        (options.env?.NYLORUN_HOME
+            ? resolve(options.env.NYLORUN_HOME)
+            : resolveHome());
+    const handle = options.handle ??
+        (await launcher(home, { env: options.env }));
+    const [verb, ...rest] = args;
+    if (verb === "up" || verb === "start") {
+        const flags = parseRuntimeFlags(rest, {
+            values: ["--port"],
+        });
+        if (flags.rest.length)
+            throw usageError(runtimeUsage);
+        const port = parsePort(flags.values.get("--port"));
+        const invokeArgs = ["up"];
+        if (port !== undefined)
+            invokeArgs.push("--port", String(port));
+        const outcome = await handle.invoke(invokeArgs);
+        throwOnLauncherFailure(outcome);
+        const result = outcome.result ?? {};
+        const url = typeof result.url === "string" ? result.url : undefined;
+        const started = result.started === true;
+        if (url && started) {
+            console.log(`Started the Runtime Host at ${url}${result.pid ? ` (pid ${result.pid})` : ""}. It stays running; stop it with "nylorun runtime down".`);
+        }
+        printUpResult(result);
+        console.log(`\n→ npx nylorun dev`);
+        return;
+    }
+    if (verb === "down" || verb === "stop") {
+        const flags = parseRuntimeFlags(rest, {
+            booleans: ["--wait", "--force"],
+            values: ["--timeout"],
+        });
+        if (flags.rest.length)
+            throw usageError(runtimeUsage);
+        if (flags.booleans.has("--wait") && flags.booleans.has("--force")) {
+            throw usageError("Use either --wait or --force, not both.");
+        }
+        const invokeArgs = ["down"];
+        if (flags.booleans.has("--wait"))
+            invokeArgs.push("--wait");
+        if (flags.booleans.has("--force"))
+            invokeArgs.push("--force");
+        if (flags.values.has("--timeout")) {
+            const seconds = Number(flags.values.get("--timeout"));
+            if (!Number.isFinite(seconds) || seconds <= 0)
+                throw usageError("--timeout must be a positive number of seconds.");
+            invokeArgs.push("--timeout", String(seconds));
+        }
+        const outcome = await handle.invoke(invokeArgs);
+        throwOnLauncherFailure(outcome);
+        const stopped = outcome.result?.stopped === true;
+        console.log(stopped
+            ? `Stopped the Runtime Host. host.json and Tenants are kept under the Host root.`
+            : `No Runtime Host is running.`);
+        return;
+    }
+    if (verb === "status") {
+        const flags = parseRuntimeFlags(rest, {
+            booleans: ["--json", "--env"],
+            values: ["--output"],
+        });
+        if (flags.rest.length)
+            throw usageError(runtimeUsage);
+        const json = flags.booleans.has("--json") || flags.values.get("--output") === "json";
+        if (flags.values.has("--output") &&
+            flags.values.get("--output") !== "json" &&
+            flags.values.get("--output") !== "text") {
+            throw usageError("--output must be text or json.");
+        }
+        if (flags.booleans.has("--env")) {
+            if (options.envHook)
+                await options.envHook();
+            else {
+                console.log("# runtime status --env requires a Project link (nylorun dev). Coming in a later release.");
+            }
+            return;
+        }
+        const outcome = await handle.invoke(["status"]);
+        throwOnLauncherFailure(outcome);
+        const result = outcome.result ?? {};
+        if (json) {
+            console.log(JSON.stringify({
+                ...result,
+                node: handle.runtime.node,
+                recommendedRuntimeVersion: runtimeVersion(),
+            }, null, 2));
+        }
+        else {
+            printStatus(result, handle);
+        }
+        const state = typeof result.state === "string" ? result.state : undefined;
+        const code = exitCodeForStatusState(state);
+        if (code !== undefined)
+            process.exitCode = code;
+        return;
+    }
+    if (verb === "logs") {
+        const flags = parseRuntimeFlags(rest, {
+            booleans: ["-f", "--follow", "--all"],
+            values: ["-n", "--lines", "--tenant"],
+        });
+        if (flags.rest.length)
+            throw usageError(runtimeUsage);
+        if (flags.booleans.has("--all") && flags.values.has("--tenant")) {
+            throw usageError("Use either --tenant or --all, not both.");
+        }
+        const linesRaw = flags.values.get("-n") ?? flags.values.get("--lines");
+        const lines = linesRaw !== undefined ? Number(linesRaw) : 200;
+        if (!Number.isInteger(lines) || lines < 1)
+            throw usageError("-n must be a positive integer.");
+        const follow = flags.booleans.has("-f") || flags.booleans.has("--follow");
+        const invokeArgs = ["logs", "--lines", String(lines)];
+        if (follow)
+            invokeArgs.push("--follow");
+        if (flags.booleans.has("--all"))
+            invokeArgs.push("--all");
+        if (flags.values.has("--tenant")) {
+            invokeArgs.push("--tenant", flags.values.get("--tenant"));
+        }
+        const outcome = follow
+            ? await handle.invokeStreaming(invokeArgs)
+            : await handle.invoke(invokeArgs);
+        if (outcome.exitCode !== 0) {
+            if (outcome.error?.code === "not_found" ||
+                /no .*log/i.test(outcome.error?.message ?? outcome.stderr)) {
+                throw new CliError(`No Runtime Host log under ${home}. Start one with "nylorun runtime up".`, 3);
+            }
+            throwOnLauncherFailure(outcome);
+        }
+        return;
+    }
+    if (verb === "restart") {
+        const flags = parseRuntimeFlags(rest, {
+            booleans: ["--allow-downgrade", "--wait", "--force"],
+            values: ["--port"],
+        });
+        if (flags.rest.length)
+            throw usageError(runtimeUsage);
+        if (flags.booleans.has("--wait") && flags.booleans.has("--force")) {
+            throw usageError("Use either --wait or --force, not both.");
+        }
+        const port = parsePort(flags.values.get("--port"));
+        const invokeArgs = ["restart"];
+        if (port !== undefined)
+            invokeArgs.push("--port", String(port));
+        if (flags.booleans.has("--allow-downgrade"))
+            invokeArgs.push("--allow-downgrade");
+        if (flags.booleans.has("--wait"))
+            invokeArgs.push("--wait");
+        if (flags.booleans.has("--force"))
+            invokeArgs.push("--force");
+        const outcome = await handle.invoke(invokeArgs);
+        throwOnLauncherFailure(outcome);
+        printUpResult(outcome.result ?? {});
+        return;
+    }
+    if (verb === "run") {
+        const flags = parseRuntimeFlags(rest, {
+            values: ["--port"],
+        });
+        if (flags.rest.length)
+            throw usageError(runtimeUsage);
+        const port = parsePort(flags.values.get("--port"));
+        const invokeArgs = ["run"];
+        if (port !== undefined)
+            invokeArgs.push("--port", String(port));
+        const outcome = await handle.invokeStreaming(invokeArgs);
+        throwOnLauncherFailure(outcome);
+        return;
+    }
+    throw usageError(runtimeUsage);
+}
+function printUpResult(result) {
+    const lines = [
+        ["Host", typeof result.hostId === "string" ? result.hostId : undefined],
+        ["URL", typeof result.url === "string" ? result.url : undefined],
+        [
+            "PID",
+            typeof result.pid === "number" ? String(result.pid) : undefined,
+        ],
+        [
+            "Version",
+            typeof result.version === "string" ? result.version : undefined,
+        ],
+        [
+            "Started",
+            result.started === true
+                ? "yes"
+                : result.started === false
+                    ? "already running"
+                    : undefined,
+        ],
+    ];
+    const width = Math.max(...lines.map(([label]) => label.length));
+    for (const [label, value] of lines) {
+        if (value !== undefined)
+            console.log(`${label.padEnd(width)}  ${value}`);
+    }
+}
+function printStatus(result, handle) {
+    const lines = [
+        ["Home", typeof result.home === "string" ? result.home : undefined],
+        ["State", typeof result.state === "string" ? result.state : undefined],
+        ["Host", typeof result.hostId === "string" ? result.hostId : undefined],
+        ["URL", typeof result.url === "string" ? result.url : undefined],
+        [
+            "PID",
+            typeof result.pid === "number" ? String(result.pid) : undefined,
+        ],
+        [
+            "Version",
+            typeof result.version === "string" ? result.version : undefined,
+        ],
+        [
+            "Last started",
+            typeof result.runtimeVersion === "string"
+                ? result.runtimeVersion
+                : undefined,
+        ],
+        ["Installed", `${handle.runtime.version} (${handle.runtime.bin})`],
+        ["Node", handle.runtime.node],
+        ["Recommended", runtimeVersion()],
+    ];
+    const width = Math.max(...lines.map(([label]) => label.length));
+    for (const [label, value] of lines) {
+        if (value !== undefined)
+            console.log(`${label.padEnd(width)}  ${value}`);
+    }
+}
+export { runtimeVersion } from "./version.js";
+export { launcher } from "./launcher.js";