nylorun 0.0.0-bootstrap → 0.1.0-beta

package/dist/stack/compose-file.js

@@ -0,0 +1,128 @@
+import { PINNED_IMAGES } from "./images.js";
+/**
+ * The local stack's Compose file (Runtime Architecture §14.3), written to
+ * `<Host root>/stack/compose.yaml` by `nylorun start`. It is the same for every
+ * machine: everything that varies (ports, the Postgres password, UID/GID, the
+ * Host root, the Runtime and Studio images) comes from `stack/.env`.
+ *
+ * Tenants are Postgres schemas, executed through Restate, with their history in
+ * s2-lite; the Runtime's /ready checks all three.
+ *
+ * Restate signs requests to the Worker endpoint with the private key in
+ * `stack/restate-identity.pem`, mounted read-only; the Runtime gets the public
+ * key as NYLORUN_RESTATE_IDENTITY_KEY.
+ */
+export function renderComposeFile() {
+    return `# Written by \`nylorun start\`; rewritten on every start. Settings live in .env.
+name: nylorun
+
+services:
+  postgres: # Session Store
+    image: ${PINNED_IMAGES.postgres}
+    environment:
+      POSTGRES_USER: nylorun
+      POSTGRES_PASSWORD: \${NYLORUN_POSTGRES_PASSWORD:?run nylorun start}
+      POSTGRES_DB: nylorun
+    volumes:
+      - postgres:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U nylorun -d nylorun"]
+      interval: 2s
+      timeout: 5s
+      retries: 30
+    restart: unless-stopped
+
+  restate: # Durable Session Execution
+    image: ${PINNED_IMAGES.restate}
+    command: ["--node-name=restate-1"] # stable name, so data is found on restart
+    environment:
+      RESTATE_WORKER__INVOKER__REQUEST_IDENTITY_PRIVATE_KEY_PEM_FILE: /run/nylorun/restate-identity.pem
+    volumes:
+      - restate:/restate-data
+      - \${NYLORUN_HOST_ROOT:?run nylorun start}/stack/restate-identity.pem:/run/nylorun/restate-identity.pem:ro
+    ports:
+      - "127.0.0.1:\${NYLORUN_RESTATE_PORT:?run nylorun start}:9070" # Restate UI and admin, for debugging
+    healthcheck:
+      test: ["CMD", "curl", "-fsS", "http://localhost:9070/health"]
+      interval: 2s
+      timeout: 5s
+      retries: 30
+    restart: unless-stopped
+
+  s2: # Durable Streams; not published, only the Runtime reaches it
+    image: ${PINNED_IMAGES.s2}
+    command: ["lite", "--local-root", "/home/nonroot/data"] # local disk; listens on port 80
+    # The image runs as uid 65532. Docker fills a new volume with the image's
+    # /home/nonroot, owned by that user; a volume at a path the image lacks
+    # (e.g. /data) is root-owned and s2-lite cannot write it.
+    volumes:
+      - s2:/home/nonroot
+    # The s2 image has no shell or HTTP client, so it has no health check;
+    # the Runtime's /ready covers it.
+    restart: unless-stopped
+
+  runtime:
+    image: \${NYLORUN_RUNTIME_IMAGE:?run nylorun start}
+    command: ["--role", "all"]
+    user: "\${NYLORUN_UID:?run nylorun start}:\${NYLORUN_GID:?run nylorun start}"
+    depends_on:
+      postgres: { condition: service_healthy }
+      restate: { condition: service_healthy }
+      s2: { condition: service_started }
+    environment:
+      NYLORUN_HOME: /nylorun
+      NYLORUN_LISTEN_HOST: 0.0.0.0
+      NYLORUN_LISTEN_PORT: "4000"
+      # Host headers the Runtime accepts: the stack network name, and the
+      # published port as clients on this machine address it.
+      NYLORUN_ALLOWED_HOSTS: runtime:4000,localhost:\${NYLORUN_PORT},127.0.0.1:\${NYLORUN_PORT}
+      NYLORUN_PUBLIC_URL: http://localhost:\${NYLORUN_PORT} # reported by /v1/admin/status
+      NYLORUN_DATABASE_URL: postgres://nylorun:\${NYLORUN_POSTGRES_PASSWORD}@postgres:5432/nylorun
+      NYLORUN_RESTATE_INGRESS_URL: http://restate:8080
+      NYLORUN_RESTATE_ADMIN_URL: http://restate:9070
+      NYLORUN_WORKER_URL: http://runtime:9080 # registered with Restate; not published
+      NYLORUN_RESTATE_IDENTITY_KEY: \${NYLORUN_RESTATE_IDENTITY_KEY:?run nylorun start}
+      NYLORUN_S2_ENDPOINT: http://s2:80
+      NYLORUN_S2_TOKEN: ignored # s2-lite has no access tokens yet
+      NYLORUN_WORKSPACE_STORE_URL: file:///workspaces
+    volumes:
+      - \${NYLORUN_HOST_ROOT:?run nylorun start}:/nylorun # Host root
+      - workspaces:/workspaces
+    ports:
+      - "127.0.0.1:\${NYLORUN_PORT:?run nylorun start}:4000" # Tenant API, Admin API, SSE
+    healthcheck:
+      test: ["CMD", "node", "-e", "fetch('http://localhost:4000/ready').then(r=>process.exit(r.ok?0:1),()=>process.exit(1))"]
+      interval: 2s
+      timeout: 5s
+      retries: 60
+    restart: unless-stopped
+
+  studio: # dashboard + trusted proxy
+    image: \${NYLORUN_STUDIO_IMAGE:?run nylorun start}
+    user: "\${NYLORUN_UID}:\${NYLORUN_GID}" # reads the 0600 admin key file
+    depends_on:
+      runtime: { condition: service_healthy }
+    environment:
+      NYLORUN_RUNTIME_URL: http://runtime:4000
+      NYLORUN_ADMIN_KEY_FILE: /run/nylorun/host-credentials.json
+      PORT: "3000"
+      # Studio's Host check accepts localhost/127.0.0.1 on the published port.
+      NYLORUN_STUDIO_PUBLIC_PORT: \${NYLORUN_STUDIO_PORT}
+    volumes:
+      - \${NYLORUN_HOST_ROOT}/host-credentials.json:/run/nylorun/host-credentials.json:ro
+    ports:
+      - "127.0.0.1:\${NYLORUN_STUDIO_PORT:?run nylorun start}:3000" # opened as http://localhost:<port>
+    healthcheck: # /healthz needs no session; Host studio:3000 is accepted
+      test: ["CMD", "node", "-e", "require('http').get({port:3000,path:'/healthz',headers:{host:'studio:3000'}},r=>process.exit(r.statusCode===200?0:1)).on('error',()=>process.exit(1))"]
+      interval: 2s
+      timeout: 5s
+      retries: 30
+    restart: unless-stopped
+
+volumes:
+  postgres: {}
+  restate: {}
+  s2: {}
+  workspaces: {}
+`;
+}

package/dist/stack/docker.d.ts

@@ -0,0 +1,38 @@
+export interface DockerResult {
+    code: number;
+    stdout: string;
+    stderr: string;
+    /** The docker binary was not found. */
+    missing?: boolean;
+}
+/** Runs `docker`; replaced by a fake in tests. */
+export interface DockerRunner {
+    /** Run and capture output. */
+    run(args: readonly string[]): Promise<DockerResult>;
+    /** Run with the terminal attached (progress, logs); resolves to the exit code. */
+    stream(args: readonly string[]): Promise<number>;
+}
+export declare function spawnDocker(env: Readonly<Record<string, string | undefined>>, binary?: string): DockerRunner;
+export type Check = {
+    ok: true;
+    version: string;
+} | {
+    ok: false;
+    problem: string;
+};
+export interface DockerChecks {
+    docker: Check;
+    /** Absent when Docker itself failed (Compose was not asked). */
+    compose?: Check;
+}
+/** Check the Docker engine and Compose v2; never throws. */
+export declare function checkDocker(docker: DockerRunner): Promise<DockerChecks>;
+/** Fail with a clear message when Docker or Compose v2 is unavailable. */
+export declare function dockerPreflight(docker: DockerRunner): Promise<void>;
+export interface ComposeService {
+    service: string;
+    state: string;
+    health: string;
+}
+/** Parse `docker compose ps --format json` (a JSON array, or one object per line). */
+export declare function parseComposePs(stdout: string): ComposeService[];

package/dist/stack/docker.js

@@ -0,0 +1,101 @@
+import { spawn } from "node:child_process";
+import { CliError } from "../errors.js";
+export function spawnDocker(env, binary = "docker") {
+    const childEnv = Object.fromEntries(Object.entries(env).filter((entry) => entry[1] !== undefined));
+    return {
+        run(args) {
+            return new Promise((resolve) => {
+                let stdout = "";
+                let stderr = "";
+                const child = spawn(binary, [...args], {
+                    env: childEnv,
+                    stdio: ["ignore", "pipe", "pipe"],
+                });
+                child.stdout.on("data", (chunk) => (stdout += chunk));
+                child.stderr.on("data", (chunk) => (stderr += chunk));
+                child.once("error", (error) => resolve({
+                    code: 127,
+                    stdout,
+                    stderr: error.message,
+                    ...(error.code === "ENOENT" ? { missing: true } : {}),
+                }));
+                child.once("close", (code) => resolve({ code: code ?? 1, stdout, stderr }));
+            });
+        },
+        stream(args) {
+            return new Promise((resolve) => {
+                // Compose writes progress to stderr and logs to stdout.
+                const child = spawn(binary, [...args], {
+                    env: childEnv,
+                    stdio: ["inherit", "inherit", "inherit"],
+                });
+                child.once("error", () => resolve(127));
+                child.once("close", (code) => resolve(code ?? 1));
+            });
+        },
+    };
+}
+function firstLine(text) {
+    return text.trim().split(/\r?\n/)[0] ?? "";
+}
+/** Check the Docker engine and Compose v2; never throws. */
+export async function checkDocker(docker) {
+    const server = await docker.run(["version", "--format", "{{.Server.Version}}"]);
+    if (server.missing)
+        return {
+            docker: {
+                ok: false,
+                problem: "Docker is required for the Nylorun stack, and the docker command was not found. Install Docker Desktop, OrbStack, Colima or another Docker engine with Compose v2, then retry.",
+            },
+        };
+    if (server.code !== 0)
+        return {
+            docker: {
+                ok: false,
+                problem: `Docker is installed but its engine is not reachable (${firstLine(server.stderr) || `exit ${server.code}`}). Start Docker Desktop, OrbStack, Colima or your Docker engine, then retry.`,
+            },
+        };
+    const engine = { ok: true, version: server.stdout.trim() };
+    const compose = await docker.run(["compose", "version", "--short"]);
+    if (compose.code !== 0 || !/^v?[2-9]\./.test(compose.stdout.trim()))
+        return {
+            docker: engine,
+            compose: {
+                ok: false,
+                problem: `Docker Compose v2 is required (the "docker compose" plugin); ${compose.code === 0 ? `found ${compose.stdout.trim()}` : firstLine(compose.stderr) || "it is not installed"}. Install or update Docker Compose, then retry.`,
+            },
+        };
+    return { docker: engine, compose: { ok: true, version: compose.stdout.trim() } };
+}
+/** Fail with a clear message when Docker or Compose v2 is unavailable. */
+export async function dockerPreflight(docker) {
+    const checks = await checkDocker(docker);
+    if (!checks.docker.ok)
+        throw new CliError(checks.docker.problem, 1);
+    if (checks.compose && !checks.compose.ok)
+        throw new CliError(checks.compose.problem, 1);
+}
+/** Parse `docker compose ps --format json` (a JSON array, or one object per line). */
+export function parseComposePs(stdout) {
+    const text = stdout.trim();
+    if (text === "")
+        return [];
+    let rows;
+    if (text.startsWith("[")) {
+        rows = JSON.parse(text);
+    }
+    else {
+        rows = text
+            .split(/\r?\n/)
+            .filter((line) => line.trim() !== "")
+            .map((line) => JSON.parse(line));
+    }
+    return rows.map((row) => {
+        const record = row;
+        return {
+            service: String(record.Service ?? record.Name ?? ""),
+            state: String(record.State ?? ""),
+            health: String(record.Health ?? ""),
+        };
+    });
+}

package/dist/stack/env-file.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Settings in `stack/.env` (mode 0600). Ports and the password persist; the
+ * Restate identity public key is derived from `restate-identity.pem`.
+ */
+export interface StackEnv {
+    /** Published Runtime port (loopback). */
+    runtimePort: number;
+    /** Published Studio port (loopback). */
+    studioPort: number;
+    /** Published Restate UI and admin port (loopback). */
+    restatePort: number;
+    postgresPassword: string;
+    /** `publickeyv1_...` of `stack/restate-identity.pem`. */
+    restateIdentityKey: string;
+    uid: number;
+    gid: number;
+    /** Absolute Host root on this machine, bind-mounted at /nylorun. */
+    hostRoot: string;
+    runtimeImage: string;
+    studioImage: string;
+}
+export declare function renderEnvFile(env: StackEnv): string;
+/** Parse KEY=value lines; comments and blank lines are skipped. */
+export declare function parseEnvLines(text: string): Map<string, string>;
+/** The settings that persist across starts, from an existing .env. */
+export interface PersistedStackEnv {
+    runtimePort?: number;
+    studioPort?: number;
+    restatePort?: number;
+    postgresPassword?: string;
+}
+export declare function parsePersisted(text: string): PersistedStackEnv;

package/dist/stack/env-file.js

@@ -0,0 +1,93 @@
+import { CliError } from "../errors.js";
+const KEYS = {
+    runtimePort: "NYLORUN_PORT",
+    studioPort: "NYLORUN_STUDIO_PORT",
+    restatePort: "NYLORUN_RESTATE_PORT",
+    postgresPassword: "NYLORUN_POSTGRES_PASSWORD",
+    restateIdentityKey: "NYLORUN_RESTATE_IDENTITY_KEY",
+    uid: "NYLORUN_UID",
+    gid: "NYLORUN_GID",
+    hostRoot: "NYLORUN_HOST_ROOT",
+    runtimeImage: "NYLORUN_RUNTIME_IMAGE",
+    studioImage: "NYLORUN_STUDIO_IMAGE",
+};
+/** Compose .env values: single quotes keep a value literal (no interpolation). */
+function quote(key, value) {
+    if (/[\r\n']/.test(value))
+        throw new CliError(`${key} cannot contain a newline or single quote: ${value}`, 1);
+    return /^[A-Za-z0-9_./:@-]*$/.test(value) ? value : `'${value}'`;
+}
+function unquote(value) {
+    const trimmed = value.trim();
+    if (trimmed.length >= 2 &&
+        ((trimmed.startsWith("'") && trimmed.endsWith("'")) ||
+            (trimmed.startsWith('"') && trimmed.endsWith('"'))))
+        return trimmed.slice(1, -1);
+    return trimmed;
+}
+export function renderEnvFile(env) {
+    const line = (field) => `${KEYS[field]}=${quote(KEYS[field], String(env[field]))}`;
+    return [
+        "# Written by `nylorun start`. Mode 0600: holds the Postgres password.",
+        "# Ports and the password are kept across starts; images, UID/GID and the",
+        "# Host root are refreshed on every start.",
+        "",
+        "# Published on 127.0.0.1; clients use http://localhost:<port>.",
+        line("runtimePort"),
+        line("studioPort"),
+        line("restatePort"),
+        "",
+        line("postgresPassword"),
+        "",
+        "# Restate signs requests to the Runtime's Worker endpoint with the private",
+        "# key in restate-identity.pem; the Runtime accepts only this public key.",
+        line("restateIdentityKey"),
+        "",
+        "# The Runtime and Studio containers run as this user, so files they write",
+        "# into the Host root belong to you.",
+        line("uid"),
+        line("gid"),
+        line("hostRoot"),
+        "",
+        line("runtimeImage"),
+        line("studioImage"),
+        "",
+    ].join("\n");
+}
+/** Parse KEY=value lines; comments and blank lines are skipped. */
+export function parseEnvLines(text) {
+    const values = new Map();
+    for (const raw of text.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (line === "" || line.startsWith("#"))
+            continue;
+        const index = line.indexOf("=");
+        if (index <= 0)
+            continue;
+        values.set(line.slice(0, index).trim(), unquote(line.slice(index + 1)));
+    }
+    return values;
+}
+function port(value) {
+    if (value === undefined || !/^\d+$/.test(value))
+        return undefined;
+    const n = Number(value);
+    return n >= 1 && n <= 65535 ? n : undefined;
+}
+export function parsePersisted(text) {
+    const values = parseEnvLines(text);
+    const out = {};
+    const runtimePort = port(values.get(KEYS.runtimePort));
+    if (runtimePort)
+        out.runtimePort = runtimePort;
+    const studioPort = port(values.get(KEYS.studioPort));
+    if (studioPort)
+        out.studioPort = studioPort;
+    const restatePort = port(values.get(KEYS.restatePort));
+    if (restatePort)
+        out.restatePort = restatePort;
+    const password = values.get(KEYS.postgresPassword);
+    if (password && /^[A-Za-z0-9]{16,}$/.test(password))
+        out.postgresPassword = password;
+    return out;
+}

package/dist/stack/host-files.d.ts

@@ -0,0 +1,36 @@
+import type { StackPaths } from "./paths.js";
+/**
+ * host.json and host-credentials.json (format 1), which `@nylorun/admin`,
+ * Studio and the Runtime container all read.
+ *
+ * For the stack, host.json names the client-facing address: `localhost` and
+ * the published port. The container binds 0.0.0.0:4000 on its own.
+ */
+/** Host name clients use for the stack. Studio's cookie is set on this name too. */
+export declare const STACK_CLIENT_HOST = "localhost";
+export interface HostConfigFile {
+    format: 1;
+    hostId: string;
+    host: string;
+    port: number;
+    runtimeVersion?: string;
+    [field: string]: unknown;
+}
+export declare function newHostId(): string;
+/** The Host root layout, mode 0700. */
+export declare function ensureHostLayout(paths: StackPaths): Promise<void>;
+export declare function readHostConfig(paths: StackPaths): Promise<Record<string, unknown> | undefined>;
+/**
+ * Write host.json with the published port. Keeps the hostId and unknown fields
+ * of an existing file; refuses a newer format.
+ */
+export declare function writeStackHostConfig(paths: StackPaths, input: {
+    port: number;
+    runtimeVersion: string;
+}): Promise<HostConfigFile>;
+export declare function readAdminKey(paths: StackPaths): Promise<string | undefined>;
+/** Create host-credentials.json (mode 0600) if missing; always leave it 0600. */
+export declare function ensureHostCredentials(paths: StackPaths): Promise<{
+    adminKey: string;
+    created: boolean;
+}>;

package/dist/stack/host-files.js

@@ -0,0 +1,93 @@
+import { randomBytes } from "node:crypto";
+import { chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { newTenantId } from "@nylorun/core/compatibility";
+import { CliError } from "../errors.js";
+/**
+ * host.json and host-credentials.json (format 1), which `@nylorun/admin`,
+ * Studio and the Runtime container all read.
+ *
+ * For the stack, host.json names the client-facing address: `localhost` and
+ * the published port. The container binds 0.0.0.0:4000 on its own.
+ */
+/** Host name clients use for the stack. Studio's cookie is set on this name too. */
+export const STACK_CLIENT_HOST = "localhost";
+const KNOWN_FORMAT = 1;
+const ADMIN_KEY_PATTERN = /^[0-9a-f]{64}$/;
+export function newHostId() {
+    return `host_${newTenantId().slice(3)}`;
+}
+async function writeAtomic(path, text) {
+    const temporary = `${path}.${randomBytes(8).toString("hex")}.tmp`;
+    await writeFile(temporary, text, { mode: 0o600 });
+    await rename(temporary, path);
+    await chmod(path, 0o600);
+}
+/** The Host root layout, mode 0700. */
+export async function ensureHostLayout(paths) {
+    for (const dir of [paths.root, paths.home, paths.tmp, paths.tenants, paths.stack])
+        await mkdir(dir, { recursive: true, mode: 0o700 });
+}
+export async function readHostConfig(paths) {
+    let text;
+    try {
+        text = await readFile(paths.config, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        const value = JSON.parse(text);
+        return value && typeof value === "object" && !Array.isArray(value)
+            ? value
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Write host.json with the published port. Keeps the hostId and unknown fields
+ * of an existing file; refuses a newer format.
+ */
+export async function writeStackHostConfig(paths, input) {
+    const existing = (await readHostConfig(paths)) ?? {};
+    const format = existing.format;
+    if (format !== undefined &&
+        (typeof format !== "number" || !Number.isInteger(format) || format > KNOWN_FORMAT))
+        throw new CliError(`host.json format ${String(format)} at ${paths.config} is newer than this CLI supports (${KNOWN_FORMAT}). Upgrade nylorun.`, 1);
+    const hostId = typeof existing.hostId === "string" && /^host_[0-9a-hjkmnp-tv-z]{26}$/.test(existing.hostId)
+        ? existing.hostId
+        : newHostId();
+    const config = {
+        ...existing,
+        format: 1,
+        hostId,
+        host: STACK_CLIENT_HOST,
+        port: input.port,
+        runtimeVersion: input.runtimeVersion,
+    };
+    await writeAtomic(paths.config, `${JSON.stringify(config, null, 2)}\n`);
+    return config;
+}
+export async function readAdminKey(paths) {
+    try {
+        const value = JSON.parse(await readFile(paths.credentials, "utf8"));
+        return typeof value?.adminKey === "string" && ADMIN_KEY_PATTERN.test(value.adminKey)
+            ? value.adminKey
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Create host-credentials.json (mode 0600) if missing; always leave it 0600. */
+export async function ensureHostCredentials(paths) {
+    const existing = await readAdminKey(paths);
+    if (existing) {
+        await chmod(paths.credentials, 0o600);
+        return { adminKey: existing, created: false };
+    }
+    const adminKey = randomBytes(32).toString("hex");
+    await writeAtomic(paths.credentials, `${JSON.stringify({ adminKey })}\n`);
+    return { adminKey, created: true };
+}

package/dist/stack/images.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Images the local stack runs. The Runtime and Studio tags are pinned by this
+ * CLI release; `NYLORUN_RUNTIME_IMAGE` and `NYLORUN_STUDIO_IMAGE` override them
+ * (local builds, CI images). Postgres, Restate and s2-lite are the official
+ * images, pinned here.
+ */
+export declare const PINNED_IMAGES: {
+    readonly postgres: "postgres:17.11";
+    readonly restate: "docker.restate.dev/restatedev/restate:1.7.12";
+    readonly s2: "ghcr.io/s2-streamstore/s2:0.43.0";
+};
+export interface StackImages {
+    runtime: string;
+    studio: string;
+    postgres: string;
+    restate: string;
+    s2: string;
+}
+export declare function stackImages(env: Readonly<Record<string, string | undefined>>, versions?: {
+    runtime: string;
+    studio: string;
+}): StackImages;

package/dist/stack/images.js

@@ -0,0 +1,28 @@
+import { pinnedVersion } from "./versions.js";
+/**
+ * Images the local stack runs. The Runtime and Studio tags are pinned by this
+ * CLI release; `NYLORUN_RUNTIME_IMAGE` and `NYLORUN_STUDIO_IMAGE` override them
+ * (local builds, CI images). Postgres, Restate and s2-lite are the official
+ * images, pinned here.
+ */
+export const PINNED_IMAGES = {
+    postgres: "postgres:17.11",
+    restate: "docker.restate.dev/restatedev/restate:1.7.12",
+    s2: "ghcr.io/s2-streamstore/s2:0.43.0",
+};
+export function stackImages(env, versions = {
+    runtime: pinnedVersion("runtime"),
+    studio: pinnedVersion("studio"),
+}) {
+    const override = (name) => {
+        const value = env[name]?.trim();
+        return value ? value : undefined;
+    };
+    return {
+        runtime: override("NYLORUN_RUNTIME_IMAGE") ??
+            `ghcr.io/nylorun/runtime:${versions.runtime}`,
+        studio: override("NYLORUN_STUDIO_IMAGE") ??
+            `ghcr.io/nylorun/studio:${versions.studio}`,
+        ...PINNED_IMAGES,
+    };
+}

package/dist/stack/index.d.ts

@@ -0,0 +1,13 @@
+import { type StackDeps } from "./commands.js";
+export { ensureStack, isStackCommand, readStackStatus, stackUsage, studioLoginUrl, tenantStudioPath, STACK_SERVICES, } from "./commands.js";
+export type { StackDeps, StackEndpoints, StackStatus } from "./commands.js";
+export { checkDocker } from "./docker.js";
+export type { Check, DockerChecks } from "./docker.js";
+/** Real dependencies: docker on PATH, global fetch, the terminal. */
+export declare function defaultStackDeps(env: Readonly<Record<string, string | undefined>>): StackDeps;
+/** Entry for `nylorun start|stop|status|logs|reset|studio`. */
+export declare function stackCommand(name: string, args: readonly string[], env: Readonly<Record<string, string | undefined>>): Promise<number>;
+/** `nylorun studio`, landing on `next` (a Tenant page) when given. */
+export declare function studioCommand(args: readonly string[], env: Readonly<Record<string, string | undefined>>, options?: {
+    next?: string;
+}): Promise<number>;

package/dist/stack/index.js

@@ -0,0 +1,75 @@
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline/promises";
+import { runStackCommand, runStudioCommand } from "./commands.js";
+import { spawnDocker } from "./docker.js";
+import { pinnedVersion } from "./versions.js";
+import { loopbackPorts } from "./ports.js";
+export { ensureStack, isStackCommand, readStackStatus, stackUsage, studioLoginUrl, tenantStudioPath, STACK_SERVICES, } from "./commands.js";
+export { checkDocker } from "./docker.js";
+function browserCommand(env) {
+    if (process.platform === "darwin")
+        return "open";
+    if (env.WSL_DISTRO_NAME)
+        return "wslview";
+    return "xdg-open";
+}
+/** Real dependencies: docker on PATH, global fetch, the terminal. */
+export function defaultStackDeps(env) {
+    const interactive = Boolean(process.stdin.isTTY && process.stderr.isTTY);
+    return {
+        env,
+        docker: spawnDocker(env),
+        fetch: (input, init) => fetch(input, init),
+        ports: loopbackPorts,
+        uid: typeof process.getuid === "function" ? process.getuid() : 1000,
+        gid: typeof process.getgid === "function" ? process.getgid() : 1000,
+        runtimeVersion: pinnedVersion("runtime"),
+        studioVersion: pinnedVersion("studio"),
+        out: (line) => console.log(line),
+        err: (line) => console.error(line),
+        ...(interactive
+            ? {
+                confirm: async (question) => {
+                    const rl = createInterface({ input: process.stdin, output: process.stderr });
+                    try {
+                        return /^y(es)?$/i.test((await rl.question(question)).trim());
+                    }
+                    finally {
+                        rl.close();
+                    }
+                },
+            }
+            : {}),
+        openBrowser: async (url) => {
+            const command = browserCommand(env);
+            await new Promise((resolve) => {
+                const child = spawn(command, [url], { detached: true, stdio: "ignore" });
+                child.once("error", () => {
+                    console.error(`Could not start ${command} to open a browser; open the Studio URL above.`);
+                    resolve();
+                });
+                child.once("spawn", () => {
+                    child.unref();
+                    resolve();
+                });
+            });
+        },
+        pidAlive: (pid) => {
+            try {
+                process.kill(pid, 0);
+                return true;
+            }
+            catch (error) {
+                return error.code === "EPERM";
+            }
+        },
+    };
+}
+/** Entry for `nylorun start|stop|status|logs|reset|studio`. */
+export async function stackCommand(name, args, env) {
+    return await runStackCommand(name, args, defaultStackDeps(env));
+}
+/** `nylorun studio`, landing on `next` (a Tenant page) when given. */
+export async function studioCommand(args, env, options = {}) {
+    return await runStudioCommand(args, defaultStackDeps(env), options);
+}