nylorun 0.6.0-beta → 0.7.0-beta

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # 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

package/README.md

@@ -36,7 +36,7 @@ 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> | --all]   # stop the containers (--all: every Tenant's, and the Studio proxy); 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-lite, gateway, runtime, studio
 nylorun studio [--tenant <name>] [--no-open]   # sign a browser in to Studio on the Tenant; starts it if needed
@@ -82,29 +82,29 @@ projects and volumes.
 
 Tenants run side by side, each on its own ports, containers, network and
 volumes ([The containers](#the-containers)); a running Tenant uses about
-600–700 MB. Each Studio has its own address through the
-[Studio proxy](#the-studio-proxy), `http://<name>.localhost:4160`. `nylorun ls`
+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  652 MB  http://localhost:8790  http://api.localhost:4160      /Users/me/api
-default  stopped  -       http://localhost:8787  http://default.localhost:4160  -
+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 1.3 GB). "nylorun stop --all" stops them all.
+Also running: default, api (about 2.4 GB). "nylorun stop --all" stops them all.
 ```
 
-`nylorun stop --all` stops every running Tenant on this machine and the Studio
-proxy, keeping their volumes; it cannot be combined with `--tenant` (exit 2).
-`stop` of one Tenant leaves the proxy running.
+`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
@@ -167,67 +167,31 @@ project, and each has the label `dev.nylorun.tenant: <name>`. For Tenant `shop`:
 | 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's RocksDB
-memory is capped at 256 MiB (`RESTATE_ROCKSDB_TOTAL_MEMORY_SIZE`; Restate's
-default is 2 GiB), so several Tenants fit on a laptop: a Tenant uses about
-600–700 MB, down from about 1.3 GB. The Runtime and Studio images are pinned by
+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
 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 and the Studio proxy keep, and kept in its `.env`.
+Tenants keep, and kept in its `.env`.
 
-`start`, `ls` and `nylorun studio` give Studio as `http://<name>.localhost:4160`,
-its address through the Studio proxy (below); `status` adds Studio's own
-`http://localhost:<port>` (`--json` has both: `studio.url` is Studio's own port,
-which an embedding app frames, and `studio.proxyUrl` the proxy's). Studio has no
+`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`, through the proxy; on Studio's own port, saying so,
-when the proxy does not answer) and opens `…/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
+/_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.
 
-Each Tenant's Studio sets its own session cookie, `nylorun_studio_<name>`
-(`NYLORUN_STUDIO_SESSION_COOKIE`).
-
-### The Studio proxy
-
-One small Caddy container per machine (`nylorun-proxy`, Compose project
-`nylorun-proxy`, label `dev.nylorun.proxy: "true"`) gives every Tenant's Studio
-the address `http://<name>.localhost:<port>`. Browsers keep cookies per host,
-not per port, so separate hosts keep the Studios' sessions apart. The proxy is
-for browsers only: programs keep using the Runtime's `http://localhost:<port>`.
-It holds no Tenant data; its files are in `~/.nylorun/proxy/` (`compose.yaml`,
-`Caddyfile`, and `.env` with `NYLORUN_PROXY_PORT`, 4160 or a free port chosen
-on its first start and kept; Caddy's own state is tmpfs). Its image is pinned
-by this release (`caddy:2.11.6`).
-
-- Caddy listens on port 80 in the container, published at `NYLORUN_PROXY_PORT`
-  on `127.0.0.1` and `[::1]` (macOS resolves `*.localhost` to `::1` only); when
-  Docker refuses `::1` (IPv6 off), it publishes on `127.0.0.1` alone and says
-  so once.
-- It routes every Tenant under `~/.nylorun/tenants/`: it joins each Tenant's
-  network and reaches `<project>-studio:3000`, passing the browser's `Host`
-  through, which Studio checks. A stopped Tenant answers 502 naming
-  `nylorun start --tenant <name>`; an unknown host 404 naming `nylorun ls`.
-- `start` rewrites its files, brings it up (only when Studio starts: not with
-  `--no-studio`), joins every Tenant's network and reloads Caddy; Studio learns
-  its proxy origin from `NYLORUN_STUDIO_PUBLIC_ORIGINS`, written to the
-  Tenant's `.env` on every start. A proxy that does not come up never fails
-  `start`: it warns once and prints Studio's own URL.
-- `reset` and `delete` detach it from the Tenant's network first; `delete`
-  removes the Tenant's route. `stop --all` stops it.
-- `NYLORUN_PROXY_DISABLED=1` turns it off: Studio is `http://localhost:<port>`.
-  A Tenant under `NYLORUN_HOME` or `NYLORUN_COMPOSE_PROJECT` (the repository's
-  smokes) does not use it either.
-
-`nylorun doctor` reports it on a `proxy` row: running (on which loopbacks and
-port), stopped, not created yet, or disabled.
+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
 
@@ -308,7 +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` |
-| `http://<name>.localhost:<port>` does not answer | `nylorun doctor` (the `proxy` row); `nylorun start` brings the proxy up; Studio's own port is in `nylorun status` |
+| 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/doctor.d.ts

@@ -1,4 +1,4 @@
-import { type Check, type ProxyStatus, type StackDeps, type StackStatus } from "./stack/index.js";
+import { type Check, type StackDeps, type StackStatus } from "./stack/index.js";
 export interface StackDoctorReport {
     node: {
         version: string;
@@ -9,8 +9,6 @@ export interface StackDoctorReport {
     tenant?: Pick<StackStatus, "name" | "project" | "home" | "state" | "runtime" | "tenant" | "studio" | "gateway">;
     /** Why no Tenant was checked: none is selected here (a project without a link). */
     noTenant?: string;
-    /** The machine's Studio proxy (`http://<tenant>.localhost:<port>`); never a failure. */
-    proxy?: ProxyStatus;
 }
 /**
  * `nylorun doctor`: check the prerequisites of a local Tenant (Node 24+,

package/dist/doctor.js

@@ -1,5 +1,5 @@
 import { CliError } from "./errors.js";
-import { checkDocker, defaultStackDeps, readProxyReport, readStackStatus, } from "./stack/index.js";
+import { checkDocker, defaultStackDeps, readStackStatus, } from "./stack/index.js";
 /** Oldest Node nylorun and the developer's application run on. */
 const MIN_NODE_MAJOR = 24;
 /**
@@ -36,7 +36,6 @@ export async function doctorStack(options) {
                 throw error;
             report.noTenant = error.message;
         }
-        report.proxy = await readProxyReport(deps);
     }
     const broken = report.tenant?.state === "running" &&
         (!report.tenant.runtime.healthy ||
@@ -96,25 +95,9 @@ export async function doctorStack(options) {
                         ? `✓ ${local.tenant.id ?? "?"} open`
                         : `✗ ${local.tenant.id ?? "?"} unavailable${local.tenant.cause ? `: ${local.tenant.cause.code}: ${local.tenant.cause.repair}` : " (opening)"}`,
                 ]);
-            rows.push(["studio", `${local.studio.proxyUrl ?? local.studio.url ?? "?"} · ${local.studio.state}`]);
+            rows.push(["studio", `${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/stack/commands.d.ts

@@ -1,7 +1,6 @@
 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-lite", "gateway", "runtime", "studio"];
 export declare const stackUsage: string;
@@ -74,10 +73,8 @@ export interface StackStatus {
     /** 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). */
+        /** `http://localhost:<port>`: also 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[];
@@ -92,8 +89,6 @@ 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;
@@ -111,7 +106,7 @@ export interface StackEndpoints {
     hostId: string;
     adminKey: string;
     studioPort: number;
-    /** Through the proxy when it serves the Tenant, else Studio's own port. */
+    /** `http://localhost:<studio port>` */
     studioUrl: string;
     /** Studio is running and healthy. */
     studioUp: boolean;
@@ -135,7 +130,7 @@ export declare function tenantStudioPath(tenantId: string): string;
  * 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, running: Pick<StackEndpoints, "studioPort" | "studioUrl" | "adminKey">, next?: string): Promise<string | undefined>;
+export declare function studioLoginUrl(deps: StackDeps, running: Pick<StackEndpoints, "studioPort" | "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;

package/dist/stack/commands.js

@@ -13,8 +13,7 @@ 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 { disconnectProxy, ensureProxySettings, PROXY_PROJECT, proxyDisabled, proxyOrigin, readProxySettings, readProxyStatus, refreshProxyRoutes, startProxy, stopProxy, } from "./proxy.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-lite", "gateway", "runtime", "studio"];
 const CORE_SERVICES = ["postgres", "restate", "s2-lite", "gateway", "runtime"];
@@ -23,7 +22,7 @@ export const stackUsage = `  up|start [--tenant <name>] [--no-link] [--no-studio
                                       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> | --all] stop the Tenant's containers (--all: every Tenant's, and the Studio proxy); 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(", ")})
@@ -43,26 +42,11 @@ export function stackProject(env, name) {
 function nylorunRoot(deps) {
     return deps.nylorunRoot ?? defaultNylorunRoot();
 }
-/**
- * The Studio proxy serves the machine's Tenants (`~/.nylorun/tenants`), unless
- * NYLORUN_PROXY_DISABLED=1; a Host root or Compose project of its own (NYLORUN_HOME,
- * NYLORUN_COMPOSE_PROJECT, as the repository's smokes use) is outside it.
- */
-function proxied(ctx) {
-    const { env } = ctx.deps;
-    return !proxyDisabled(env) && !env.NYLORUN_HOME?.trim() && !env.NYLORUN_COMPOSE_PROJECT?.trim();
-}
-/** Studio's URL for browsers: through the proxy when it serves the Tenant, else its own port. */
-async function studioUrl(ctx, studioPort) {
-    const settings = proxied(ctx) ? await readProxySettings(nylorunRoot(ctx.deps)) : undefined;
-    return settings ? proxyOrigin(ctx.name, settings.port) : studioOrigin(studioPort);
-}
-/** The proxy's routes: every Tenant on this machine. */
-async function proxyRoutes(deps) {
-    return (await listTenants(nylorunRoot(deps))).map((tenant) => ({
-        name: tenant.name,
-        project: stackProject(deps.env, tenant.name),
-    }));
+/** 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
@@ -78,13 +62,9 @@ async function oldVolumes(docker, project) {
         current: names.has(`${project}-postgres`),
     };
 }
-/**
- * Before `docker compose down` (`reset`, `delete`): detach the proxy from the Tenant's network
- * so Compose can remove it. After it: drop a 0.5 Tenant's volumes and network.
- */
+/** `docker compose down` (`reset`, `delete`), then drop a 0.5 Tenant's volumes and network. */
 async function composeDown(ctx, args) {
     const { docker } = ctx.deps;
-    await disconnectProxy(docker, ctx.project);
     const code = await docker.stream(args);
     if (code !== 0)
         throw new CliError(`docker compose down failed (exit ${code}).`, 1);
@@ -356,14 +336,9 @@ async function tenantPorts(base, except) {
     }
     return reserved;
 }
-/** Ports other Tenants and the proxy keep, so a new Tenant avoids them. */
+/** Ports other Tenants keep, so a new Tenant avoids them. */
 async function reservedPorts(ctx) {
-    const base = nylorunRoot(ctx.deps);
-    const reserved = await tenantPorts(base, ctx.paths.root);
-    const proxy = await readProxySettings(base);
-    if (proxy)
-        reserved.add(proxy.port);
-    return reserved;
+    return await tenantPorts(nylorunRoot(ctx.deps), ctx.paths.root);
 }
 async function bringUp(ctx, options) {
     const { deps } = ctx;
@@ -377,10 +352,6 @@ async function bringUp(ctx, options) {
     const base = nylorunRoot(deps);
     const telemetry = await readTelemetry(base);
     const analytics = telemetryDecision(deps.env, telemetry).enabled;
-    // The proxy's port avoids every Tenant's; a new Tenant's ports then avoid the proxy's.
-    const proxy = proxied(ctx)
-        ? await ensureProxySettings(base, deps.ports, await tenantPorts(base))
-        : undefined;
     const prepared = await prepareStack({
         paths: ctx.paths,
         name: ctx.name,
@@ -400,7 +371,6 @@ async function bringUp(ctx, options) {
             : {}),
         ...(options.studioEmbedOrigins ? { studioEmbedOrigins: options.studioEmbedOrigins } : {}),
         ...(analytics ? { studioAnalyticsId: STUDIO_ANALYTICS_ID } : {}),
-        ...(proxy ? { studioPublicOrigin: proxyOrigin(ctx.name, proxy.port) } : {}),
     });
     if (analytics && options.studio && telemetry.noticeShown === undefined) {
         deps.err(TELEMETRY_NOTICE);
@@ -430,45 +400,21 @@ async function bringUp(ctx, options) {
         if (!studioStarted)
             deps.err(`Warning: Studio did not start (image ${prepared.env.studioImage}). The Runtime is up; see "nylorun logs studio".`);
     }
-    let studioUrl = studioOrigin(prepared.env.studioPort);
-    if (studioStarted && proxy) {
-        const up = await startProxy({
-            docker: deps.docker,
-            base,
-            settings: proxy,
-            routes: await proxyRoutes(deps),
-            err: deps.err,
-            ...(deps.pollMs !== undefined ? { pollMs: deps.pollMs } : {}),
-        });
-        if (up)
-            studioUrl = proxyOrigin(ctx.name, proxy.port);
-    }
     return {
         runtimeUrl,
         adminUrl,
         hostId: prepared.host.hostId,
         studioPort: prepared.env.studioPort,
-        studioUrl,
+        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 URL: through the proxy when it serves the Tenant (once; a proxy that
- * does not answer falls back, saying so), else on Studio's own port, retried while it starts.
- */
-async function tryStudioLogin(ctx, studio, adminKey) {
+/** A login URL on Studio's own port, retried while it starts. */
+async function tryStudioLogin(ctx, studioPort, adminKey) {
     const { deps } = ctx;
-    const origin = studioOrigin(studio.port);
-    if (studio.url !== origin) {
-        try {
-            return await mintStudioLogin({ fetch: deps.fetch, origin: studio.url, adminKey });
-        }
-        catch (error) {
-            deps.err(`Studio did not answer through the proxy at ${studio.url} (${errorText(error)}); signing in at ${origin} instead.`);
-        }
-    }
+    const origin = studioOrigin(studioPort);
     const deadline = Date.now() + (deps.loginTimeoutMs ?? 15_000);
     let lastError = "";
     for (;;) {
@@ -584,7 +530,7 @@ async function start(deps, args) {
     if (started.studioStarted) {
         deps.out(`Studio    ${started.studioUrl}`);
         if (opensBrowser(deps, flags)) {
-            const login = await tryStudioLogin(ctx, { port: started.studioPort, url: started.studioUrl }, started.adminKey);
+            const login = await tryStudioLogin(ctx, started.studioPort, started.adminKey);
             if (login)
                 await openLogin(ctx, withNext(login, tenantStudioPath(tenant.id)));
         }
@@ -631,7 +577,7 @@ 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, then the Studio proxy; volumes are kept. */
+/** `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();
@@ -648,17 +594,11 @@ async function stopAll(deps) {
             throw new CliError(`docker compose stop failed for Tenant ${tenant.name} (exit ${code}).`, 1);
         stopped.push(tenant.name);
     }
-    const proxy = projects.get(PROXY_PROJECT) === "running" && (await stopProxy(deps.docker));
     deps.out(stopped.length
-        ? `Stopped Tenants ${stopped.join(", ")}${proxy ? " and the Studio proxy" : ""}; their data is kept.`
-        : `No Tenant was running${proxy ? "; stopped the Studio proxy" : ""}.`);
+        ? `Stopped Tenants ${stopped.join(", ")}; their data is kept.`
+        : "No Tenant was running.");
     return 0;
 }
-async function studioUrls(ctx, port) {
-    const url = await studioUrl(ctx, port);
-    const direct = studioOrigin(port);
-    return url === direct ? { url } : { url: direct, proxyUrl: url };
-}
 async function stackStatus(ctx) {
     const base = {
         name: ctx.name,
@@ -703,7 +643,7 @@ async function stackStatus(ctx) {
         },
         ...(tenant ? { tenant } : {}),
         studio: {
-            ...(persisted.studioPort ? await studioUrls(ctx, persisted.studioPort) : {}),
+            ...(persisted.studioPort ? { url: studioOrigin(persisted.studioPort) } : {}),
             state: studio ? [studio.state, studio.health].filter(Boolean).join(", ") : "absent",
             ...(persisted.studioFrameAncestors
                 ? { embedOrigins: persisted.studioFrameAncestors }
@@ -719,13 +659,9 @@ async function stackStatus(ctx) {
         services,
     };
 }
-/** The Studio proxy, as data (`nylorun doctor`). */
-export async function readProxyReport(deps) {
-    return await readProxyStatus(deps.docker, nylorunRoot(deps), deps.env);
-}
 /** 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) {
@@ -760,8 +696,7 @@ async function status(deps, args) {
         out(`Runtime     ${result.runtime.url ?? "?"}  ${runtimeDetail}`);
         if (result.runtime.adminUrl)
             out(`Admin API   ${result.runtime.adminUrl}  (operators only, never proxied)`);
-        const also = result.studio.proxyUrl ? `also ${result.studio.url}; ` : "";
-        out(`Studio      ${result.studio.proxyUrl ?? result.studio.url ?? "?"}  ${result.studio.state} (${also}log in with "nylorun studio")`);
+        out(`Studio      ${result.studio.url ?? "?"}  ${result.studio.state} (log in with "nylorun studio")`);
         if (result.studio.embedOrigins?.length)
             out(`Embeds      ${result.studio.embedOrigins.join(" ")}  (may show Studio in a frame)`);
         out(`Gateway     ${result.gateway.state} (the Model Gate; model calls fail while it is down)`);
@@ -848,7 +783,6 @@ async function ls(deps, args) {
     const memory = [...(projects?.values() ?? [])].includes("running")
         ? await tenantMemory(deps.docker)
         : undefined;
-    const proxy = proxyDisabled(deps.env) ? undefined : await readProxySettings(base);
     const tenants = [];
     for (const entry of await listTenants(base)) {
         const persisted = (await readStackEnv(stackPaths(entry.root))) ?? {};
@@ -862,13 +796,7 @@ async function ls(deps, args) {
             ...(persisted.runtimePort
                 ? { runtimeUrl: `http://${STACK_CLIENT_HOST}:${persisted.runtimePort}` }
                 : {}),
-            ...(persisted.studioPort
-                ? {
-                    studioUrl: proxy
-                        ? proxyOrigin(entry.name, proxy.port)
-                        : studioOrigin(persisted.studioPort),
-                }
-                : {}),
+            ...(persisted.studioPort ? { studioUrl: studioOrigin(persisted.studioPort) } : {}),
             ports: {
                 ...(persisted.runtimePort ? { runtime: persisted.runtimePort } : {}),
                 ...(persisted.adminPort ? { admin: persisted.adminPort } : {}),
@@ -920,7 +848,6 @@ async function deleteStack(deps, args) {
         ? composeArgs(ctx, "down", "--volumes", "--remove-orphans")
         : ["compose", "--project-name", ctx.project, "down", "--volumes", "--remove-orphans"]);
     await rm(ctx.paths.root, { recursive: true, force: true });
-    await refreshProxyRoutes(deps.docker, base, await proxyRoutes(deps));
     deps.out(`Deleted Tenant ${name}: its containers, volumes and Host root (vault key included).`);
     return 0;
 }
@@ -955,7 +882,7 @@ async function runningStack(ctx, options) {
         hostId: host.hostId,
         adminKey,
         studioPort: persisted.studioPort,
-        studioUrl: await studioUrl(ctx, persisted.studioPort),
+        studioUrl: studioOrigin(persisted.studioPort),
         studioUp,
         started: false,
     };
@@ -1005,7 +932,7 @@ export function tenantStudioPath(tenantId) {
  * Undefined (after a warning) when Studio does not answer.
  */
 export async function studioLoginUrl(deps, running, next) {
-    const login = await tryStudioLogin({ deps }, { port: running.studioPort, url: running.studioUrl }, running.adminKey);
+    const login = await tryStudioLogin({ deps }, running.studioPort, running.adminKey);
     return login === undefined ? undefined : withNext(login, next);
 }
 async function studio(deps, args, options = {}) {
@@ -1035,7 +962,6 @@ async function studio(deps, args, options = {}) {
         deps.out(`Studio    ${login}`);
         return 0;
     }
-    // The login's origin: the proxy's, or Studio's own port when the proxy did not answer.
     const origin = new URL(login).origin;
     deps.out(`Studio    ${next ? new URL(next, origin).toString() : origin}`);
     await openLogin({ deps }, login);
@@ -1043,7 +969,7 @@ async function studio(deps, args, options = {}) {
 }
 /** `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 = {
@@ -1067,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

@@ -6,7 +6,7 @@
  * 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, Studio's public origins) comes from `docker/.env`.
+ * 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

package/dist/stack/compose-file.js

@@ -7,7 +7,7 @@ import { PINNED_IMAGES } from "./images.js";
  * 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, Studio's public origins) comes from `docker/.env`.
+ * 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
@@ -72,9 +72,6 @@ services:
     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
-      # RocksDB's memory (block cache and memtables) defaults to 2 GiB; a local Tenant needs a
-      # fraction of it, and several Tenants share a laptop.
-      RESTATE_ROCKSDB_TOTAL_MEMORY_SIZE: 256MiB
     volumes:
       - restate:/restate-data
       - \${NYLORUN_HOST_ROOT:?run nylorun start}/docker/restate-identity.pem:/run/nylorun/restate-identity.pem:ro
@@ -209,10 +206,8 @@ services:
       NYLORUN_RUNTIME_URL: http://runtime:4001 # the operator listener: Admin and Tenant API
       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, and the
-      # proxy's origin (http://<name>.localhost:<port>), kept in .env.
+      # Studio's Host check accepts localhost/127.0.0.1 on the published port.
       NYLORUN_STUDIO_PUBLIC_PORT: \${NYLORUN_STUDIO_PORT}
-      NYLORUN_STUDIO_PUBLIC_ORIGINS: \${NYLORUN_STUDIO_PUBLIC_ORIGINS:-}
       # 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}

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

@@ -34,11 +34,6 @@ export interface StackEnv {
      * when telemetry is off. Decided again on every start.
      */
     studioAnalyticsId: string;
-    /**
-     * Origins Studio also serves besides localhost and 127.0.0.1 on its port, separated by
-     * spaces: the proxy's `http://<name>.localhost:<port>`, or empty. Decided on every start.
-     */
-    studioPublicOrigins: string;
     /** The Tenant's name, which the Runtime gives the Tenant it creates. */
     tenantName: string;
     /**

package/dist/stack/env-file.js

@@ -24,7 +24,6 @@ const KEYS = {
     studioImage: "NYLORUN_STUDIO_IMAGE",
     studioFrameAncestors: "NYLORUN_STUDIO_FRAME_ANCESTORS",
     studioAnalyticsId: "NYLORUN_STUDIO_ANALYTICS_ID",
-    studioPublicOrigins: "NYLORUN_STUDIO_PUBLIC_ORIGINS",
     tenantName: "NYLORUN_TENANT_NAME",
     derivedPrincipals: "NYLORUN_DERIVED_PRINCIPALS",
 };
@@ -82,10 +81,6 @@ export function renderEnvFile(env) {
         "# it off with nylorun telemetry disable or NYLORUN_TELEMETRY_DISABLED=1.",
         line("studioAnalyticsId"),
         "",
-        "# Studio's address through the proxy (http://<name>.localhost:<port>); empty",
-        "# without the proxy. Set on every start.",
-        line("studioPublicOrigins"),
-        "",
         "# The Tenant's name, which the Runtime gives the Tenant it creates on the first",
         "# start, and the derived principals it registers on that Tenant (keys derived",
         "# from the admin key; `project` is the Project link's).",

package/dist/stack/images.d.ts

@@ -2,13 +2,12 @@
  * Images a local Tenant 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, as is Caddy for the machine's Studio proxy.
+ * 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";
-    readonly proxy: "caddy:2.11.6";
 };
 export interface StackImages {
     runtime: string;
@@ -16,7 +15,6 @@ export interface StackImages {
     postgres: string;
     restate: string;
     s2: string;
-    proxy: string;
 }
 /** `NYLORUN_RUNTIME_IMAGE` names the Runtime image, so its version is unknown here. */
 export declare function runtimeImageOverridden(env: Readonly<Record<string, string | undefined>>): boolean;

package/dist/stack/images.js

@@ -3,13 +3,12 @@ import { pinnedVersion } from "./versions.js";
  * Images a local Tenant 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, as is Caddy for the machine's Studio proxy.
+ * 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",
-    proxy: "caddy:2.11.6",
 };
 function override(env, name) {
     const value = env[name]?.trim();

package/dist/stack/index.d.ts

@@ -1,9 +1,8 @@
 import { type StackDeps } from "./commands.js";
-export { ensureStack, isStackCommand, readProxyReport, readStackStatus, stackUsage, studioLoginUrl, tenantStudioPath, STACK_SERVICES, } from "./commands.js";
+export { ensureStack, isStackCommand, readStackStatus, stackUsage, studioLoginUrl, tenantStudioPath, STACK_SERVICES, } from "./commands.js";
 export type { StackDeps, StackEndpoints, StackStatus, StackTenant } from "./commands.js";
 export { checkDocker } from "./docker.js";
 export type { Check, DockerChecks } from "./docker.js";
-export type { ProxyStatus } from "./proxy.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|ls|delete`. */

package/dist/stack/index.js

@@ -4,7 +4,7 @@ import { runStackCommand, runStudioCommand } from "./commands.js";
 import { spawnDocker } from "./docker.js";
 import { pinnedVersion } from "./versions.js";
 import { loopbackPorts } from "./ports.js";
-export { ensureStack, isStackCommand, readProxyReport, readStackStatus, stackUsage, studioLoginUrl, tenantStudioPath, STACK_SERVICES, } from "./commands.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")
@@ -21,8 +21,6 @@ const STACK_ENV_OWNED = [
     "NYLORUN_TENANT_NAME",
     "NYLORUN_DERIVED_PRINCIPALS",
     "NYLORUN_STUDIO_ANALYTICS_ID",
-    "NYLORUN_STUDIO_PUBLIC_ORIGINS",
-    "NYLORUN_PROXY_PORT",
 ];
 /** Real dependencies: docker on PATH, global fetch, the terminal. */
 export function defaultStackDeps(env) {

package/dist/stack/ports.d.ts

@@ -1,6 +1,4 @@
 export declare const DEFAULT_PORTS: {
-    /** The Studio proxy, one per machine (`http://<tenant>.localhost:<port>`). */
-    readonly proxy: 4160;
     readonly runtime: 8787;
     /** The Runtime's operator listener (Admin API). */
     readonly admin: 8788;

package/dist/stack/ports.js

@@ -1,7 +1,5 @@
 import { createServer } from "node:net";
 export const DEFAULT_PORTS = {
-    /** The Studio proxy, one per machine (`http://<tenant>.localhost:<port>`). */
-    proxy: 4160,
     runtime: 8787,
     /** The Runtime's operator listener (Admin API). */
     admin: 8788,

package/dist/stack/prepare.d.ts

@@ -43,6 +43,4 @@ export declare function prepareStack(input: {
     };
     /** The measurement id Studio reports page views to; absent when telemetry is off. */
     studioAnalyticsId?: string;
-    /** Studio's origin through the proxy; absent without the proxy. */
-    studioPublicOrigin?: string;
 }): Promise<PreparedStack>;

package/dist/stack/prepare.js

@@ -77,7 +77,6 @@ export async function prepareStack(input) {
         studioImage: input.images.studio,
         studioFrameAncestors,
         studioAnalyticsId: input.studioAnalyticsId ?? "",
-        studioPublicOrigins: input.studioPublicOrigin ?? "",
         tenantName: input.name,
         derivedPrincipals: (input.derivedPrincipals?.trim()
             ? parseDerivedPrincipals(input.derivedPrincipals, "NYLORUN_DERIVED_PRINCIPALS")

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

@@ -3,8 +3,8 @@ export type FetchLike = (input: string, init?: RequestInit) => Promise<Response>
 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) on `origin` (its published port, or
- * the proxy's `http://<name>.localhost:<port>`) and return the URL to open there.
+ * (`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: {

package/dist/stack/studio-login.js

@@ -5,8 +5,8 @@ export function studioOrigin(port) {
 }
 /**
  * Ask the Studio container for a single-use login token with the admin key
- * (`POST /_studio/login-tokens`, Studio §6) on `origin` (its published port, or
- * the proxy's `http://<name>.localhost:<port>`) and return the URL to open there.
+ * (`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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nylorun",
-  "version": "0.6.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",
@@ -42,6 +42,6 @@
   },
   "nylorun": {
     "runtime": "0.15.2-beta",
-    "studio": "0.17.0-beta"
+    "studio": "0.18.0-beta"
   }
 }

package/dist/stack/proxy.d.ts

@@ -1,78 +0,0 @@
-import type { DockerRunner } from "./docker.js";
-import { type PortProbe } from "./ports.js";
-/**
- * The Studio proxy: one small Caddy container per machine that gives each local Tenant's
- * Studio the address `http://<name>.localhost:<port>`. Browsers keep cookies per host, not
- * per port, so separate hosts keep the Studios' sessions apart. It routes browsers to Studio
- * only (programs keep the Runtime's `http://localhost:<port>`: Node's resolver need not
- * resolve `*.localhost`) and holds no Tenant data: its files are `~/.nylorun/proxy/`
- * (`compose.yaml`, `Caddyfile`, `.env`), and Caddy's own state is tmpfs.
- *
- * The proxy joins each Tenant's network (named after its Compose project) and reaches Studio
- * by container name, `<project>-studio:3000`. Docker cannot remove a network the proxy is
- * attached to, so `reset` and `delete` disconnect it first.
- */
-export declare const PROXY_PROJECT = "nylorun-proxy";
-export declare const PROXY_CONTAINER = "nylorun-proxy";
-export interface ProxyPaths {
-    dir: string;
-    compose: string;
-    caddyfile: string;
-    /** The port, and whether Docker took the `::1` binding. */
-    env: string;
-}
-export declare function proxyPaths(base: string): ProxyPaths;
-/** `NYLORUN_PROXY_DISABLED=1`: no proxy; Studio is `http://localhost:<port>`. */
-export declare function proxyDisabled(env: Readonly<Record<string, string | undefined>>): boolean;
-export declare function proxyOrigin(name: string, port: number): string;
-export interface ProxySettings {
-    port: number;
-    /** Also published on `[::1]` (false once Docker refused it). */
-    ipv6: boolean;
-}
-export declare function readProxySettings(base: string): Promise<ProxySettings | undefined>;
-/**
- * The proxy's settings. On first use its port is 4160 when free, else a free one outside
- * `taken`; it is kept after that.
- */
-export declare function ensureProxySettings(base: string, ports: PortProbe, taken: ReadonlySet<number>): Promise<ProxySettings>;
-/** A Tenant the proxy routes to: its name and Compose project (also its network's name). */
-export interface ProxyRoute {
-    name: string;
-    project: string;
-}
-/**
- * One site per Tenant. Site addresses carry no port: Caddy listens on 80 in the container,
- * and its host match ignores the published port in the browser's Host. The browser's Host
- * (`<name>.localhost:<port>`) reaches Studio unchanged, which Studio checks; a Tenant that is
- * not running answers 502, and an unknown host 404.
- */
-export declare function renderCaddyfile(routes: readonly ProxyRoute[]): string;
-export declare function renderProxyCompose(ipv6: boolean): string;
-/** Detach the proxy from a Tenant's network, so Compose can remove it; never fails. */
-export declare function disconnectProxy(docker: DockerRunner, network: string): Promise<void>;
-/**
- * Write the routes, bring the proxy up (Compose recreates it when its file changed), attach
- * it to every routed Tenant's network and reload Caddy. Never throws: a problem is warned
- * once and the caller shows Studio's own port. When Docker refuses `[::1]` (IPv6 off), the
- * proxy listens on 127.0.0.1 only, and says so once.
- */
-export declare function startProxy(input: {
-    docker: DockerRunner;
-    base: string;
-    settings: ProxySettings;
-    routes: readonly ProxyRoute[];
-    err(line: string): void;
-    pollMs?: number;
-}): Promise<boolean>;
-/** Rewrite the routes of an existing proxy and reload it (`delete`); never fails. */
-export declare function refreshProxyRoutes(docker: DockerRunner, base: string, routes: readonly ProxyRoute[]): Promise<void>;
-/** Stop the proxy (`stop --all`); true when it stopped. */
-export declare function stopProxy(docker: DockerRunner): Promise<boolean>;
-export interface ProxyStatus {
-    state: "running" | "stopped" | "absent" | "disabled";
-    port?: number;
-    ipv6?: boolean;
-}
-/** The proxy as `nylorun doctor` reports it. */
-export declare function readProxyStatus(docker: DockerRunner, base: string, env: Readonly<Record<string, string | undefined>>): Promise<ProxyStatus>;

package/dist/stack/proxy.js

@@ -1,224 +0,0 @@
-import { randomBytes } from "node:crypto";
-import { existsSync } from "node:fs";
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { parseEnvLines } from "./env-file.js";
-import { PINNED_IMAGES } from "./images.js";
-import { choosePort, DEFAULT_PORTS } from "./ports.js";
-/**
- * The Studio proxy: one small Caddy container per machine that gives each local Tenant's
- * Studio the address `http://<name>.localhost:<port>`. Browsers keep cookies per host, not
- * per port, so separate hosts keep the Studios' sessions apart. It routes browsers to Studio
- * only (programs keep the Runtime's `http://localhost:<port>`: Node's resolver need not
- * resolve `*.localhost`) and holds no Tenant data: its files are `~/.nylorun/proxy/`
- * (`compose.yaml`, `Caddyfile`, `.env`), and Caddy's own state is tmpfs.
- *
- * The proxy joins each Tenant's network (named after its Compose project) and reaches Studio
- * by container name, `<project>-studio:3000`. Docker cannot remove a network the proxy is
- * attached to, so `reset` and `delete` disconnect it first.
- */
-export const PROXY_PROJECT = "nylorun-proxy";
-export const PROXY_CONTAINER = "nylorun-proxy";
-export function proxyPaths(base) {
-    const dir = join(base, "proxy");
-    return {
-        dir,
-        compose: join(dir, "compose.yaml"),
-        caddyfile: join(dir, "Caddyfile"),
-        env: join(dir, ".env"),
-    };
-}
-/** `NYLORUN_PROXY_DISABLED=1`: no proxy; Studio is `http://localhost:<port>`. */
-export function proxyDisabled(env) {
-    return /^(1|true)$/i.test(env.NYLORUN_PROXY_DISABLED?.trim() ?? "");
-}
-export function proxyOrigin(name, port) {
-    return `http://${name}.localhost:${port}`;
-}
-export async function readProxySettings(base) {
-    let text;
-    try {
-        text = await readFile(proxyPaths(base).env, "utf8");
-    }
-    catch {
-        return undefined;
-    }
-    const values = parseEnvLines(text);
-    const port = Number(values.get("NYLORUN_PROXY_PORT"));
-    if (!Number.isInteger(port) || port < 1 || port > 65535)
-        return undefined;
-    return { port, ipv6: values.get("NYLORUN_PROXY_IPV6") !== "false" };
-}
-async function writeAtomic(path, text) {
-    const temporary = `${path}.${randomBytes(8).toString("hex")}.tmp`;
-    await writeFile(temporary, text, { mode: 0o644 });
-    await rename(temporary, path);
-}
-async function writeProxySettings(base, settings) {
-    const paths = proxyPaths(base);
-    await mkdir(paths.dir, { recursive: true, mode: 0o755 });
-    await writeAtomic(paths.env, [
-        "# Written by `nylorun start`: the Studio proxy's port, kept from its first start,",
-        "# and whether it is also published on [::1].",
-        `NYLORUN_PROXY_PORT=${settings.port}`,
-        `NYLORUN_PROXY_IPV6=${settings.ipv6}`,
-        "",
-    ].join("\n"));
-}
-/**
- * The proxy's settings. On first use its port is 4160 when free, else a free one outside
- * `taken`; it is kept after that.
- */
-export async function ensureProxySettings(base, ports, taken) {
-    const existing = await readProxySettings(base);
-    if (existing)
-        return existing;
-    const settings = { port: await choosePort(ports, DEFAULT_PORTS.proxy, undefined, taken), ipv6: true };
-    await writeProxySettings(base, settings);
-    return settings;
-}
-/**
- * One site per Tenant. Site addresses carry no port: Caddy listens on 80 in the container,
- * and its host match ignores the published port in the browser's Host. The browser's Host
- * (`<name>.localhost:<port>`) reaches Studio unchanged, which Studio checks; a Tenant that is
- * not running answers 502, and an unknown host 404.
- */
-export function renderCaddyfile(routes) {
-    const sites = routes.map(({ name, project }) => `http://${name}.localhost {
-	reverse_proxy ${project}-studio:3000
-	handle_errors {
-		respond \`Tenant ${name} is not running. Run "nylorun start --tenant ${name}".\` 502
-	}
-}
-`);
-    return [
-        `# Written by \`nylorun start\`: a site per Tenant under ~/.nylorun/tenants. Rewritten on every start.
-{
-	auto_https off
-	admin localhost:2019 # inside the container only; \`caddy reload\` uses it
-}
-`,
-        ...sites,
-        `:80 {
-	respond \`No Tenant at {host}. "nylorun ls" lists the Tenants on this machine.\` 404
-}
-`,
-    ].join("\n");
-}
-export function renderProxyCompose(ipv6) {
-    return `# Written by \`nylorun start\`; rewritten on every start. The port lives in .env.
-name: ${PROXY_PROJECT}
-
-services:
-  proxy: # http://<tenant>.localhost:<port>: every local Tenant's Studio
-    image: ${PINNED_IMAGES.proxy}
-    container_name: ${PROXY_CONTAINER}
-    labels:
-      dev.nylorun.proxy: "true"
-    volumes:
-      - .:/etc/caddy:ro # this directory: the Caddyfile, reloaded with \`caddy reload\`
-    tmpfs: [/config, /data] # Caddy's own state; nothing to keep
-    ports:
-      - "127.0.0.1:\${NYLORUN_PROXY_PORT:?run nylorun start}:80"${ipv6
-        ? `
-      - "[::1]:\${NYLORUN_PROXY_PORT:?run nylorun start}:80" # macOS resolves <name>.localhost to ::1 only`
-        : ""}
-    restart: unless-stopped
-
-networks:
-  default:
-    name: ${PROXY_PROJECT}
-    labels:
-      dev.nylorun.proxy: "true"
-`;
-}
-function proxyCompose(paths, ...args) {
-    return ["compose", "--project-name", PROXY_PROJECT, "--file", paths.compose, "--env-file", paths.env, ...args];
-}
-function lastLine(text) {
-    return text.trim().split(/\r?\n/).at(-1) ?? "";
-}
-/** Attach the proxy to a Tenant's network; "already attached" and "no such network" are fine. */
-async function connectProxy(docker, network) {
-    const result = await docker.run(["network", "connect", network, PROXY_CONTAINER]);
-    if (result.code === 0 || /already exists|not found|no such network/i.test(result.stderr))
-        return undefined;
-    return lastLine(result.stderr) || `exit ${result.code}`;
-}
-/** Detach the proxy from a Tenant's network, so Compose can remove it; never fails. */
-export async function disconnectProxy(docker, network) {
-    await docker.run(["network", "disconnect", "--force", network, PROXY_CONTAINER]);
-}
-async function reloadProxy(docker) {
-    return await docker.run(["exec", PROXY_CONTAINER, "caddy", "reload", "--config", "/etc/caddy/Caddyfile"]);
-}
-/**
- * Write the routes, bring the proxy up (Compose recreates it when its file changed), attach
- * it to every routed Tenant's network and reload Caddy. Never throws: a problem is warned
- * once and the caller shows Studio's own port. When Docker refuses `[::1]` (IPv6 off), the
- * proxy listens on 127.0.0.1 only, and says so once.
- */
-export async function startProxy(input) {
-    const { docker, base, err } = input;
-    const paths = proxyPaths(base);
-    const warn = (problem) => err(`Warning: the Studio proxy is not available (${problem}); Studio is on its own port. See "nylorun doctor".`);
-    try {
-        await writeAtomic(paths.caddyfile, renderCaddyfile(input.routes));
-        await writeAtomic(paths.compose, renderProxyCompose(input.settings.ipv6));
-    }
-    catch (error) {
-        warn(error instanceof Error ? error.message : String(error));
-        return false;
-    }
-    let up = await docker.run(proxyCompose(paths, "up", "--detach"));
-    if (up.code !== 0 && input.settings.ipv6) {
-        await writeAtomic(paths.compose, renderProxyCompose(false));
-        const ipv4 = await docker.run(proxyCompose(paths, "up", "--detach"));
-        if (ipv4.code === 0) {
-            await writeProxySettings(base, { ...input.settings, ipv6: false });
-            err(`Docker refused the Studio proxy on [::1]:${input.settings.port} (${lastLine(up.stderr)}); it listens on 127.0.0.1 only, so a browser that resolves *.localhost to ::1 alone does not reach it.`);
-        }
-        up = ipv4;
-    }
-    if (up.code !== 0) {
-        warn(`docker compose up: ${lastLine(up.stderr) || `exit ${up.code}`}`);
-        return false;
-    }
-    for (const route of input.routes) {
-        const problem = await connectProxy(docker, route.project);
-        if (problem)
-            err(`Warning: the Studio proxy could not join ${route.project} (${problem}).`);
-    }
-    // A container Compose just created may not take the reload yet.
-    for (let attempt = 1;; attempt += 1) {
-        const reload = await reloadProxy(docker);
-        if (reload.code === 0)
-            return true;
-        if (attempt === 10) {
-            warn(`caddy reload: ${lastLine(reload.stderr) || `exit ${reload.code}`}`);
-            return false;
-        }
-        await new Promise((resolve) => setTimeout(resolve, input.pollMs ?? 500));
-    }
-}
-/** Rewrite the routes of an existing proxy and reload it (`delete`); never fails. */
-export async function refreshProxyRoutes(docker, base, routes) {
-    const paths = proxyPaths(base);
-    if (!existsSync(paths.caddyfile))
-        return;
-    await writeAtomic(paths.caddyfile, renderCaddyfile(routes));
-    await reloadProxy(docker);
-}
-/** Stop the proxy (`stop --all`); true when it stopped. */
-export async function stopProxy(docker) {
-    return (await docker.run(["compose", "--project-name", PROXY_PROJECT, "stop"])).code === 0;
-}
-/** The proxy as `nylorun doctor` reports it. */
-export async function readProxyStatus(docker, base, env) {
-    if (proxyDisabled(env))
-        return { state: "disabled" };
-    const settings = await readProxySettings(base);
-    const inspect = await docker.run(["inspect", "--format", "{{.State.Status}}", PROXY_CONTAINER]);
-    const state = inspect.code !== 0 ? "absent" : inspect.stdout.trim() === "running" ? "running" : "stopped";
-    return { state, ...(settings ? { port: settings.port, ipv6: settings.ipv6 } : {}) };
-}