nylorun 0.5.0-beta → 0.7.0-beta

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # nylorun
 
+## 0.7.0-beta
+
+### Minor Changes
+
+- 9af30d8: **The Studio proxy is removed, and Restate runs with its own memory defaults.** Each Tenant's Studio is at `http://localhost:<port>` again (`nylorun studio --tenant <name>` opens it signed in): its own session cookie already keeps it apart from other Studios, so the proxy only added a container and a second address. The 256 MiB RocksDB cap did not lower Restate's memory, so it is gone. The first command of this release removes the proxy that 0.6 started (`nylorun-proxy` and `~/.nylorun/proxy/`); `NYLORUN_PROXY_PORT`, `NYLORUN_PROXY_DISABLED`, `studio.proxyUrl` and Studio's `NYLORUN_STUDIO_PUBLIC_ORIGINS` are gone.
+
+### Patch Changes
+
+- Pin studio to the tested release.
+
+## 0.6.0-beta
+
+### Minor Changes
+
+- 0cbd5c9: **Breaking (`nylorun`): readable Docker names, several Tenants on one machine, and Studio at `http://<name>.localhost:4160`.** See MIGRATION.md.
+
+  - **Breaking (`nylorun`): names.** Every container, the network and every volume carries the Tenant's Compose project: containers `nylorun-<name>-postgres`, `-restate`, `-s2-lite`, `-gateway`, `-runtime`, `-studio` (were `…-1`), network `nylorun-<name>` (was `nylorun-<name>_default`), volumes `nylorun-<name>-postgres`, `-restate`, `-s2-lite`, `-workspaces` (were `nylorun-<name>_postgres`, …), each labelled `dev.nylorun.tenant: <name>`. The Compose service `s2` is now `s2-lite` (`nylorun logs s2-lite`).
+  - **Breaking (`nylorun`): Tenants created by 0.5 start fresh.** `start` on a Tenant whose data is in the old volumes exits 3 without starting it and names them; `nylorun reset --tenant <name>` starts it anew. `reset` and `delete` also remove the old volumes and the old network.
+  - **Studio proxy.** One Caddy container per machine (`nylorun-proxy`, files in `~/.nylorun/proxy/`) gives each Tenant's Studio the address `http://<name>.localhost:<port>` (`NYLORUN_PROXY_PORT`, 4160 or a free port chosen once), on `127.0.0.1` and `[::1]` (IPv4 only, saying so, when Docker refuses `::1`). It holds no Tenant data and routes browsers only. `start` brings it up when Studio starts, prints Studio's proxy URL and signs in there (on Studio's own port when the proxy does not answer); a proxy failure never fails `start`. `status` shows both URLs, `ls` and `nylorun studio` the proxy's. `NYLORUN_PROXY_DISABLED=1` turns it off; a Tenant under `NYLORUN_HOME` or `NYLORUN_COMPOSE_PROJECT` does not use it. `doctor` has a `proxy` row.
+  - **Several Tenants.** Restate's RocksDB memory is capped at 256 MiB, so a Tenant uses about 600–700 MB (was about 1.3 GB). `nylorun ls` has a `MEMORY` column (`memoryBytes` in `--json`). `start` names the other running Tenants and their memory. `nylorun stop --all` stops every running Tenant and the proxy, keeping their volumes.
+  - **`@nylorun/studio`.** `NYLORUN_STUDIO_PUBLIC_ORIGINS` lists exact `http:` origins Studio also serves (Host and `Origin` checks); a login token's URL is on the origin it was minted on; `NYLORUN_STUDIO_SESSION_COOKIE` names the session cookie (default `nylorun_studio_session`; `nylorun` sets `nylorun_studio_<name>`, so Studios on one host keep their own sessions); the `421` answer lists the served origins.
+
+### Patch Changes
+
+- Pin runtime to the tested release.
+- Pin studio to the tested release.
+
 ## 0.5.0-beta
 
 ### Minor Changes

package/README.md

@@ -36,12 +36,12 @@ npx nylorun doctor                 # Node 24+, Docker, Compose v2, and the Tenan
 ```sh
 nylorun up|start [--tenant <name>] [--no-link] [--no-studio] [--no-open] [--allow-downgrade] [--studio-embed-origin <origin>]... [--studio-embed-origin-reset]
                                    # create (first run) and start the Tenant; link the project; print the URLs; open Studio signed in
-nylorun down|stop [--tenant <name>]   # stop the containers; keep volumes
+nylorun down|stop [--tenant <name> | --all]   # stop the containers (--all: every Tenant's); keep volumes
 nylorun status [--tenant <name>] [--json]   # the Tenant, its Host root and id, services, endpoints, Runtime health
-nylorun logs [service] [--tenant <name>] [-f] [--tail <n>]   # postgres, restate, s2, gateway, runtime, studio
+nylorun logs [service] [--tenant <name>] [-f] [--tail <n>]   # postgres, restate, s2-lite, gateway, runtime, studio
 nylorun studio [--tenant <name>] [--no-open]   # sign a browser in to Studio on the Tenant; starts it if needed
 nylorun reset [--tenant <name>] [--yes]        # delete the Tenant's volumes, Tenant directory and vault key; the next start creates it anew
-nylorun ls [--json]                # the Tenants on this machine
+nylorun ls [--json]                # the Tenants on this machine, with their state, memory and URLs
 nylorun delete <tenant> --yes      # remove a Tenant: containers, volumes, Host root and vault key
 nylorun doctor [--json]            # prerequisites and the Tenant's health
 nylorun telemetry [status|enable|disable]   # Studio's anonymous usage analytics
@@ -78,6 +78,42 @@ name). nylorun 0.4 kept Host roots in `~/.nylorun/stacks/`: the first command
 of this release moves them to `~/.nylorun/tenants/`, keeping their Compose
 projects and volumes.
 
+### Several Tenants
+
+Tenants run side by side, each on its own ports, containers, network and
+volumes ([The containers](#the-containers)); a running Tenant uses about
+1.2 GB. Each Studio is on its own port, `http://localhost:<port>`, with its own
+session cookie, so two Studios in one browser stay signed in;
+`nylorun studio --tenant <name>` opens any Tenant's Studio signed in. `nylorun ls`
+lists them with their state, the memory their containers use (`MEMORY`: the sum
+of `docker stats` over the containers labelled `dev.nylorun.tenant=<name>`, `-`
+when stopped; `memoryBytes` in `--json`, `null` when stopped or unknown), the
+Runtime's URL and Studio's:
+
+```text
+TENANT   STATE    MEMORY  RUNTIME                STUDIO                 PROJECT
+api      running  1.2 GB  http://localhost:8790  http://localhost:4162  /Users/me/api
+default  stopped  -       http://localhost:8787  http://localhost:4161  -
+```
+
+When other Tenants are running, `start` says so after its summary, on stderr
+(without the size when Docker does not report it):
+
+```text
+Also running: default, api (about 2.4 GB). "nylorun stop --all" stops them all.
+```
+
+`nylorun stop --all` stops every running Tenant on this machine, keeping their
+volumes; it cannot be combined with `--tenant` (exit 2).
+
+A Tenant created by nylorun 0.5 keeps its data in volumes Compose named
+`<project>_postgres`, `<project>_restate`, `<project>_s2` and
+`<project>_workspaces`; this release names them `<project>-postgres`, … (see
+[The containers](#the-containers)). `start` on such a Tenant exits 3 without
+starting it, naming the old volumes: run `nylorun reset --tenant <name>` to
+start it fresh. `reset` and `delete` also remove the old volumes (and the old
+network `<project>_default`).
+
 A Tenant refuses only a Runtime older than its own database: `start` records
 the pinned Runtime version in `host.json` (`runtimeVersion`) and exits 5 when
 this nylorun pins an older one. Update nylorun, or pass `--allow-downgrade`
@@ -119,9 +155,21 @@ The Runtime registers the derived principals of `NYLORUN_DERIVED_PRINCIPALS`
 ## The containers
 
 `nylorun start` writes `compose.yaml` and `.env` (mode 0600) under
-`~/.nylorun/tenants/<name>/docker/` on the first run and reuses them after that: `postgres`,
-`restate`, `s2`, `gateway`, `runtime` and `studio`. Postgres initialises the
-Tenant's database with C collation. The Runtime and Studio images are pinned by
+`~/.nylorun/tenants/<name>/docker/` on every start; `.env` keeps the ports and
+secrets chosen on the first run. The services are `postgres`, `restate`,
+`s2-lite`, `gateway`, `runtime` and `studio`. Container, network and volume
+names are global on the Docker engine, so each carries the Tenant's Compose
+project, and each has the label `dev.nylorun.tenant: <name>`. For Tenant `shop`:
+
+| Thing | Name |
+| --- | --- |
+| Containers | `nylorun-shop-postgres`, `nylorun-shop-restate`, `nylorun-shop-s2-lite`, `nylorun-shop-gateway`, `nylorun-shop-runtime`, `nylorun-shop-studio` |
+| Network | `nylorun-shop` |
+| Volumes | `nylorun-shop-postgres`, `nylorun-shop-restate`, `nylorun-shop-s2-lite`, `nylorun-shop-workspaces` |
+
+Postgres initialises the Tenant's database with C collation. Restate runs with
+its own defaults. A running Tenant uses about 1.2 GB, most of it Restate; stop
+the Tenants you are not using (`nylorun stop`, or `nylorun stop --all`). The Runtime and Studio images are pinned by
 this release (`package.json` `nylorun.runtime` and `nylorun.studio`);
 `NYLORUN_RUNTIME_IMAGE` and `NYLORUN_STUDIO_IMAGE` override them (local builds,
 CI). Ports publish on loopback only: the Runtime on `8787`, its operator
@@ -129,15 +177,21 @@ listener (Admin API) on `8788`, Studio on `4161` and the Restate UI on `9070`,
 or free ports chosen on the Tenant's first start, avoiding the ports other
 Tenants keep, and kept in its `.env`.
 
-`start` prints Studio as `http://localhost:<port>`. Studio has no password: in a
-terminal (not in CI, and not with `--no-open`), `start` asks the Studio container
-for a single-use login token with the admin key (`POST /_studio/login-tokens`)
-and opens `http://localhost:<port>/login?token=…` on the Tenant's page in the
-browser. That sets a session cookie for 30 days, which survives Studio
-restarts, so the printed URL keeps working in that browser. The token itself is
-never printed unless no browser starts. Otherwise `start` says to run `nylorun
-studio`, which signs a browser in the same way; `nylorun studio --no-open`
-prints the login URL (it works once, for two minutes) instead.
+`start`, `status`, `ls` and `nylorun studio` give Studio as
+`http://localhost:<port>` (`studio.url` in `status --json`). Studio has no
+password: in a terminal (not in CI, and not with `--no-open`), `start` asks the
+Studio container for a single-use login token with the admin key (`POST
+/_studio/login-tokens`) and opens `http://localhost:<port>/login?token=…` on the
+Tenant's page in the browser. That sets a session cookie for 30 days, which
+survives Studio restarts, so the printed URL keeps working in that browser. The
+token itself is never printed unless no browser starts. Otherwise `start` says
+to run `nylorun studio`, which signs a browser in the same way; `nylorun studio
+--no-open` prints the login URL (it works once, for two minutes) instead.
+
+Browsers share cookies across the ports of one host, so each Tenant's Studio
+sets its own session cookie, `nylorun_studio_<name>`
+(`NYLORUN_STUDIO_SESSION_COOKIE`): signing in to one Studio does not sign you
+out of another.
 
 ### Embedding Studio in a desktop app
 
@@ -201,7 +255,7 @@ containers, volumes and Host root: the vault key (KEK) and all its data go with
 | 0 | Success |
 | 1 | Generic failure, including a missing Docker or Compose v2 |
 | 2 | Usage error (including no Tenant selected, or `delete` without `--yes`), or a removed or moved command |
-| 3 | `status`: the Runtime is not answering; `stop`/`logs`: no Tenant yet; `delete`: no such Tenant |
+| 3 | `status`: the Runtime is not answering; `stop`/`logs`: no Tenant yet; `delete`: no such Tenant; `start`: a Tenant created by nylorun 0.5 (reset it) |
 | 4 | The Runtime port is held by another Host |
 | 5 | `up`/`start`/`studio`: this nylorun pins a Runtime older than the one that last ran the Tenant; update nylorun, or `start --allow-downgrade` |
 | 7 | The containers, the Tenant or Studio did not become ready (an unavailable Tenant's cause is printed) |
@@ -218,5 +272,7 @@ containers, volumes and Host root: the vault key (KEK) and all its data go with
 | Port conflict | Change `NYLORUN_PORT` / `NYLORUN_STUDIO_PORT` in `~/.nylorun/tenants/<name>/docker/.env` |
 | Logs | `nylorun logs runtime -f` |
 | Studio login expired | `nylorun studio` |
+| Which Studio is which | `nylorun ls` lists each Tenant's Studio URL; `nylorun studio --tenant <name>` opens one signed in |
+| `Tenant … was created by nylorun 0.5` (exit 3) | `nylorun reset --tenant <name>` (its data starts fresh) |
 
 See [MIGRATION.md](../MIGRATION.md).

package/dist/stack/commands.d.ts

@@ -2,7 +2,7 @@ import type { HostTenant } from "@nylorun/core/contracts";
 import { type ComposeService, type DockerRunner } from "./docker.js";
 import type { PortProbe } from "./ports.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_TENANT, image overrides, NYLORUN_COMPOSE_PROJECT). */
@@ -73,6 +73,7 @@ export interface StackStatus {
     /** The Tenant as the Runtime reports it, while it answers. */
     tenant?: StackTenant;
     studio: {
+        /** `http://localhost:<port>`: also what an embedding app frames (same site as its own localhost). */
         url?: string;
         state: string;
         /** Exact origins that may show Studio in a frame (Studio §8.9). */
@@ -105,6 +106,8 @@ export interface StackEndpoints {
     hostId: string;
     adminKey: string;
     studioPort: number;
+    /** `http://localhost:<studio port>` */
+    studioUrl: string;
     /** Studio is running and healthy. */
     studioUp: boolean;
     /** This call started the Runtime (it was not running before). */

package/dist/stack/commands.js

@@ -8,28 +8,28 @@ import { readProjectCredentials, readProjectLink, writeProjectCredentials, write
 import { findProjectRoot } from "../project/root.js";
 import { seedTenant } from "../project/seed.js";
 import { readTelemetry, STUDIO_ANALYTICS_ID, TELEMETRY_NOTICE, telemetryDecision, writeTelemetry, } from "../telemetry.js";
-import { dockerPreflight, parseComposePs, } from "./docker.js";
+import { dockerPreflight, formatBytes, parseComposePs, tenantMemory, } from "./docker.js";
 import { readAdminKey, readHostConfig, STACK_CLIENT_HOST } from "./host-files.js";
 import { runtimeImageOverridden, stackImages } from "./images.js";
 import { stackPaths } from "./paths.js";
 import { prepareStack, readStackEnv } from "./prepare.js";
-import { assertTenantName, chooseTenantName, DEFAULT_TENANT, defaultNylorunRoot, listTenants, moveStackRoots, readTenantRecord, sanitizeTenantName, tenantRoot, tenantsDir, writeTenantRecord, } from "./stacks.js";
+import { assertTenantName, chooseTenantName, DEFAULT_TENANT, defaultNylorunRoot, listTenants, moveStackRoots, readTenantRecord, removeOldProxy, sanitizeTenantName, tenantRoot, tenantsDir, writeTenantRecord, } from "./stacks.js";
 import { mintStudioLogin, studioOrigin } from "./studio-login.js";
-export const STACK_SERVICES = ["postgres", "restate", "s2", "gateway", "runtime", "studio"];
-const CORE_SERVICES = ["postgres", "restate", "s2", "gateway", "runtime"];
+export const STACK_SERVICES = ["postgres", "restate", "s2-lite", "gateway", "runtime", "studio"];
+const CORE_SERVICES = ["postgres", "restate", "s2-lite", "gateway", "runtime"];
 export const stackUsage = `  up|start [--tenant <name>] [--no-link] [--no-studio] [--no-open] [--allow-downgrade] [--studio-embed-origin <origin>]... [--studio-embed-origin-reset]
                                       start the project's Tenant, creating it and the Project link (.nylorun/link.json,
                                       credentials.json) on the first run; print the Runtime and Studio URLs and open Studio
                                       signed in (in a terminal). --tenant attaches to (or creates) a named Tenant; --no-link
                                       starts the default Tenant (or --tenant's) without linking the current directory
-  down|stop [--tenant <name>]         stop the Tenant's containers; keep volumes
+  down|stop [--tenant <name> | --all] stop the Tenant's containers (--all: every Tenant's); keep volumes
   status [--tenant <name>] [--json]   the Tenant, its id, services, endpoints and Runtime health
   logs [service] [--tenant <name>] [-f] [--tail <n>]
                                       container logs (${STACK_SERVICES.join(", ")})
   studio [--tenant <name>] [--no-open]
                                       sign a browser in to Studio on the Tenant; --no-open prints the login URL; start the Tenant if it is stopped
   reset [--tenant <name>] [--yes]     delete the Tenant's data (volumes, tenant/ and vault key); the next start creates it anew
-  ls [--json]                         the Tenants on this machine
+  ls [--json]                         the Tenants on this machine, with their memory in use
   delete <tenant> --yes               remove a Tenant: containers, volumes and its Host root, with the vault key (KEK)`;
 const usageError = (message) => new CliError(message, 2);
 /** The Compose project of Tenant `name`: `nylorun-<name>`, or `NYLORUN_COMPOSE_PROJECT`. */
@@ -42,6 +42,38 @@ export function stackProject(env, name) {
 function nylorunRoot(deps) {
     return deps.nylorunRoot ?? defaultNylorunRoot();
 }
+/** Before every Tenant command: move 0.4's Host roots, remove 0.6's Studio proxy. */
+async function tidyMachine(deps) {
+    const base = nylorunRoot(deps);
+    await moveStackRoots(base, deps.err);
+    await removeOldProxy(deps.docker, base, deps.err);
+}
+/**
+ * Compose's names for a 0.5 Tenant's volumes (`<project>_postgres`, …) that exist on this
+ * engine, and whether this release's `<project>-postgres` does.
+ */
+async function oldVolumes(docker, project) {
+    const result = await docker.run(["volume", "ls", "--quiet", "--filter", `name=${project}`]);
+    const names = new Set(result.code === 0 ? result.stdout.split(/\s+/) : []);
+    return {
+        old: ["postgres", "restate", "s2", "workspaces"]
+            .map((volume) => `${project}_${volume}`)
+            .filter((name) => names.has(name)),
+        current: names.has(`${project}-postgres`),
+    };
+}
+/** `docker compose down` (`reset`, `delete`), then drop a 0.5 Tenant's volumes and network. */
+async function composeDown(ctx, args) {
+    const { docker } = ctx.deps;
+    const code = await docker.stream(args);
+    if (code !== 0)
+        throw new CliError(`docker compose down failed (exit ${code}).`, 1);
+    const { old } = await oldVolumes(docker, ctx.project);
+    if (old.length) {
+        await docker.run(["volume", "rm", ...old]);
+        await docker.run(["network", "rm", `${ctx.project}_default`]);
+    }
+}
 async function tenantNames(deps) {
     const names = (await listTenants(nylorunRoot(deps))).map((tenant) => tenant.name);
     return names.length ? ` Tenants on this machine: ${names.join(", ")}.` : "";
@@ -285,10 +317,10 @@ async function refuseDowngrade(ctx, allowDowngrade) {
     }
     throw new CliError(`Refusing to start Runtime ${pinned} on Tenant ${ctx.name}: Runtime ${host.runtimeVersion} last ran it (${ctx.paths.config}), and a Runtime older than the Tenant's database cannot open its Tenant. Update nylorun (npx nylorun@latest start), or run "nylorun start --allow-downgrade" when both Runtimes use the same database schema.`, 5);
 }
-/** Ports other Tenants keep in their `.env`, so a new Tenant avoids them. */
-async function reservedPorts(ctx) {
-    const others = (await listTenants(nylorunRoot(ctx.deps)))
-        .filter((tenant) => resolve(tenant.root) !== ctx.paths.root)
+/** Ports the Tenants on this machine keep in their `.env` (but the one under `except`). */
+async function tenantPorts(base, except) {
+    const others = (await listTenants(base))
+        .filter((tenant) => resolve(tenant.root) !== except)
         .map((tenant) => stackPaths(tenant.root));
     const reserved = new Set();
     for (const paths of others) {
@@ -304,13 +336,21 @@ async function reservedPorts(ctx) {
     }
     return reserved;
 }
+/** Ports other Tenants keep, so a new Tenant avoids them. */
+async function reservedPorts(ctx) {
+    return await tenantPorts(nylorunRoot(ctx.deps), ctx.paths.root);
+}
 async function bringUp(ctx, options) {
     const { deps } = ctx;
     await refuseLauncherRuntime(ctx);
     const overridden = runtimeImageOverridden(deps.env);
     if (!overridden)
         await refuseDowngrade(ctx, options.allowDowngrade ?? false);
-    const telemetry = await readTelemetry(nylorunRoot(deps));
+    const legacy = await oldVolumes(deps.docker, ctx.project);
+    if (legacy.old.length && !legacy.current)
+        throw new CliError(`Tenant ${ctx.name} was created by nylorun 0.5; its data is in the old volumes ${legacy.old.join(", ")}. Run "nylorun reset --tenant ${ctx.name}" to start it fresh; that also removes the old volumes (or drop them yourself with "docker volume rm ${legacy.old.join(" ")}").`, 3);
+    const base = nylorunRoot(deps);
+    const telemetry = await readTelemetry(base);
     const analytics = telemetryDecision(deps.env, telemetry).enabled;
     const prepared = await prepareStack({
         paths: ctx.paths,
@@ -365,25 +405,30 @@ async function bringUp(ctx, options) {
         adminUrl,
         hostId: prepared.host.hostId,
         studioPort: prepared.env.studioPort,
+        studioUrl: studioOrigin(prepared.env.studioPort),
         studioStarted,
         adminKey: prepared.adminKey,
     };
 }
+const errorText = (error) => (error instanceof Error ? error.message : String(error));
+/** A login URL on Studio's own port, retried while it starts. */
 async function tryStudioLogin(ctx, studioPort, adminKey) {
-    const deadline = Date.now() + (ctx.deps.loginTimeoutMs ?? 15_000);
+    const { deps } = ctx;
+    const origin = studioOrigin(studioPort);
+    const deadline = Date.now() + (deps.loginTimeoutMs ?? 15_000);
     let lastError = "";
     for (;;) {
         try {
-            return await mintStudioLogin({ fetch: ctx.deps.fetch, studioPort, adminKey });
+            return await mintStudioLogin({ fetch: deps.fetch, origin, adminKey });
         }
         catch (error) {
-            lastError = error instanceof Error ? error.message : String(error);
+            lastError = errorText(error);
         }
         if (Date.now() > deadline)
             break;
-        await sleep(ctx.deps.pollMs ?? 500);
+        await sleep(deps.pollMs ?? 500);
     }
-    ctx.deps.err(`Warning: Studio at ${studioOrigin(studioPort)} is not reachable for a login (${lastError}).`);
+    deps.err(`Warning: Studio at ${origin} is not reachable for a login (${lastError}).`);
     return undefined;
 }
 /** Printed by `start` when it does not open Studio itself. */
@@ -483,7 +528,7 @@ async function start(deps, args) {
     deps.out(`Tenant    ${ctx.name}  (${tenant.id})`);
     deps.out(`Runtime   ${started.runtimeUrl}`);
     if (started.studioStarted) {
-        deps.out(`Studio    ${studioOrigin(started.studioPort)}`);
+        deps.out(`Studio    ${started.studioUrl}`);
         if (opensBrowser(deps, flags)) {
             const login = await tryStudioLogin(ctx, started.studioPort, started.adminKey);
             if (login)
@@ -492,13 +537,37 @@ async function start(deps, args) {
         else
             deps.err(STUDIO_SIGN_IN_HINT);
     }
+    await alsoRunning(ctx);
     return 0;
 }
+/** After `start`: the machine's other running Tenants and their memory, on stderr. */
+async function alsoRunning(ctx) {
+    const { deps } = ctx;
+    const projects = await composeProjects(deps.docker);
+    if (!projects)
+        return;
+    const others = (await listTenants(nylorunRoot(deps)))
+        .map((tenant) => tenant.name)
+        .filter((name) => name !== ctx.name && projects.get(`nylorun-${name}`) === "running");
+    if (others.length === 0)
+        return;
+    const memory = await tenantMemory(deps.docker);
+    const sizes = others.map((name) => memory?.get(name));
+    const total = sizes.every((size) => size !== undefined)
+        ? sizes.reduce((sum, size) => sum + size, 0)
+        : undefined;
+    deps.err(`Also running: ${others.join(", ")}${total === undefined ? "" : ` (about ${formatBytes(total)})`}. "nylorun stop --all" stops them all.`);
+}
 async function stop(deps, args) {
-    const usage = "nylorun stop [--tenant <name>]";
-    const flags = parseStackFlags(args, { values: ["--tenant"] }, usage);
+    const usage = "nylorun stop [--tenant <name> | --all]";
+    const flags = parseStackFlags(args, { booleans: ["--all"], values: ["--tenant"] }, usage);
     if (flags.rest.length)
         throw usageError(`Usage: ${usage}`);
+    if (flags.booleans.has("--all")) {
+        if (flags.values.has("--tenant"))
+            throw usageError(`--all and --tenant are exclusive. Usage: ${usage}`);
+        return await stopAll(deps);
+    }
     const ctx = await selectStack(deps, nameOption(flags));
     requireStackFiles(ctx);
     await dockerPreflight(deps.docker);
@@ -508,6 +577,28 @@ async function stop(deps, args) {
     deps.out(`Stopped Tenant ${ctx.name}; its data is kept.`);
     return 0;
 }
+/** `stop --all`: every running Tenant on this machine; volumes are kept. */
+async function stopAll(deps) {
+    await dockerPreflight(deps.docker);
+    const projects = (await composeProjects(deps.docker)) ?? new Map();
+    const stopped = [];
+    for (const tenant of await listTenants(nylorunRoot(deps))) {
+        const project = `nylorun-${tenant.name}`;
+        if (projects.get(project) !== "running")
+            continue;
+        const paths = stackPaths(tenant.root);
+        const code = await deps.docker.stream(existsSync(paths.compose) && existsSync(paths.env)
+            ? composeArgs({ project, paths }, "stop")
+            : ["compose", "--project-name", project, "stop"]);
+        if (code !== 0)
+            throw new CliError(`docker compose stop failed for Tenant ${tenant.name} (exit ${code}).`, 1);
+        stopped.push(tenant.name);
+    }
+    deps.out(stopped.length
+        ? `Stopped Tenants ${stopped.join(", ")}; their data is kept.`
+        : "No Tenant was running.");
+    return 0;
+}
 async function stackStatus(ctx) {
     const base = {
         name: ctx.name,
@@ -570,7 +661,7 @@ async function stackStatus(ctx) {
 }
 /** What `nylorun status` reports, as data (`nylorun doctor`). */
 export async function readStackStatus(deps, options = {}) {
-    await moveStackRoots(nylorunRoot(deps), deps.err);
+    await tidyMachine(deps);
     return await stackStatus(await selectStack(deps, options));
 }
 function describeTenant(tenant) {
@@ -655,9 +746,7 @@ async function reset(deps, args) {
     }
     if (existsSync(paths.compose) && existsSync(paths.env)) {
         await dockerPreflight(deps.docker);
-        const code = await deps.docker.stream(composeArgs(ctx, "down", "--volumes", "--remove-orphans"));
-        if (code !== 0)
-            throw new CliError(`docker compose down failed (exit ${code}).`, 1);
+        await composeDown(ctx, composeArgs(ctx, "down", "--volumes", "--remove-orphans"));
     }
     await rm(paths.tenant, { recursive: true, force: true });
     await mkdir(paths.tenant, { recursive: true, mode: 0o700 });
@@ -691,14 +780,19 @@ async function ls(deps, args) {
     const base = nylorunRoot(deps);
     const projects = await composeProjects(deps.docker);
     const state = (project) => (projects ? (projects.get(project) ?? "stopped") : "unknown");
+    const memory = [...(projects?.values() ?? [])].includes("running")
+        ? await tenantMemory(deps.docker)
+        : undefined;
     const tenants = [];
     for (const entry of await listTenants(base)) {
         const persisted = (await readStackEnv(stackPaths(entry.root))) ?? {};
+        const tenantState = state(`nylorun-${entry.name}`);
         tenants.push({
             name: entry.name,
             root: entry.root,
             ...(entry.record.project ? { project: entry.record.project } : {}),
-            state: state(`nylorun-${entry.name}`),
+            state: tenantState,
+            memoryBytes: (tenantState === "running" && memory?.get(entry.name)) || null,
             ...(persisted.runtimePort
                 ? { runtimeUrl: `http://${STACK_CLIENT_HOST}:${persisted.runtimePort}` }
                 : {}),
@@ -719,10 +813,20 @@ async function ls(deps, args) {
         deps.out('No Tenants on this machine. Run "npx nylorun start" in a project (or anywhere, for the default Tenant).');
         return 0;
     }
-    const width = Math.max(6, ...tenants.map((tenant) => tenant.name.length)) + 2;
-    deps.out(`${"TENANT".padEnd(width)}${"STATE".padEnd(9)}${"RUNTIME".padEnd(24)}${"STUDIO".padEnd(24)}PROJECT`);
-    for (const tenant of tenants)
-        deps.out(`${tenant.name.padEnd(width)}${tenant.state.padEnd(9)}${(tenant.runtimeUrl ?? "-").padEnd(24)}${(tenant.studioUrl ?? "-").padEnd(24)}${tenant.project ?? "-"}`);
+    const rows = [
+        ["TENANT", "STATE", "MEMORY", "RUNTIME", "STUDIO", "PROJECT"],
+        ...tenants.map((tenant) => [
+            tenant.name,
+            tenant.state,
+            tenant.memoryBytes === null ? "-" : formatBytes(tenant.memoryBytes),
+            tenant.runtimeUrl ?? "-",
+            tenant.studioUrl ?? "-",
+            tenant.project ?? "-",
+        ]),
+    ];
+    const widths = rows[0].map((_, column) => Math.max(...rows.map((row) => row[column].length)) + 2);
+    for (const row of rows)
+        deps.out(row.map((cell, column) => (column < row.length - 1 ? cell.padEnd(widths[column]) : cell)).join(""));
     return 0;
 }
 async function deleteStack(deps, args) {
@@ -740,11 +844,9 @@ async function deleteStack(deps, args) {
         throw usageError(`nylorun delete removes Tenant ${name}: its containers, volumes and Host root ${ctx.paths.root}, with its vault key (KEK) and all its data. This cannot be undone; pass --yes to confirm.`);
     await dockerPreflight(deps.docker);
     const files = existsSync(ctx.paths.compose) && existsSync(ctx.paths.env);
-    const code = await deps.docker.stream(files
+    await composeDown(ctx, files
         ? composeArgs(ctx, "down", "--volumes", "--remove-orphans")
         : ["compose", "--project-name", ctx.project, "down", "--volumes", "--remove-orphans"]);
-    if (code !== 0)
-        throw new CliError(`docker compose down failed (exit ${code}).`, 1);
     await rm(ctx.paths.root, { recursive: true, force: true });
     deps.out(`Deleted Tenant ${name}: its containers, volumes and Host root (vault key included).`);
     return 0;
@@ -780,6 +882,7 @@ async function runningStack(ctx, options) {
         hostId: host.hostId,
         adminKey,
         studioPort: persisted.studioPort,
+        studioUrl: studioOrigin(persisted.studioPort),
         studioUp,
         started: false,
     };
@@ -799,6 +902,7 @@ async function ensureSelected(ctx, options) {
         hostId: started.hostId,
         adminKey: started.adminKey,
         studioPort: started.studioPort,
+        studioUrl: started.studioUrl,
         studioUp: started.studioStarted,
         started: !runtimeWasUp,
     };
@@ -858,14 +962,14 @@ async function studio(deps, args, options = {}) {
         deps.out(`Studio    ${login}`);
         return 0;
     }
-    const origin = studioOrigin(running.studioPort);
+    const origin = new URL(login).origin;
     deps.out(`Studio    ${next ? new URL(next, origin).toString() : origin}`);
     await openLogin({ deps }, login);
     return 0;
 }
 /** `nylorun studio`, landing on `next` when given, else on the Tenant's page. */
 export async function runStudioCommand(args, deps, options = {}) {
-    await moveStackRoots(nylorunRoot(deps), deps.err);
+    await tidyMachine(deps);
     return await studio(deps, args, options);
 }
 const COMMANDS = {
@@ -889,6 +993,6 @@ export async function runStackCommand(name, args, deps) {
     const command = COMMANDS[name];
     if (!command)
         throw usageError(`Unknown command ${name}.\n${stackUsage}`);
-    await moveStackRoots(nylorunRoot(deps), deps.err);
+    await tidyMachine(deps);
     return await command(deps, args);
 }

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

@@ -2,8 +2,11 @@
  * A local Tenant's Compose file (Runtime Architecture §14.3), written to
  * `<Host root>/docker/compose.yaml` by `nylorun start`. Each local Tenant is one installation
  * (tenancy.md §6): its own Compose project (`nylorun-<name>`, the file's `name`), volumes,
- * network and ports. Everything else that varies (ports, the Postgres password, UID/GID, the
- * Host root, the images, the Tenant's name) comes from `docker/.env`.
+ * network and ports. Container, network and volume names are global on the Docker engine, so
+ * every one is `<project>-<role>` (`nylorun-shop-studio`, network `nylorun-shop`, volume
+ * `nylorun-shop-postgres`), labelled `dev.nylorun.tenant: <name>`; they are written here, from
+ * the project and the Tenant's name. Everything else that varies (ports, the Postgres password,
+ * UID/GID, the Host root, the images) comes from `docker/.env`.
  *
  * The Tenant's state is its Postgres database, executed through Restate, with its
  * history in s2-lite; the Runtime's /ready checks all three. Postgres initialises the
@@ -33,4 +36,4 @@
  * it is down, model and MCP calls fail, deliveries are retried, vault writes and
  * token minting answer 503, and the session takes the next message.
  */
-export declare function renderComposeFile(project: string): string;
+export declare function renderComposeFile(project: string, name: string): string;

package/dist/stack/compose-file.js

@@ -3,8 +3,11 @@ import { PINNED_IMAGES } from "./images.js";
  * A local Tenant's Compose file (Runtime Architecture §14.3), written to
  * `<Host root>/docker/compose.yaml` by `nylorun start`. Each local Tenant is one installation
  * (tenancy.md §6): its own Compose project (`nylorun-<name>`, the file's `name`), volumes,
- * network and ports. Everything else that varies (ports, the Postgres password, UID/GID, the
- * Host root, the images, the Tenant's name) comes from `docker/.env`.
+ * network and ports. Container, network and volume names are global on the Docker engine, so
+ * every one is `<project>-<role>` (`nylorun-shop-studio`, network `nylorun-shop`, volume
+ * `nylorun-shop-postgres`), labelled `dev.nylorun.tenant: <name>`; they are written here, from
+ * the project and the Tenant's name. Everything else that varies (ports, the Postgres password,
+ * UID/GID, the Host root, the images) comes from `docker/.env`.
  *
  * The Tenant's state is its Postgres database, executed through Restate, with its
  * history in s2-lite; the Runtime's /ready checks all three. Postgres initialises the
@@ -34,13 +37,18 @@ import { PINNED_IMAGES } from "./images.js";
  * it is down, model and MCP calls fail, deliveries are retried, vault writes and
  * token minting answer 503, and the session takes the next message.
  */
-export function renderComposeFile(project) {
+export function renderComposeFile(project, name) {
     return `# Written by \`nylorun start\`; rewritten on every start. Settings live in .env.
 name: ${project}
 
+x-tenant: &tenant
+  dev.nylorun.tenant: "${name}"
+
 services:
   postgres: # Session Store
     image: ${PINNED_IMAGES.postgres}
+    container_name: ${project}-postgres
+    labels: *tenant
     # Logical replication feeds the stream relay; a stuck slot is capped at 4 GB of WAL.
     command: ["postgres", "-c", "wal_level=logical", "-c", "max_slot_wal_keep_size=4GB"]
     environment:
@@ -59,6 +67,8 @@ services:
 
   restate: # Durable Session Execution
     image: ${PINNED_IMAGES.restate}
+    container_name: ${project}-restate
+    labels: *tenant
     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
@@ -74,20 +84,24 @@ services:
       retries: 30
     restart: unless-stopped
 
-  s2: # Durable Streams; not published, only the Runtime reaches it
+  s2-lite: # Durable Streams; not published, only the Runtime reaches it
     image: ${PINNED_IMAGES.s2}
+    container_name: ${project}-s2-lite
+    labels: *tenant
     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
+      - s2-lite:/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
 
   gateway: # the Model and Tool Gates and keys: the vault key, credentials, signing, outbound calls; not published
     image: \${NYLORUN_RUNTIME_IMAGE:?run nylorun start}
+    container_name: ${project}-gateway
+    labels: *tenant
     command: ["--service", "gates,keys"]
     user: "\${NYLORUN_UID:?run nylorun start}:\${NYLORUN_GID:?run nylorun start}"
     depends_on:
@@ -116,12 +130,14 @@ services:
 
   runtime:
     image: \${NYLORUN_RUNTIME_IMAGE:?run nylorun start}
+    container_name: ${project}-runtime
+    labels: *tenant
     command: ["--service", "core,loop"]
     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 }
+      s2-lite: { condition: service_started }
     environment:
       NYLORUN_HOME: /nylorun
       NYLORUN_PACKING: combined
@@ -149,7 +165,7 @@ services:
       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_ENDPOINT: http://s2-lite:80
       NYLORUN_S2_TOKEN: ignored # s2-lite has no access tokens yet
       NYLORUN_WORKSPACE_STORE_URL: file:///workspaces
       # Action endpoints on this machine: \`localhost\` in a registered URL means the Docker host.
@@ -181,6 +197,8 @@ services:
 
   studio: # dashboard + trusted proxy
     image: \${NYLORUN_STUDIO_IMAGE:?run nylorun start}
+    container_name: ${project}-studio
+    labels: *tenant
     user: "\${NYLORUN_UID}:\${NYLORUN_GID}" # reads the 0600 admin key file
     depends_on:
       runtime: { condition: service_healthy }
@@ -190,6 +208,9 @@ services:
       PORT: "3000"
       # Studio's Host check accepts localhost/127.0.0.1 on the published port.
       NYLORUN_STUDIO_PUBLIC_PORT: \${NYLORUN_STUDIO_PORT}
+      # Browsers share cookies across ports of one host: a cookie per Tenant keeps the
+      # sessions of two Studios on localhost apart.
+      NYLORUN_STUDIO_SESSION_COOKIE: nylorun_studio_${name}
       # Exact origins that may frame Studio (Babai Desktop); kept in .env.
       NYLORUN_STUDIO_FRAME_ANCESTORS: \${NYLORUN_STUDIO_FRAME_ANCESTORS:-}
       # Studio's anonymous usage analytics; empty when telemetry is off.
@@ -205,10 +226,15 @@ services:
       retries: 30
     restart: unless-stopped
 
+networks:
+  default:
+    name: ${project}
+    labels: *tenant
+
 volumes:
-  postgres: {}
-  restate: {}
-  s2: {}
-  workspaces: {}
+  postgres: { name: ${project}-postgres, labels: *tenant }
+  restate: { name: ${project}-restate, labels: *tenant }
+  s2-lite: { name: ${project}-s2-lite, labels: *tenant }
+  workspaces: { name: ${project}-workspaces, labels: *tenant }
 `;
 }

package/dist/stack/docker.d.ts

@@ -36,3 +36,13 @@ export interface ComposeService {
 }
 /** Parse `docker compose ps --format json` (a JSON array, or one object per line). */
 export declare function parseComposePs(stdout: string): ComposeService[];
+/** `123.4MiB` (from `docker stats` MemUsage) in bytes; undefined when unreadable. */
+export declare function parseByteSize(text: string): number | undefined;
+/** `812 MB`, `2.1 GB`. */
+export declare function formatBytes(bytes: number): string;
+/**
+ * Memory in use per Tenant: the sum over its running containers, found by the label
+ * `dev.nylorun.tenant`, from one `docker stats --no-stream`. Undefined when Docker does not
+ * answer; a Tenant with no running container is absent.
+ */
+export declare function tenantMemory(docker: DockerRunner): Promise<Map<string, number> | undefined>;

package/dist/stack/docker.js

@@ -99,3 +99,66 @@ export function parseComposePs(stdout) {
         };
     });
 }
+const UNITS = {
+    b: 1,
+    kb: 1e3,
+    mb: 1e6,
+    gb: 1e9,
+    tb: 1e12,
+    kib: 2 ** 10,
+    mib: 2 ** 20,
+    gib: 2 ** 30,
+    tib: 2 ** 40,
+};
+/** `123.4MiB` (from `docker stats` MemUsage) in bytes; undefined when unreadable. */
+export function parseByteSize(text) {
+    const match = /^([\d.]+)\s*([a-z]+)$/i.exec(text.trim());
+    const unit = match ? UNITS[match[2].toLowerCase()] : undefined;
+    return match && unit ? Number(match[1]) * unit : undefined;
+}
+/** `812 MB`, `2.1 GB`. */
+export function formatBytes(bytes) {
+    return bytes >= 1e9 ? `${(bytes / 1e9).toFixed(1)} GB` : `${Math.round(bytes / 1e6)} MB`;
+}
+/**
+ * Memory in use per Tenant: the sum over its running containers, found by the label
+ * `dev.nylorun.tenant`, from one `docker stats --no-stream`. Undefined when Docker does not
+ * answer; a Tenant with no running container is absent.
+ */
+export async function tenantMemory(docker) {
+    const ps = await docker.run([
+        "ps",
+        "--filter",
+        "label=dev.nylorun.tenant",
+        "--format",
+        '{{.Names}}\t{{.Label "dev.nylorun.tenant"}}',
+    ]);
+    if (ps.code !== 0)
+        return undefined;
+    const owners = new Map(ps.stdout
+        .split(/\r?\n/)
+        .map((line) => line.trim().split("\t"))
+        .filter((cells) => cells.length === 2 && cells[1] !== ""));
+    const memory = new Map();
+    if (owners.size === 0)
+        return memory;
+    const stats = await docker.run([
+        "stats",
+        "--no-stream",
+        "--format",
+        "{{.Name}}\t{{.MemUsage}}",
+        ...owners.keys(),
+    ]);
+    if (stats.code !== 0)
+        return undefined;
+    for (const line of stats.stdout.split(/\r?\n/)) {
+        const [name, usage] = line.trim().split("\t");
+        const tenant = name ? owners.get(name) : undefined;
+        const bytes = usage ? parseByteSize(usage.split("/")[0]) : undefined;
+        if (tenant && bytes !== undefined)
+            memory.set(tenant, (memory.get(tenant) ?? 0) + bytes);
+    }
+    for (const [tenant, bytes] of memory)
+        memory.set(tenant, Math.round(bytes));
+    return memory;
+}

package/dist/stack/prepare.js

@@ -90,6 +90,6 @@ export async function prepareStack(input) {
         runtimeVersion: input.runtimeVersion,
     });
     await writeFileMode(paths.env, renderEnvFile(env), 0o600);
-    await writeFileMode(paths.compose, renderComposeFile(input.project), 0o644);
+    await writeFileMode(paths.compose, renderComposeFile(input.project, input.name), 0o644);
     return { env, host, adminKey, firstRun };
 }

package/dist/stack/stacks.d.ts

@@ -1,3 +1,4 @@
+import type { DockerRunner } from "./docker.js";
 /**
  * The machine's local Tenants (tenancy.md §6): one installation per Tenant, each with its own
  * Host root `~/.nylorun/tenants/<name>/`, Compose project `nylorun-<name>`, ports and volumes.
@@ -48,3 +49,10 @@ export declare function chooseTenantName(base: string, projectDir: string): Prom
  * volumes with new keys.
  */
 export declare function moveStackRoots(base: string, err: (line: string) => void): Promise<void>;
+/**
+ * Remove the Studio proxy of nylorun 0.6 (a Caddy container `nylorun-proxy` on its own network,
+ * files in `~/.nylorun/proxy/`). Removing the container also detaches it from the Tenants'
+ * networks, so their `docker compose down` works again. The directory goes last, once Docker
+ * removed both (or never had them), so a Docker that does not answer is retried next time.
+ */
+export declare function removeOldProxy(docker: DockerRunner, base: string, err: (line: string) => void): Promise<void>;

package/dist/stack/stacks.js

@@ -148,3 +148,22 @@ export async function moveStackRoots(base, err) {
         err(`Moved Tenants ${moved.join(", ")} from ${tilde(stacks)} to ${tilde(tenantsDir(base))}.`);
     }
 }
+/**
+ * Remove the Studio proxy of nylorun 0.6 (a Caddy container `nylorun-proxy` on its own network,
+ * files in `~/.nylorun/proxy/`). Removing the container also detaches it from the Tenants'
+ * networks, so their `docker compose down` works again. The directory goes last, once Docker
+ * removed both (or never had them), so a Docker that does not answer is retried next time.
+ */
+export async function removeOldProxy(docker, base, err) {
+    const dir = join(base, "proxy");
+    if (!existsSync(dir))
+        return;
+    const container = await docker.run(["rm", "--force", "nylorun-proxy"]);
+    if (container.code !== 0 && !/no such container/i.test(container.stderr))
+        return;
+    const network = await docker.run(["network", "rm", "nylorun-proxy"]);
+    if (network.code !== 0 && !/not found|no such network/i.test(network.stderr))
+        return;
+    await rm(dir, { recursive: true, force: true });
+    err("Removed the Studio proxy of nylorun 0.6 (nylorun-proxy); each Studio is on its own localhost port again (\"nylorun studio\" opens it).");
+}

package/dist/stack/studio-login.d.ts

@@ -1,14 +1,15 @@
 export type FetchLike = (input: string, init?: RequestInit) => Promise<Response>;
-/** Studio's origin as the CLI opens it: always `localhost` (the cookie's host). */
+/** Studio's published origin: always `localhost` (the cookie's host). */
 export declare function studioOrigin(port: number): string;
 /**
  * Ask the Studio container for a single-use login token with the admin key
- * (`POST /_studio/login-tokens`, Studio §6) and return the URL to open.
+ * (`POST /_studio/login-tokens`, Studio §6) on `origin` (its published port)
+ * and return the URL to open there.
  * Accepts `{ loginUrl }`, `{ url }` or `{ token }` in the response.
  */
 export declare function mintStudioLogin(input: {
     fetch: FetchLike;
-    studioPort: number;
+    origin: string;
     adminKey: string;
     timeoutMs?: number;
 }): Promise<string>;

package/dist/stack/studio-login.js

@@ -1,15 +1,16 @@
 import { STACK_CLIENT_HOST } from "./host-files.js";
-/** Studio's origin as the CLI opens it: always `localhost` (the cookie's host). */
+/** Studio's published origin: always `localhost` (the cookie's host). */
 export function studioOrigin(port) {
     return `http://${STACK_CLIENT_HOST}:${port}`;
 }
 /**
  * Ask the Studio container for a single-use login token with the admin key
- * (`POST /_studio/login-tokens`, Studio §6) and return the URL to open.
+ * (`POST /_studio/login-tokens`, Studio §6) on `origin` (its published port)
+ * and return the URL to open there.
  * Accepts `{ loginUrl }`, `{ url }` or `{ token }` in the response.
  */
 export async function mintStudioLogin(input) {
-    const origin = studioOrigin(input.studioPort);
+    const { origin } = input;
     const response = await input.fetch(`${origin}/_studio/login-tokens`, {
         method: "POST",
         headers: {
@@ -27,7 +28,7 @@ export async function mintStudioLogin(input) {
     for (const field of ["loginUrl", "url"]) {
         const value = body[field];
         if (typeof value === "string" && value !== "") {
-            // A relative URL is resolved against the published origin.
+            // A relative URL is resolved against the origin it was minted on.
             return new URL(value, origin).toString();
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nylorun",
-  "version": "0.5.0-beta",
+  "version": "0.7.0-beta",
   "type": "module",
   "license": "Apache-2.0",
   "description": "Set up and run local Nylorun Tenants (Runtime and Studio) with Docker Compose",
@@ -41,7 +41,7 @@
     "nylorun": "dist/cli.js"
   },
   "nylorun": {
-    "runtime": "0.15.1-beta",
-    "studio": "0.16.0-beta"
+    "runtime": "0.15.2-beta",
+    "studio": "0.18.0-beta"
   }
 }