nylorun 0.12.2-beta → 0.14.0-beta

package/dist/client/project/connection.d.ts

@@ -0,0 +1,36 @@
+import { type ManagementClient } from "@nylorun/admin";
+import { type ProjectCredentials, type ProjectLink as LinkFile } from "@nylorun/core/project";
+/**
+ * The Project link (format 3), which `nylorun start` writes and `nylo` only reads with
+ * `@nylorun/core/project`'s reader. `tenantId` is information: the installation serves one
+ * Tenant, so nothing selects it.
+ */
+export type ProjectLink = LinkFile & {
+    format: 3;
+};
+/** The Project's link; one of an older nylorun (formats 0 to 2) is refused. */
+export declare function readLink(projectRoot: string): Promise<ProjectLink | undefined>;
+/**
+ * The Project's credentials (mode 0600), which `nylorun start` writes beside the link: the
+ * application key and its principal, and the management key and its principal when it issued
+ * one. A format 0 file's legacy `executors` map is ignored.
+ */
+export declare function readCredentials(projectRoot: string): Promise<ProjectCredentials | undefined>;
+/** The installation `nylo` acts on: a Runtime URL, an application key and a management key. */
+export interface LinkedConnection {
+    url: string;
+    /** The application key (Runtime API); absent when only a management key is set. */
+    key?: string;
+    /** The management key (Management API), when there is one. */
+    managementKey?: string;
+    /** The Project link it came from, when it came from one. */
+    link?: ProjectLink;
+}
+/**
+ * The Project's link and credentials, else `NYLORUN_RUNTIME_URL` with `NYLORUN_SERVER_KEY`, or
+ * `NYLORUN_MANAGEMENT_KEY`, or both; `NYLORUN_MANAGEMENT_KEY` also stands in for a Project
+ * credentials file without one. The installation serves one Tenant, so nothing names it.
+ */
+export declare function linkedConnection(projectRoot: string, env?: Readonly<Record<string, string | undefined>>): Promise<LinkedConnection>;
+/** The Management API client of `connection`; refused without a management key. */
+export declare function managementClient(connection: LinkedConnection): ManagementClient;

package/dist/client/project/connection.js

@@ -0,0 +1,80 @@
+import { chmod } from "node:fs/promises";
+import { createManagementClient } from "@nylorun/admin";
+import { ProjectFileError, projectCredentialsPath, projectLinkPath, readProjectCredentials, readProjectLink, } from "@nylorun/core/project";
+import { CliError } from "../../errors.js";
+/** The Project's link; one of an older nylorun (formats 0 to 2) is refused. */
+export async function readLink(projectRoot) {
+    const path = projectLinkPath(projectRoot);
+    let link;
+    try {
+        link = readProjectLink(projectRoot);
+    }
+    catch (error) {
+        if (!(error instanceof ProjectFileError))
+            throw error;
+        throw new CliError(error.reason === "newer"
+            ? `Project link at ${path} has an unsupported format. Upgrade nylorun.`
+            : `Invalid Project link at ${path}. Remove .nylorun/link.json and run "npx nylorun start".`, 1);
+    }
+    if (link === undefined)
+        return undefined;
+    if (link.format !== 3)
+        throw new CliError(`The Project link at ${path} is from an older nylorun. Run "npx nylorun start" in this project to link it again.`, 1);
+    return { ...link, format: 3 };
+}
+/**
+ * The Project's credentials (mode 0600), which `nylorun start` writes beside the link: the
+ * application key and its principal, and the management key and its principal when it issued
+ * one. A format 0 file's legacy `executors` map is ignored.
+ */
+export async function readCredentials(projectRoot) {
+    const path = projectCredentialsPath(projectRoot);
+    let credentials;
+    try {
+        credentials = readProjectCredentials(projectRoot);
+    }
+    catch (error) {
+        if (!(error instanceof ProjectFileError))
+            throw error;
+        throw new CliError(error.reason === "newer"
+            ? `Project credentials at ${path} have an unsupported format. Upgrade nylorun.`
+            : `Invalid Project credentials at ${path}. Remove .nylorun/credentials.json and run "npx nylorun start".`, 1);
+    }
+    if (credentials)
+        await chmod(path, 0o600);
+    return credentials;
+}
+/**
+ * The Project's link and credentials, else `NYLORUN_RUNTIME_URL` with `NYLORUN_SERVER_KEY`, or
+ * `NYLORUN_MANAGEMENT_KEY`, or both; `NYLORUN_MANAGEMENT_KEY` also stands in for a Project
+ * credentials file without one. The installation serves one Tenant, so nothing names it.
+ */
+export async function linkedConnection(projectRoot, env = process.env) {
+    const link = await readLink(projectRoot);
+    const credentials = await readCredentials(projectRoot);
+    const managementKey = env.NYLORUN_MANAGEMENT_KEY?.trim();
+    if (link && credentials) {
+        const management = credentials.managementKey ?? managementKey;
+        return {
+            url: link.hostUrl,
+            key: credentials.applicationKey,
+            ...(management ? { managementKey: management } : {}),
+            link,
+        };
+    }
+    const url = env.NYLORUN_RUNTIME_URL?.trim();
+    const key = env.NYLORUN_SERVER_KEY?.trim();
+    if (url && (key || managementKey))
+        return {
+            url: url.replace(/\/$/, ""),
+            ...(key ? { key } : {}),
+            ...(managementKey ? { managementKey } : {}),
+        };
+    throw new CliError(`No Project link in ${projectRoot}. Run "npx nylorun start" in this project to start its Tenant and link it, or set NYLORUN_RUNTIME_URL and NYLORUN_SERVER_KEY (or NYLORUN_MANAGEMENT_KEY).`, 1);
+}
+/** The Management API client of `connection`; refused without a management key. */
+export function managementClient(connection) {
+    if (!connection.managementKey)
+        throw new CliError(`No management key for the Tenant at ${connection.url}: run npx nylorun start, or set NYLORUN_MANAGEMENT_KEY.`, 1);
+    return createManagementClient({ url: connection.url, key: connection.managementKey });
+}

package/dist/client/project/env.d.ts

@@ -0,0 +1,3 @@
+/** Two `export` lines for `nylo env` (was `nylorun status --env`, F2-7). */
+export declare function printLinkedEnvExports(projectRoot?: string): Promise<void>;
+export declare function shellQuote(value: string): string;

package/dist/client/project/env.js

@@ -0,0 +1,19 @@
+import { findProjectRoot } from "@nylorun/core/project";
+import { readCredentials, readLink } from "./connection.js";
+/** Two `export` lines for `nylo env` (was `nylorun status --env`, F2-7). */
+export async function printLinkedEnvExports(projectRoot = process.cwd()) {
+    const root = findProjectRoot(projectRoot) ?? projectRoot;
+    const link = await readLink(root);
+    const credentials = await readCredentials(root);
+    if (!link || !credentials) {
+        console.log('# No Project link in this directory. Run "npx nylorun start" in this project to start its Tenant and link it.');
+        return;
+    }
+    console.log(`export NYLORUN_RUNTIME_URL=${shellQuote(link.hostUrl)}`);
+    console.log(`export NYLORUN_SERVER_KEY=${shellQuote(credentials.applicationKey)}`);
+}
+export function shellQuote(value) {
+    if (/^[A-Za-z0-9_./:-]+$/.test(value))
+        return value;
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}

package/dist/command.d.ts

@@ -0,0 +1,8 @@
+/** Both commands refuse native Windows before acting; WSL2 runs them. */
+export declare function refuseNativeWindows(): void;
+/**
+ * Run a command (`nylorun` or `nylo`) and exit once stdout and stderr are flushed: with
+ * `process.exitCode` (0 when unset), or after printing a failure's message with its
+ * `CliError` exit code (else 1).
+ */
+export declare function runCommand(main: () => Promise<void>): void;

package/dist/command.js

@@ -0,0 +1,23 @@
+import { CliError } from "./errors.js";
+/** Both commands refuse native Windows before acting; WSL2 runs them. */
+export function refuseNativeWindows() {
+    if (process.platform === "win32")
+        throw new CliError("Nylorun does not run on native Windows. Use WSL2: install Node 24 and Docker (Docker Desktop's WSL integration) inside your WSL distribution and run nylorun there (https://learn.microsoft.com/windows/wsl/install).", 1);
+}
+/**
+ * Run a command (`nylorun` or `nylo`) and exit once stdout and stderr are flushed: with
+ * `process.exitCode` (0 when unset), or after printing a failure's message with its
+ * `CliError` exit code (else 1).
+ */
+export function runCommand(main) {
+    void main().then(() => finish(process.exitCode === undefined ? 0 : Number(process.exitCode)), (error) => {
+        console.error(error instanceof Error ? error.message : String(error));
+        return finish(error instanceof CliError ? error.exitCode : 1);
+    });
+}
+async function finish(code) {
+    process.exitCode = code;
+    for (const stream of [process.stdout, process.stderr])
+        await new Promise((resolve) => stream.write("", () => resolve()));
+    process.exit(code);
+}

package/dist/errors.d.ts

@@ -1,4 +1,4 @@
-/** Exit codes are part of the CLI contract; see cli/README.md. */
+/** Exit codes are part of both commands' contract; see cli/nylorun/README.md ("Exit codes"). */
 export declare class CliError extends Error {
     readonly exitCode: number;
     constructor(message: string, exitCode?: number);

package/dist/errors.js

@@ -1,4 +1,4 @@
-/** Exit codes are part of the CLI contract; see cli/README.md. */
+/** Exit codes are part of both commands' contract; see cli/nylorun/README.md ("Exit codes"). */
 export class CliError extends Error {
     exitCode;
     constructor(message, exitCode = 1) {

package/dist/nylo.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "./baseline.js";

package/dist/nylo.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import "./baseline.js";
+import { runCommand } from "./command.js";
+// `nylo`, the Runtime client (client/). `nylorun`'s entry never imports it, so `npx nylorun start`
+// loads none of it, nor @nylorun/admin.
+runCommand(async () => {
+    const { main } = await import("./client/cli.js");
+    await main(process.argv.slice(2));
+});

package/dist/project/link.d.ts

@@ -31,7 +31,8 @@ export interface KeyCredentials {
 export declare function readProjectCredentials(projectRoot: string): Promise<KeyCredentials | undefined>;
 /**
  * A credentials file (format 0 or 1): the Project's, or one the nylorun commands keep in the
- * Host root. Undefined when absent or unreadable, so `start` replaces it.
+ * Host root. Undefined when absent or unreadable, so `start` replaces it; a newer format is an
+ * error, as for the link, so this release never rewrites it in its own.
  */
 export declare function readCredentialsFile(path: string): Promise<KeyCredentials | undefined>;
 /** `.nylorun/credentials.json` (format 1, mode 0600). */

package/dist/project/link.js

@@ -49,14 +49,17 @@ export async function readProjectCredentials(projectRoot) {
 }
 /**
  * A credentials file (format 0 or 1): the Project's, or one the nylorun commands keep in the
- * Host root. Undefined when absent or unreadable, so `start` replaces it.
+ * Host root. Undefined when absent or unreadable, so `start` replaces it; a newer format is an
+ * error, as for the link, so this release never rewrites it in its own.
  */
 export async function readCredentialsFile(path) {
     let value;
     try {
         value = readCredentials(path);
     }
-    catch {
+    catch (error) {
+        if (error instanceof ProjectFileError && error.reason === "newer")
+            throw new CliError(`Newer credentials at ${error.path}. Upgrade nylorun, or remove the file and run "npx nylorun start" again.`, 1);
         return undefined;
     }
     if (!value)

package/dist/stack/commands.js

@@ -561,7 +561,7 @@ async function linkProject(ctx, started, tenantId) {
             deps.err(`Seeded the Tenant from .env: ${set.join(", ")}.`);
     }
     catch (error) {
-        deps.err(`Warning: could not seed the Tenant from .env (${error instanceof Error ? error.message : String(error)}). Set the model in Studio or with "npx @nylorun/cli configure".`);
+        deps.err(`Warning: could not seed the Tenant from .env (${error instanceof Error ? error.message : String(error)}). Set the model in Studio or with "npx -p nylorun nylo configure".`);
     }
 }
 const START_USAGE = "nylorun start [--tenant <name>] [--no-link] [--no-studio] [--allow-downgrade] [--studio-embed-origin <origin>]... [--studio-embed-origin-reset] [--restate-ui]";

package/dist/stack/compose-file.js

@@ -238,7 +238,16 @@ ${sandboxes ? SANDBOXES_GATES_PORT : ""}    # Egress and the stores; the harness
       NYLORUN_HARNESS: \${NYLORUN_HARNESS:-remote}
       NYLORUN_HARNESS_LISTEN_PORT: "4200"
       NYLORUN_HARNESS_ALLOWED_HOSTS: runtime:4200${sandboxes ? SANDBOXES_HARNESS_HOST : ""}
-      NYLORUN_HARNESS_TOKEN: \${NYLORUN_HARNESS_TOKEN:?run nylorun start}${sandboxes ? SANDBOXES_RUNTIME_ENV : ""}${identity ? IDENTITY_RUNTIME_ENV : ""}
+      NYLORUN_HARNESS_TOKEN: \${NYLORUN_HARNESS_TOKEN:?run nylorun start}
+      # Traces (R7.2): from the shell that runs \`nylorun start\`. Unset, they are
+      # empty and the Runtime exports nothing. A collector on this machine is host.docker.internal.
+      OTEL_EXPORTER_OTLP_ENDPOINT: \${OTEL_EXPORTER_OTLP_ENDPOINT:-}
+      OTEL_EXPORTER_OTLP_TRACES_ENDPOINT: \${OTEL_EXPORTER_OTLP_TRACES_ENDPOINT:-}
+      OTEL_EXPORTER_OTLP_HEADERS: \${OTEL_EXPORTER_OTLP_HEADERS:-}
+      OTEL_SERVICE_NAME: \${OTEL_SERVICE_NAME:-}
+      OTEL_RESOURCE_ATTRIBUTES: \${OTEL_RESOURCE_ATTRIBUTES:-}
+      OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT: \${OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT:-}
+      NYLORUN_TRACE_CONTENT: \${NYLORUN_TRACE_CONTENT:-}${sandboxes ? SANDBOXES_RUNTIME_ENV : ""}${identity ? IDENTITY_RUNTIME_ENV : ""}
     extra_hosts:
       host.docker.internal: host-gateway # the Docker host, also on Linux Docker Engine
     volumes:

package/dist/stack/mcp.d.ts

@@ -1,9 +1,11 @@
 import type { McpPreview } from "@nylorun/core/contracts";
 import { type StackDeps } from "./commands.js";
-export declare const mcpUsage = "  mcp inspect <url> [--server <name>] [--vault <id>] [--sse] [--tenant <name>] [--json]\n                                      list a remote MCP server's tools with the installation vault's\n                                      credential for <url>: model names, schema sizes, renames, or\n                                      that it needs a person's sign-in (the Runtime calls no tool)";
+export declare const mcpUsage = "  mcp inspect <url> [--server <name>] [--environment <id>] [--sse] [--tenant <name>] [--json]\n                                      list a remote MCP server's tools, with Environment <id>'s\n                                      credential for <url> (none without it): model names, schema\n                                      sizes, renames, or that it needs a person's sign-in (the\n                                      Runtime calls no tool)";
+/** What `--vault` says since protocol 11. */
+export declare const MCP_VAULT_REMOVED = "--vault was removed in protocol 11: a credential is a secret of an Environment, in its own vault. Pass --environment <id> to send that Environment's credential for the URL.";
 /** What the removed `connect` subcommand says since protocol 10. */
-export declare const MCP_CONNECT_REMOVED = "The connect subcommand of nylorun mcp was removed with MCP OAuth (protocol 10): add the server's key to an installation vault as a bearer or headers credential (Studio's Credentials page, or @nylorun/admin), or reach a server that needs a person's sign-in through a gateway (a credential with via). See its tools with nylorun mcp inspect <url>.";
+export declare const MCP_CONNECT_REMOVED: string;
 /** A preview as a person reads it: the server, a table of tools, the renames, or the sign-in hint. */
-export declare function previewLines(preview: McpPreview): string[];
+export declare function previewLines(preview: McpPreview, environmentId?: string): string[];
 /** `nylorun mcp <inspect|connect> ...` */
 export declare function mcpCommand(deps: StackDeps, args: readonly string[]): Promise<number>;

package/dist/stack/mcp.js

@@ -2,30 +2,39 @@
  * `nylorun mcp inspect <url>`: a remote MCP server's tools before an agent names it (R2b C12),
  * through the running local Tenant's Management API (`POST /v1/tenant/mcp/preview`) with the
  * Project link's management key, else the Host root's (`runningTenantApi`). It never starts the
- * Tenant, and the Runtime never calls a tool. Its `connect` subcommand (MCP OAuth) was removed
- * in protocol 10, and says so.
+ * Tenant, and the Runtime never calls a tool. `--environment <id>` sends that Environment's
+ * credential for the URL (protocol 11; it replaced `--vault`); an Environment's secrets are
+ * written on the Runtime API (`client.environments.secrets.put` of `@nylorun/agents`). Its
+ * `connect` subcommand (MCP OAuth) was removed in protocol 10, and says so.
  */
 import { PROTOCOL_HEADER, PROTOCOL_VERSION } from "@nylorun/core/compatibility";
 import { CliError } from "../errors.js";
 import { parseStackFlags, runningTenantApi } from "./commands.js";
-export const mcpUsage = `  mcp inspect <url> [--server <name>] [--vault <id>] [--sse] [--tenant <name>] [--json]
-                                      list a remote MCP server's tools with the installation vault's
-                                      credential for <url>: model names, schema sizes, renames, or
-                                      that it needs a person's sign-in (the Runtime calls no tool)`;
-const INSPECT_USAGE = "nylorun mcp inspect <url> [--server <name>] [--vault <id>] [--sse] [--tenant <name>] [--json]";
+export const mcpUsage = `  mcp inspect <url> [--server <name>] [--environment <id>] [--sse] [--tenant <name>] [--json]
+                                      list a remote MCP server's tools, with Environment <id>'s
+                                      credential for <url> (none without it): model names, schema
+                                      sizes, renames, or that it needs a person's sign-in (the
+                                      Runtime calls no tool)`;
+const INSPECT_USAGE = "nylorun mcp inspect <url> [--server <name>] [--environment <id>] [--sse] [--tenant <name>] [--json]";
+/** Where a credential for an MCP server goes since protocol 11. */
+const SECRET_HINT = "write it as a bearer or headers secret of an Environment (client.environments.secrets.put of @nylorun/agents, or Studio)";
+/** What `--vault` says since protocol 11. */
+export const MCP_VAULT_REMOVED = "--vault was removed in protocol 11: a credential is a secret of an Environment, in its own vault. Pass --environment <id> to send that Environment's credential for the URL.";
 /** What the removed `connect` subcommand says since protocol 10. */
-export const MCP_CONNECT_REMOVED = "The connect subcommand of nylorun mcp was removed with MCP OAuth (protocol 10): add the server's key to an installation vault as a bearer or headers credential (Studio's Credentials page, or @nylorun/admin), or reach a server that needs a person's sign-in through a gateway (a credential with via). See its tools with nylorun mcp inspect <url>.";
+export const MCP_CONNECT_REMOVED = `The connect subcommand of nylorun mcp was removed with MCP OAuth (protocol 10): ${SECRET_HINT.replace("write it", "write the server's key")}, or reach a server that needs a person's sign-in through a gateway (a secret with via). See its tools with nylorun mcp inspect <url> --environment <id>.`;
 /** The preview takes up to 15 s in the Runtime; the hop gets a margin. */
 const PREVIEW_TIMEOUT_MS = 30_000;
 const DESCRIPTION_CHARS = 60;
 const usageError = (message) => new CliError(message, 2);
 async function inspect(deps, args) {
-    const flags = parseStackFlags(args, { booleans: ["--json", "--sse"], values: ["--server", "--vault", "--tenant"] }, INSPECT_USAGE);
+    if (args.some((arg) => arg === "--vault" || arg.startsWith("--vault=")))
+        throw usageError(MCP_VAULT_REMOVED);
+    const flags = parseStackFlags(args, { booleans: ["--json", "--sse"], values: ["--server", "--environment", "--tenant"] }, INSPECT_USAGE);
     if (flags.rest.length !== 1)
         throw usageError(`Usage: ${INSPECT_USAGE}`);
     const url = flags.rest[0];
     const name = flags.values.get("--server");
-    const vaultId = flags.values.get("--vault");
+    const environmentId = flags.values.get("--environment");
     const tenant = flags.values.get("--tenant");
     const api = await runningTenantApi(deps, tenant === undefined ? {} : { name: tenant });
     const response = await deps.fetch(`${api.runtimeUrl}/v1/tenant/mcp/preview`, {
@@ -40,7 +49,7 @@ async function inspect(deps, args) {
             url,
             ...(flags.booleans.has("--sse") ? { type: "sse" } : {}),
             ...(name === undefined ? {} : { name }),
-            ...(vaultId === undefined ? {} : { vaultId }),
+            ...(environmentId === undefined ? {} : { environmentId }),
         }),
         redirect: "error",
         signal: AbortSignal.timeout(PREVIEW_TIMEOUT_MS),
@@ -60,15 +69,17 @@ async function inspect(deps, args) {
         deps.out(JSON.stringify(preview, null, 2));
         return 0;
     }
-    for (const line of previewLines(preview))
+    for (const line of previewLines(preview, environmentId))
         deps.out(line);
     return 0;
 }
 /** A preview as a person reads it: the server, a table of tools, the renames, or the sign-in hint. */
-export function previewLines(preview) {
+export function previewLines(preview, environmentId) {
     const credential = preview.credentialSent
-        ? "with the installation vault's credential"
-        : "with no credential (no installation vault holds one for this URL)";
+        ? `with Environment ${environmentId ?? "(unnamed)"}'s credential`
+        : environmentId === undefined
+            ? "with no credential (pass --environment <id> to send an Environment's)"
+            : `with no credential (Environment ${environmentId} holds none for this URL)`;
     if (preview.authRequired) {
         const metadata = preview.authRequired.resourceMetadata;
         const servers = Array.isArray(metadata?.authorization_servers)
@@ -76,13 +87,14 @@ export function previewLines(preview) {
             : [];
         return [
             preview.credentialSent
-                ? `The MCP server at ${preview.url} answered 401: it rejected the installation vault's credential.`
+                ? `The MCP server at ${preview.url} answered 401: it rejected Environment ${environmentId ?? "(unnamed)"}'s credential.`
                 : `The MCP server at ${preview.url} answered 401: it needs a credential.`,
             ...(servers.length > 0
                 ? [`It signs people in with ${servers.join(", ")} (${preview.authRequired.resourceMetadataUrl}).`]
                 : []),
-            "Nylorun holds no OAuth client: add the server's API key to an installation vault, or reach it",
-            "through a gateway that keeps each person's sign-in (a credential with via and an identity header).",
+            `Nylorun holds no OAuth client: ${SECRET_HINT.replace("write it", "write the server's API key")},`,
+            "and pass --environment <id>; or reach it through a gateway that keeps each person's sign-in",
+            "(a secret with via and an identity header).",
         ];
     }
     const info = preview.serverInfo;

package/dist/stack/sandbox.d.ts

@@ -1,4 +1,4 @@
 import { type StackDeps } from "./commands.js";
-export declare const sandboxUsage = "  sandbox ls [--tenant <name>] [--label <key=value>]... [--json]\n                                      the Tenant's sandboxes: id, kind, state, attached sessions and labels\n  sandbox rm <id> [--tenant <name>]   delete a sandbox and its files (refused while a turn runs in it)\n  sandbox enable --context <name> [--tenant <name>] [--host-address <ip>] [--bind-address <ip>] [--no-pull]\n                                      run the Tenant's sandboxes as pods on that kubeconfig context (agent-sandbox v1.0.5)\n  sandbox disable [--tenant <name>] [--delete-namespace]\n                                      stop the sandboxes service and forget the cluster\n  sandbox status [--tenant <name>] [--json]\n                                      the cluster, the sandboxes service's readiness and what it reports";
+export declare const sandboxUsage = "  sandbox ls [--tenant <name>] [--label <key=value>]... [--json]\n                                      the Tenant's Environments: id, kind, state, sessions and labels\n  sandbox rm <id> [--tenant <name>]   delete an Environment: its sandbox, files and vault\n                                      (refused while a turn runs in it)\n  sandbox enable --context <name> [--tenant <name>] [--host-address <ip>] [--bind-address <ip>] [--no-pull]\n                                      run the Tenant's sandboxes as pods on that kubeconfig context (agent-sandbox v1.0.5)\n  sandbox disable [--tenant <name>] [--delete-namespace]\n                                      stop the sandboxes service and forget the cluster\n  sandbox status [--tenant <name>] [--json]\n                                      the cluster, the sandboxes service's readiness and what it reports";
 /** `nylorun sandbox <ls|rm|enable|disable|status> ...` */
 export declare function sandboxCommand(deps: StackDeps, args: readonly string[]): Promise<number>;

package/dist/stack/sandbox.js

@@ -1,8 +1,8 @@
 /**
- * `nylorun sandbox ls | rm`: the running local Tenant's sandbox resources (Host feature
- * `sandboxes`), through its Tenant API with an operator key (`runningTenantApi`). Neither starts the
- * Tenant. `nylorun sandbox enable|disable|status` (sandbox pods on a cluster, F7.2) live in
- * `../sandbox/commands.ts`.
+ * `nylorun sandbox ls | rm`: the running local Tenant's Environments (protocol 11: each holds one
+ * sandbox and one vault), through its Runtime API with the application key (`runningTenantApi`).
+ * Neither starts the Tenant. `nylorun sandbox enable|disable|status` (sandbox pods on a cluster,
+ * F7.2) live in `../sandbox/commands.ts`.
  */
 import { PROTOCOL_HEADER, PROTOCOL_VERSION } from "@nylorun/core/compatibility";
 import { CliError } from "../errors.js";
@@ -10,8 +10,9 @@ import { runSandboxCommand, sandboxUsage as clusterUsage } from "../sandbox/comm
 import { spawnKubectl } from "../sandbox/kubectl.js";
 import { parseStackFlags, runningTenantApi } from "./commands.js";
 export const sandboxUsage = `  sandbox ls [--tenant <name>] [--label <key=value>]... [--json]
-                                      the Tenant's sandboxes: id, kind, state, attached sessions and labels
-  sandbox rm <id> [--tenant <name>]   delete a sandbox and its files (refused while a turn runs in it)
+                                      the Tenant's Environments: id, kind, state, sessions and labels
+  sandbox rm <id> [--tenant <name>]   delete an Environment: its sandbox, files and vault
+                                      (refused while a turn runs in it)
 ${clusterUsage}`;
 const usageError = (message) => new CliError(message, 2);
 async function call(deps, api, method, path) {
@@ -26,8 +27,8 @@ async function call(deps, api, method, path) {
         signal: AbortSignal.timeout(15_000),
     });
     const body = (await response.json().catch(() => ({})));
-    if (response.status === 404 && path === "/v1/sandboxes")
-        throw new CliError(`Tenant ${api.name} runs a Runtime without sandboxes. Update it: npx nylorun@latest start.`, 1);
+    if (response.status === 404 && /^\/v1\/environments(\?|$)/.test(path))
+        throw new CliError(`Tenant ${api.name} runs a Runtime without Environments. Update it: npx nylorun@latest start.`, 1);
     if (!response.ok && response.status !== 404)
         throw new CliError(`${method} ${path} returned ${response.status}${typeof body.message === "string" ? `: ${body.message}` : ""}`, 1);
     return { status: response.status, body };
@@ -50,24 +51,24 @@ async function ls(deps, args) {
     const name = flags.values.get("--tenant");
     const api = await runningTenantApi(deps, name === undefined ? {} : { name });
     const search = query.toString();
-    const { body } = await call(deps, api, "GET", `/v1/sandboxes${search ? `?${search}` : ""}`);
-    const sandboxes = (body.sandboxes ?? []);
+    const { body } = await call(deps, api, "GET", `/v1/environments${search ? `?${search}` : ""}`);
+    const environments = (body.environments ?? []);
     if (flags.booleans.has("--json")) {
-        deps.out(JSON.stringify(sandboxes, null, 2));
+        deps.out(JSON.stringify(environments, null, 2));
         return 0;
     }
-    if (sandboxes.length === 0) {
-        deps.out(`No sandboxes on Tenant ${api.name}.`);
+    if (environments.length === 0) {
+        deps.out(`No Environments on Tenant ${api.name}.`);
         return 0;
     }
     const rows = [
         ["ID", "KIND", "STATE", "SESSIONS", "LABELS"],
-        ...sandboxes.map((sandbox) => [
-            sandbox.id,
-            sandbox.kind,
-            sandbox.state,
-            String(sandbox.sessions.length),
-            labelsText(sandbox.labels),
+        ...environments.map((environment) => [
+            environment.id,
+            environment.kind,
+            environment.state,
+            String(environment.sessions.length),
+            labelsText(environment.labels),
         ]),
     ];
     const widths = rows[0].map((_, column) => Math.max(...rows.map((row) => row[column].length)));
@@ -85,12 +86,12 @@ async function rm(deps, args) {
     const id = flags.rest[0];
     const name = flags.values.get("--tenant");
     const api = await runningTenantApi(deps, name === undefined ? {} : { name });
-    const { status, body } = await call(deps, api, "DELETE", `/v1/sandboxes/${encodeURIComponent(id)}`);
+    const { status, body } = await call(deps, api, "DELETE", `/v1/environments/${encodeURIComponent(id)}`);
     if (status === 404 || body.deleted !== true) {
-        deps.err(`No sandbox ${id} on Tenant ${api.name}.`);
+        deps.err(`No Environment ${id} on Tenant ${api.name}.`);
         return 1;
     }
-    deps.out(`Deleted sandbox ${id} and its files.`);
+    deps.out(`Deleted Environment ${id}: its sandbox, files and vault.`);
     return 0;
 }
 /** `nylorun sandbox <ls|rm|enable|disable|status> ...` */

package/dist/stack/versions.d.ts

@@ -1,7 +1,7 @@
-/** An image this CLI release pins in `cli/package.json` `nylorun` (D7). */
+/** An image this CLI release pins in its `package.json` `nylorun` (D7). */
 export type PinnedImage = "runtime" | "studio";
 /**
- * The version this CLI release pins for an image, from `cli/package.json`
+ * The version this CLI release pins for an image, from its `package.json`
  * `nylorun.runtime` or `nylorun.studio`: the tag of `ghcr.io/nylorun/<name>`
  * a local Tenant runs unless `NYLORUN_RUNTIME_IMAGE` / `NYLORUN_STUDIO_IMAGE`
  * overrides it. The release tooling writes both pins.

package/dist/stack/versions.js

@@ -3,11 +3,11 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { CliError } from "../errors.js";
 function cliPackageJsonPath() {
-    // src/stack/*.ts and dist/stack/*.js both sit two levels below cli/.
+    // src/stack/*.ts and dist/stack/*.js both sit two levels below the package root.
     return join(dirname(fileURLToPath(import.meta.url)), "..", "..", "package.json");
 }
 /**
- * The version this CLI release pins for an image, from `cli/package.json`
+ * The version this CLI release pins for an image, from its `package.json`
  * `nylorun.runtime` or `nylorun.studio`: the tag of `ghcr.io/nylorun/<name>`
  * a local Tenant runs unless `NYLORUN_RUNTIME_IMAGE` / `NYLORUN_STUDIO_IMAGE`
  * overrides it. The release tooling writes both pins.
@@ -22,7 +22,7 @@ export function pinnedVersion(name) {
     }
     const version = raw?.nylorun?.[name];
     if (typeof version !== "string" || version.trim() === "") {
-        throw new CliError(`cli/package.json is missing "nylorun.${name}" (the pinned ${name} image version).`, 1);
+        throw new CliError(`nylorun's package.json is missing "nylorun.${name}" (the pinned ${name} image version).`, 1);
     }
     return version;
 }

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "nylorun",
-  "version": "0.12.2-beta",
+  "version": "0.14.0-beta",
   "type": "module",
   "license": "Apache-2.0",
-  "description": "Set up and run local Nylorun Tenants (Runtime and Studio) with Docker Compose",
+  "description": "Set up and run local Nylorun Tenants (Runtime and Studio) with Docker Compose (nylorun), and the Runtime client of the linked installation (nylo)",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nylorun/agents.git",
-    "directory": "nylorun"
+    "directory": "cli/nylorun"
   },
   "files": [
     "dist",
@@ -23,25 +23,29 @@
     "node": ">=24.0.0"
   },
   "scripts": {
-    "build": "npm run clean && node ../scripts/check-typescript-version.mjs && tsc -p tsconfig.json",
+    "build": "npm run clean && node ../../scripts/check-typescript-version.mjs && tsc -p tsconfig.json",
     "clean": "node -e \"import('node:fs').then(({rmSync})=>rmSync('dist',{recursive:true,force:true}))\"",
     "check": "npm run build && npm test && node scripts/check-package.mjs",
     "test": "vitest run --passWithNoTests",
     "prepack": "npm run build"
   },
   "dependencies": {
-    "@nylorun/core": "0.19.0-beta"
+    "@nylorun/core": "0.20.0-beta",
+    "@nylorun/admin": "0.16.0-beta"
   },
   "devDependencies": {
+    "@earendil-works/pi-ai": "0.99.1",
+    "@nylorun/agents": "file:../../sdks/agents",
     "typescript": "npm:@typescript/typescript6@^6.0.2",
-    "@types/node": "^26.5.0",
+    "@types/node": "^26.6.4",
     "vitest": "^5.0.2"
   },
   "bin": {
-    "nylorun": "dist/cli.js"
+    "nylorun": "dist/cli.js",
+    "nylo": "dist/nylo.js"
   },
   "nylorun": {
-    "runtime": "0.22.0-beta",
-    "studio": "0.23.2-beta"
+    "runtime": "0.24.0-beta",
+    "studio": "0.24.0-beta"
   }
 }