nylorun 0.6.0-beta → 0.8.0-beta

package/dist/sandbox/probe.js

@@ -0,0 +1,137 @@
+import { randomBytes } from "node:crypto";
+import { CliError } from "../errors.js";
+import { networkPolicy, PROBE_IMAGE, probePod } from "./manifests.js";
+const DOCKER_DESKTOP_HOST = "192.168.65.254";
+/** Docker Desktop and OrbStack forward the host address to this machine's loopback. */
+export function defaultBind(context, hostAddress) {
+    if (hostAddress === DOCKER_DESKTOP_HOST || context === "docker-desktop" || context === "orbstack")
+        return "127.0.0.1";
+    return hostAddress;
+}
+const IPV4 = /^(?:(?:25[0-5]|2[0-4]\d|1?\d?\d)\.){3}(?:25[0-5]|2[0-4]\d|1?\d?\d)$/;
+export function assertIPv4(value, option) {
+    if (!IPV4.test(value))
+        throw new CliError(`${option} must be an IPv4 address: ${value}`, 2);
+    return value;
+}
+/** The last IPv4 address `nslookup` prints for the name (the first is the DNS server). */
+export function parseNslookup(output) {
+    const answer = output.split(/Name:\s*\S+/).slice(1).join("\n");
+    const addresses = [...answer.matchAll(/Address(?:es)?:?\s*(?:\d+\s+)?([0-9.]+)\b/g)]
+        .map((match) => match[1])
+        .filter((address) => IPV4.test(address));
+    return addresses.at(-1);
+}
+async function sleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+/** `wget` from a probe pod; true when the connection succeeds. */
+async function reaches(kube, namespace, pod, address, port) {
+    const result = await kube.run(["exec", "-n", namespace, pod, "--", "wget", "-q", "-O", "-", "-T", "3", `http://${address}:${port}/`], { timeoutMs: 20_000 });
+    return result.code === 0;
+}
+export async function runProbe(deps, options) {
+    const { kube, docker } = deps;
+    const suffix = randomBytes(3).toString("hex");
+    const namespace = `nylorun-sbx-probe-${suffix}`;
+    const listener = namespace;
+    const poll = deps.pollMs ?? 1000;
+    let listenerStarted = false;
+    const fail = (message) => new CliError(`Refusing context ${kube.context}: ${message}`, 6);
+    try {
+        await kube.apply("Creating the probe namespace", [
+            { apiVersion: "v1", kind: "Namespace", metadata: { name: namespace, labels: { "app.kubernetes.io/managed-by": "nylorun" } } },
+            probePod(namespace, "peer", { role: "peer", serve: true }),
+            probePod(namespace, "control", { role: "control" }),
+            probePod(namespace, "restricted", { role: "restricted" }),
+        ]);
+        await kube.check("Waiting for the probe pods", [
+            "wait", "--for=condition=Ready", "pod", "--all", "-n", namespace, "--timeout=180s",
+        ], { timeoutMs: 200_000 });
+        let hostAddress = options.hostAddress;
+        if (!hostAddress) {
+            const lookup = await kube.run(["exec", "-n", namespace, "control", "--", "nslookup", "host.docker.internal"]);
+            // busybox nslookup may exit non-zero after an NXDOMAIN on a search domain: parse anyway.
+            hostAddress = parseNslookup(lookup.stdout);
+            if (!hostAddress)
+                throw fail("pods cannot resolve host.docker.internal. Pass --host-address with the Docker host's address as pods reach it (172.17.0.1 for kind on Linux).");
+        }
+        const bindAddress = options.bindAddress ?? defaultBind(kube.context, hostAddress);
+        const allowed = await deps.ports.pickFree();
+        let denied = await deps.ports.pickFree();
+        if (denied === allowed)
+            denied = await deps.ports.pickFree();
+        const started = await docker.run([
+            "run", "--detach", "--rm", "--name", listener, "--label", "dev.nylorun.probe=true",
+            "--publish", `${bindAddress}:${allowed}:8080`, "--publish", `${bindAddress}:${denied}:8081`,
+            PROBE_IMAGE, "sh", "-c",
+            "echo ok > /tmp/index.html; httpd -p 8081 -h /tmp; exec httpd -f -p 8080 -h /tmp",
+        ]);
+        if (started.code !== 0)
+            throw fail(`could not publish a probe listener on ${bindAddress}: ${started.stderr.trim()}`);
+        listenerStarted = true;
+        const peer = (await kube.check("Reading the peer pod's address", [
+            "get", "pod", "peer", "-n", namespace, "-o", "jsonpath={.status.podIP}",
+        ])).trim();
+        if (!(await reaches(kube, namespace, "control", peer, 8080)))
+            throw fail("a pod cannot reach another pod in its namespace (the probe cannot tell a policy from a broken network).");
+        if (!(await reaches(kube, namespace, "control", hostAddress, allowed)))
+            throw fail(`pods cannot reach ${hostAddress}:${allowed} on the Docker host (published on ${bindAddress}). Pass --host-address and --bind-address for this cluster.`);
+        await kube.apply("Applying the probe NetworkPolicy", [
+            networkPolicy(namespace, hostAddress, [allowed], { name: "probe", podSelector: { "nylorun.dev/probe": "restricted" } }),
+        ]);
+        const deadline = Date.now() + (deps.policyTimeoutMs ?? 30_000);
+        while (await reaches(kube, namespace, "restricted", peer, 8080)) {
+            if (Date.now() > deadline)
+                throw fail("NetworkPolicy is not enforced: a pod under a deny policy still reached another pod. Sandboxes need a CNI that enforces NetworkPolicy (kindnet with policy support, Calico, Cilium).");
+            await sleep(poll);
+        }
+        if (await reaches(kube, namespace, "restricted", hostAddress, denied))
+            throw fail(`NetworkPolicy is not enforced per port: a restricted pod reached ${hostAddress}:${denied}.`);
+        if (!(await reaches(kube, namespace, "restricted", hostAddress, allowed)))
+            throw fail(`a restricted pod cannot reach the allowed ${hostAddress}:${allowed}: the policy's ipBlock does not match the host route.`);
+        const notPulled = options.prePull?.length ? await prePull(deps, namespace, options.prePull) : [];
+        return { hostAddress, bindAddress, enforced: true, probedAt: new Date().toISOString(), notPulled };
+    }
+    finally {
+        if (listenerStarted)
+            await docker.run(["rm", "--force", listener]);
+        await kube.run(["delete", "namespace", namespace, "--ignore-not-found", "--wait=false"]);
+    }
+}
+/**
+ * Pull images on every node with a pod per node and image (a cold pull of a pack-sized image
+ * takes about 30 s). Best effort: images that do not pull (a local build, no registry) are
+ * returned, for a warning.
+ */
+async function prePull(deps, namespace, images) {
+    const { kube } = deps;
+    const nodes = JSON.parse(await kube.check("Listing nodes", ["get", "nodes", "-o", "json"]));
+    const pods = nodes.items.flatMap((node, n) => images.map((image, i) => ({
+        name: `pull-${n}-${i}`,
+        image,
+        manifest: probePod(namespace, `pull-${n}-${i}`, {
+            role: "pull", image, nodeName: node.metadata.name, command: ["true"],
+        }),
+    })));
+    await kube.apply("Pre-pulling images", pods.map((pod) => pod.manifest));
+    const failed = new Set();
+    const done = new Set();
+    const deadline = Date.now() + 300_000;
+    while (done.size + failed.size < pods.length && Date.now() < deadline) {
+        const list = await kube.getJson(["pods", "-n", namespace, "-l", "nylorun.dev/probe=pull"]);
+        for (const item of list?.items ?? []) {
+            const pod = pods.find((p) => p.name === item.metadata.name);
+            if (!pod || done.has(pod.name) || failed.has(pod.name))
+                continue;
+            const reason = item.status?.containerStatuses?.[0]?.state?.waiting?.reason ?? "";
+            if (/ErrImagePull|ImagePullBackOff|InvalidImageName|ErrImageNeverPull/.test(reason))
+                failed.add(pod.name);
+            else if (item.status?.phase && item.status.phase !== "Pending")
+                done.add(pod.name);
+        }
+        if (done.size + failed.size < pods.length)
+            await sleep(deps.pollMs ?? 2000);
+    }
+    return images.filter((image) => pods.some((pod) => pod.image === image && !done.has(pod.name)));
+}

package/dist/stack/commands.d.ts

@@ -1,9 +1,10 @@
 import type { HostTenant } from "@nylorun/core/contracts";
 import { type ComposeService, type DockerRunner } from "./docker.js";
+import type { HarnessMode, SandboxStackEnv } from "./env-file.js";
+import { type StackPaths } from "./paths.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 STACK_SERVICES: readonly ["postgres", "restate", "s2-lite", "rustfs", "gateway", "runtime", "harness", "studio"];
 export declare const stackUsage: string;
 export interface StackDeps {
     /** Environment snapshot (NYLORUN_HOME, NYLORUN_TENANT, image overrides, NYLORUN_COMPOSE_PROJECT). */
@@ -74,26 +75,35 @@ 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[];
     };
+    /** Restate's UI: `url` only while published (`nylorun start --restate-ui`). */
     restate: {
         url?: string;
+        published: boolean;
     };
     /** The gateway container (the Model Gate), in the combined packing. */
     gateway: {
         state: string;
         healthy: boolean;
     };
+    /**
+     * Where agent turns, MCP servers and workspaces run (F6.2): `remote`, the harness container,
+     * or `in-process`, the runtime container (`NYLORUN_HARNESS` in .env). `connected` counts the
+     * harnesses attached to the Tenant, as the Runtime reports them.
+     */
+    harness: {
+        mode: HarnessMode;
+        state: string;
+        healthy: boolean;
+        connected?: number;
+    };
     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,13 +121,28 @@ 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;
     /** This call started the Runtime (it was not running before). */
     started: boolean;
 }
+/** The running Tenant's API, reached as the Project's derived principal (`nylorun sandbox`). */
+export interface TenantApi {
+    /** The Tenant's name. */
+    name: string;
+    runtimeUrl: string;
+    /** The `project` derived principal's key, derived from the admin key; never stored. */
+    applicationKey: string;
+}
+/**
+ * The selected Tenant's API while it runs: commands that read or change the Tenant's data never
+ * start it. Exit 3 when it is not running, 7 when it is not open.
+ */
+export declare function runningTenantApi(deps: StackDeps, options?: {
+    name?: string;
+}): Promise<TenantApi>;
 /**
  * Start the selected Tenant unless it is already running (`nylorun studio`): the
  * `start` code path without its output, its Tenant wait or the Project link. Compose
@@ -127,6 +152,28 @@ export declare function ensureStack(deps: StackDeps, options: {
     studio: boolean;
     name?: string;
 }): Promise<StackEndpoints>;
+/** A started Tenant as `nylorun sandbox` sees it. */
+export interface SelectedTenant {
+    name: string;
+    paths: StackPaths;
+    project: string;
+    /** `docker compose` arguments for this Tenant's project and files. */
+    compose(...args: string[]): string[];
+}
+/** The Tenant `nylorun sandbox` acts on; it must have been started once. */
+export declare function selectTenant(deps: StackDeps, options?: {
+    name?: string;
+}): Promise<SelectedTenant>;
+/**
+ * Rewrite the Tenant's Compose files with `sandboxes` set (an object) or removed (null),
+ * and bring it up again: Compose recreates the containers whose settings changed.
+ */
+export declare function restartTenant(deps: StackDeps, options: {
+    name?: string;
+    sandboxes: SandboxStackEnv | null;
+}): Promise<void>;
+/** Ports every Tenant on this machine keeps for sandboxes, but the one under `except`. */
+export declare function reservedSandboxPorts(deps: StackDeps, except: string): Promise<Set<number>>;
 /** Add Studio's `next` path (e.g. `/tenants/<id>`) to a login URL. */
 export declare function withNext(loginUrl: string, next: string | undefined): string;
 /** The Tenant's Studio page, as a login `next` path. */
@@ -135,7 +182,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;