nylorun 0.4.0-beta → 0.6.0-beta

package/dist/doctor.js

@@ -1,12 +1,12 @@
 import { CliError } from "./errors.js";
-import { checkDocker, defaultStackDeps, readStackStatus, } from "./stack/index.js";
-/** Oldest Node the stack's tooling and the developer's application run on. */
+import { checkDocker, defaultStackDeps, readProxyReport, readStackStatus, } from "./stack/index.js";
+/** Oldest Node nylorun and the developer's application run on. */
 const MIN_NODE_MAJOR = 24;
 /**
- * `nylorun doctor`: check the prerequisites of the local stack (Node 24+,
- * Docker, Compose v2) and, when they pass, the stack's health. Prints the fix
+ * `nylorun doctor`: check the prerequisites of a local Tenant (Node 24+,
+ * Docker, Compose v2) and, when they pass, the Tenant's health. Prints the fix
  * for each problem and returns 1 when a prerequisite is missing or a running
- * stack is unhealthy; installs and starts nothing.
+ * Tenant is unhealthy; installs and starts nothing.
  */
 export async function doctorStack(options) {
     const log = options.log ?? ((line) => console.log(line));
@@ -20,7 +20,7 @@ export async function doctorStack(options) {
     if (checks.docker.ok && checks.compose?.ok) {
         try {
             const status = await readStackStatus(deps);
-            report.stack = {
+            report.tenant = {
                 name: status.name,
                 project: status.project,
                 home: status.home,
@@ -34,14 +34,15 @@ export async function doctorStack(options) {
         catch (error) {
             if (!(error instanceof CliError) || error.exitCode !== 2)
                 throw error;
-            report.noStack = error.message;
+            report.noTenant = error.message;
         }
+        report.proxy = await readProxyReport(deps);
     }
-    const stackBroken = report.stack?.state === "running" &&
-        (!report.stack.runtime.healthy ||
-            !report.stack.gateway.healthy ||
-            report.stack.tenant?.cause !== undefined);
-    const failed = !nodeOk || !checks.docker.ok || checks.compose?.ok === false || stackBroken;
+    const broken = report.tenant?.state === "running" &&
+        (!report.tenant.runtime.healthy ||
+            !report.tenant.gateway.healthy ||
+            report.tenant.tenant?.cause !== undefined);
+    const failed = !nodeOk || !checks.docker.ok || checks.compose?.ok === false || broken;
     if (options.json) {
         log(JSON.stringify(report, null, 2));
         return failed ? 1 : 0;
@@ -61,43 +62,59 @@ export async function doctorStack(options) {
         ["docker", line(checks.docker)],
         ["compose", line(checks.compose)],
     ];
-    const stack = report.stack;
-    if (report.noStack)
-        rows.push(["stack", `- ${report.noStack}`]);
-    if (stack) {
+    const local = report.tenant;
+    if (report.noTenant)
+        rows.push(["tenant", `- ${report.noTenant}`]);
+    if (local) {
         rows.push([
-            "stack",
-            stack.state === "absent"
-                ? `- ${stack.name} not created under ${stack.home}: run nylorun up`
-                : stack.state === "stopped"
-                    ? `- ${stack.name} stopped (Compose project ${stack.project}): run nylorun up`
-                    : stack.runtime.healthy
-                        ? `✓ ${stack.name} running (Compose project ${stack.project})`
-                        : `✗ ${stack.name} running, but the Runtime does not answer: see nylorun status and nylorun logs runtime`,
+            "tenant",
+            local.state === "absent"
+                ? `- ${local.name} not created under ${local.home}: run nylorun up`
+                : local.state === "stopped"
+                    ? `- ${local.name} stopped (Compose project ${local.project}): run nylorun up`
+                    : local.runtime.healthy
+                        ? `✓ ${local.name} running (Compose project ${local.project})`
+                        : `✗ ${local.name} running, but the Runtime does not answer: see nylorun status and nylorun logs runtime`,
         ]);
-        if (stack.state === "running") {
+        if (local.state === "running") {
             rows.push([
                 "runtime",
-                stack.runtime.healthy
-                    ? `✓ ${stack.runtime.url ?? "?"} · ${stack.runtime.version ?? "?"}`
-                    : `✗ ${stack.runtime.url ?? "?"} not answering`,
+                local.runtime.healthy
+                    ? `✓ ${local.runtime.url ?? "?"} · ${local.runtime.version ?? "?"}`
+                    : `✗ ${local.runtime.url ?? "?"} not answering`,
             ]);
             rows.push([
                 "gateway",
-                stack.gateway.healthy
-                    ? `✓ ${stack.gateway.state} · combined packing (runtime: core,loop; gateway: gates)`
-                    : `✗ ${stack.gateway.state}: model calls fail; see nylorun logs gateway`,
+                local.gateway.healthy
+                    ? `✓ ${local.gateway.state} · combined packing (runtime: core,loop; gateway: gates)`
+                    : `✗ ${local.gateway.state}: model calls fail; see nylorun logs gateway`,
             ]);
-            if (stack.tenant)
+            if (local.tenant)
                 rows.push([
-                    "tenant",
-                    stack.tenant.state === "open"
-                        ? `✓ ${stack.tenant.id ?? "?"} open`
-                        : `✗ ${stack.tenant.id ?? "?"} unavailable${stack.tenant.cause ? `: ${stack.tenant.cause.code}: ${stack.tenant.cause.repair}` : " (opening)"}`,
+                    "tenant id",
+                    local.tenant.state === "open"
+                        ? `✓ ${local.tenant.id ?? "?"} open`
+                        : `✗ ${local.tenant.id ?? "?"} unavailable${local.tenant.cause ? `: ${local.tenant.cause.code}: ${local.tenant.cause.repair}` : " (opening)"}`,
                 ]);
-            rows.push(["studio", `${stack.studio.url ?? "?"} · ${stack.studio.state}`]);
+            rows.push(["studio", `${local.studio.proxyUrl ?? local.studio.url ?? "?"} · ${local.studio.state}`]);
         }
     }
+    const proxy = report.proxy;
+    if (proxy) {
+        const on = proxy.port
+            ? `127.0.0.1:${proxy.port}${proxy.ipv6 ? ` and [::1]:${proxy.port}` : ""}`
+            : "";
+        rows.push([
+            "proxy",
+            proxy.state === "running"
+                ? `✓ running on ${on} (http://<tenant>.localhost:${proxy.port ?? "?"})`
+                : proxy.state === "disabled"
+                    ? "- disabled (NYLORUN_PROXY_DISABLED): Studio is on each Tenant's own port"
+                    : proxy.state === "stopped"
+                        ? `- stopped${on ? ` (${on})` : ""}: nylorun start starts it`
+                        : "- not created yet: nylorun start creates it",
+        ]);
+    }
     const width = Math.max(...rows.map(([key]) => key.length)) + 2;
     for (const [key, value] of rows)
         log(`  ${key.padEnd(width)}${value}`);

package/dist/home.d.ts

@@ -1,5 +1,5 @@
 /**
- * The Host root: an explicit home, `NYLORUN_HOME`, or `~/.nylorun`. The stack
+ * The Host root: an explicit home, `NYLORUN_HOME`, or `~/.nylorun`. Compose
  * bind-mounts it into the Runtime and Studio containers, and `@nylorun/admin`
  * reads `host.json` and the admin key from it.
  */

package/dist/home.js

@@ -1,7 +1,7 @@
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 /**
- * The Host root: an explicit home, `NYLORUN_HOME`, or `~/.nylorun`. The stack
+ * The Host root: an explicit home, `NYLORUN_HOME`, or `~/.nylorun`. Compose
  * bind-mounts it into the Runtime and Studio containers, and `@nylorun/admin`
  * reads `host.json` and the admin key from it.
  */

package/dist/project/derived-key.d.ts

@@ -1,7 +1,7 @@
-/** The derived principal a Project uses; the stack's Runtime registers it on its Tenant. */
+/** The derived principal a Project uses; the local Runtime registers it on its Tenant. */
 export declare const PROJECT_PRINCIPAL_ID = "project";
 /**
- * Key of a derived principal on the stack's Tenant, from the admin key. A copy of
+ * Key of a derived principal on the local Tenant, from the admin key. A copy of
  * `deriveTenantKey` in `@nylorun/admin` (nylorun depends on `@nylorun/core` only); both are
  * tested against the same fixed vector.
  */

package/dist/project/derived-key.js

@@ -1,8 +1,8 @@
 import { createHmac } from "node:crypto";
-/** The derived principal a Project uses; the stack's Runtime registers it on its Tenant. */
+/** The derived principal a Project uses; the local Runtime registers it on its Tenant. */
 export const PROJECT_PRINCIPAL_ID = "project";
 /**
- * Key of a derived principal on the stack's Tenant, from the admin key. A copy of
+ * Key of a derived principal on the local Tenant, from the admin key. A copy of
  * `deriveTenantKey` in `@nylorun/admin` (nylorun depends on `@nylorun/core` only); both are
  * tested against the same fixed vector.
  */

package/dist/project/link.d.ts

@@ -1,13 +1,13 @@
 /**
  * The Project link (`.nylorun/link.json`) and credentials (`.nylorun/credentials.json`).
- * `nylorun start` writes both, format 2: the stack the Project uses, its URL and Host id, and
- * the Tenant id as information (nothing selects a Tenant). Formats 0 and 1 named a Tenant on a
- * multi-Tenant Host of an older Runtime.
+ * `nylorun start` writes both, format 3: the local Tenant's name, its URL and Host id, and
+ * the Tenant id as information (nothing in a request selects a Tenant). `start` replaces a link
+ * of an older format.
  */
 export interface ProjectLink {
-    format: 0 | 1 | 2;
-    /** The local stack (format 2). */
-    stack?: string;
+    format: 0 | 1 | 2 | 3;
+    /** The local Tenant's name (format 3). */
+    tenant?: string;
     hostUrl: string;
     hostId: string;
     tenantId?: string;
@@ -17,7 +17,7 @@ export declare function credentialsPath(projectRoot: string): string;
 /** The Project's link, or undefined when it has none. An unreadable link is an error. */
 export declare function readProjectLink(projectRoot: string): Promise<ProjectLink | undefined>;
 export declare function writeProjectLink(projectRoot: string, link: {
-    stack: string;
+    tenant: string;
     hostUrl: string;
     hostId: string;
     tenantId: string;

package/dist/project/link.js

@@ -33,7 +33,7 @@ export async function readProjectLink(projectRoot) {
     const link = parsed.data;
     return {
         format: link.format,
-        ...(link.stack ? { stack: link.stack } : {}),
+        ...(link.format === 3 && link.tenant ? { tenant: link.tenant } : {}),
         hostUrl: link.hostUrl.replace(/\/$/, ""),
         hostId: link.hostId,
         ...(link.tenantId ? { tenantId: link.tenantId } : {}),
@@ -60,8 +60,8 @@ async function ensureProjectDir(projectRoot) {
 export async function writeProjectLink(projectRoot, link) {
     await ensureProjectDir(projectRoot);
     await writePrivate(linkPath(projectRoot), {
-        format: 2,
-        stack: link.stack,
+        format: 3,
+        tenant: link.tenant,
         hostUrl: link.hostUrl.replace(/\/$/, ""),
         hostId: link.hostId,
         tenantId: link.tenantId,

package/dist/stack/commands.d.ts

@@ -1,11 +1,12 @@
 import type { HostTenant } from "@nylorun/core/contracts";
 import { type ComposeService, type DockerRunner } from "./docker.js";
 import type { PortProbe } from "./ports.js";
+import { type ProxyStatus } from "./proxy.js";
 import { type FetchLike } from "./studio-login.js";
-export declare const STACK_SERVICES: readonly ["postgres", "restate", "s2", "gateway", "runtime", "studio"];
+export declare const STACK_SERVICES: readonly ["postgres", "restate", "s2-lite", "gateway", "runtime", "studio"];
 export declare const stackUsage: string;
 export interface StackDeps {
-    /** Environment snapshot (NYLORUN_HOME, NYLORUN_STACK, image overrides, NYLORUN_STACK_PROJECT). */
+    /** Environment snapshot (NYLORUN_HOME, NYLORUN_TENANT, image overrides, NYLORUN_COMPOSE_PROJECT). */
     env: Readonly<Record<string, string | undefined>>;
     docker: DockerRunner;
     fetch: FetchLike;
@@ -26,7 +27,7 @@ export interface StackDeps {
     pidAlive(pid: number): boolean;
     /** Where the project is looked for (default: the process's working directory). */
     cwd?: string;
-    /** `~/.nylorun`: the stacks and the legacy stack (tests use a temporary directory). */
+    /** `~/.nylorun`: the Tenants (tests use a temporary directory). */
     nylorunRoot?: string;
     /** Delay between health polls; tests shorten it. */
     pollMs?: number;
@@ -35,7 +36,7 @@ export interface StackDeps {
     /** How long a Studio login is retried before warning. */
     loginTimeoutMs?: number;
 }
-/** The Compose project of stack `name`: `nylorun-<name>`, or `NYLORUN_STACK_PROJECT`. */
+/** The Compose project of Tenant `name`: `nylorun-<name>`, or `NYLORUN_COMPOSE_PROJECT`. */
 export declare function stackProject(env: StackDeps["env"], name: string): string;
 interface Flags {
     rest: string[];
@@ -55,7 +56,7 @@ export type StackTenant = Pick<HostTenant, "id" | "name" | "state" | "cause">;
 /** Printed by `start` when it does not open Studio itself. */
 export declare const STUDIO_SIGN_IN_HINT = "To sign a browser in to Studio, run \"npx nylorun studio\".";
 export interface StackStatus {
-    /** The stack's name. */
+    /** The Tenant's name. */
     name: string;
     /** The Compose project. */
     project: string;
@@ -64,16 +65,19 @@ export interface StackStatus {
     state: "running" | "stopped" | "absent";
     runtime: {
         url?: string;
-        /** The Admin API (operator listener), when the stack publishes one. */
+        /** The Admin API (operator listener), when the Tenant publishes one. */
         adminUrl?: string;
         healthy: boolean;
         version?: string;
         hostId?: string;
     };
-    /** The stack's one Tenant, while the Runtime answers. */
+    /** The Tenant as the Runtime reports it, while it answers. */
     tenant?: StackTenant;
     studio: {
+        /** Studio's own port: what an embedding app frames (same site as its own localhost). */
         url?: string;
+        /** Through the Studio proxy, when it serves the Tenant. */
+        proxyUrl?: string;
         state: string;
         /** Exact origins that may show Studio in a frame (Studio §8.9). */
         embedOrigins?: string[];
@@ -88,13 +92,15 @@ export interface StackStatus {
     };
     services: ComposeService[];
 }
+/** The Studio proxy, as data (`nylorun doctor`). */
+export declare function readProxyReport(deps: StackDeps): Promise<ProxyStatus>;
 /** What `nylorun status` reports, as data (`nylorun doctor`). */
 export declare function readStackStatus(deps: StackDeps, options?: {
     name?: string;
 }): Promise<StackStatus>;
-/** The running stack as clients reach it. */
+/** The running Tenant as clients reach it. */
 export interface StackEndpoints {
-    /** The stack's name. */
+    /** The Tenant's name. */
     name: string;
     /** The Host root. */
     home: string;
@@ -105,13 +111,15 @@ export interface StackEndpoints {
     hostId: string;
     adminKey: string;
     studioPort: number;
+    /** Through the proxy when it serves the Tenant, else Studio's own port. */
+    studioUrl: string;
     /** Studio is running and healthy. */
     studioUp: boolean;
     /** This call started the Runtime (it was not running before). */
     started: boolean;
 }
 /**
- * Start the selected stack unless it is already running (`nylorun studio`): the
+ * Start the selected Tenant unless it is already running (`nylorun studio`): the
  * `start` code path without its output, its Tenant wait or the Project link. Compose
  * progress still streams, since the first run pulls images.
  */
@@ -121,18 +129,18 @@ export declare function ensureStack(deps: StackDeps, options: {
 }): Promise<StackEndpoints>;
 /** Add Studio's `next` path (e.g. `/tenants/<id>`) to a login URL. */
 export declare function withNext(loginUrl: string, next: string | undefined): string;
-/** The Studio page of the stack's Tenant, as a login `next` path. */
+/** The Tenant's Studio page, as a login `next` path. */
 export declare function tenantStudioPath(tenantId: string): string;
 /**
- * Mint a fresh Studio login URL on a running stack, landing on `next`.
+ * Mint a fresh Studio login URL on a running Tenant, landing on `next`.
  * Undefined (after a warning) when Studio does not answer.
  */
-export declare function studioLoginUrl(deps: StackDeps, stack: Pick<StackEndpoints, "studioPort" | "adminKey">, next?: string): Promise<string | undefined>;
-/** `nylorun studio`, landing on `next` when given, else on the stack's Tenant. */
+export declare function studioLoginUrl(deps: StackDeps, running: Pick<StackEndpoints, "studioPort" | "studioUrl" | "adminKey">, next?: string): Promise<string | undefined>;
+/** `nylorun studio`, landing on `next` when given, else on the Tenant's page. */
 export declare function runStudioCommand(args: readonly string[], deps: StackDeps, options?: {
     next?: string;
 }): Promise<number>;
 export declare function isStackCommand(name: string | undefined): boolean;
-/** Run one stack command (`up`/`start`, `down`/`stop`, `status`, `logs`, `reset`, `studio`, `ls`, `delete`, `legacy`). */
+/** Run one Tenant command (`up`/`start`, `down`/`stop`, `status`, `logs`, `reset`, `studio`, `ls`, `delete`). */
 export declare function runStackCommand(name: string, args: readonly string[], deps: StackDeps): Promise<number>;
 export {};