@nylorun/cli 0.9.0-beta → 0.12.0-beta

package/CHANGELOG.md

@@ -1,5 +1,99 @@
 # @nylorun/cli
 
+## 0.12.0-beta
+
+### Major Changes
+
+- c135267: **Action endpoints are removed (manifest-only agents, M6).** The Runtime runs no code of yours during a session: an agent's tools are HTTP tools, remote MCP servers, agents used as tools and the Runtime's built-ins. Protocol stays 8; the `action-endpoints` feature is gone, so a client that requires it is refused. See MIGRATION.md, "Action endpoints are removed".
+
+  - **Breaking (`@nylorun/core`):** the `Action`, endpoint (`PutEndpointsRequest`, `Endpoint`, `EndpointHealth`, …) and delivery schemas, `SIGNATURE_HEADER`, `OUTCOME_HEADER`, `DELIVERY_TOKEN_TYPE` and the `action.*` events (`action.pending`, `.delivered`, `.delivery_failed`, `.completed`, `.uncertain`) are removed, and `ToolDefinition.background` with them. `ActionOutcome` is renamed `EffectOutcome`. Tenant status loses `checks.endpoints`, `agents[].registered` and `agents[].endpoint`, and `counts.pendingActions`; the session view loses `actions`. A `turn.paused` interaction carries the tool call's `callId`. New `codeToolsOf` and `codeToolRefusal` name a definition's tools that would run your code. The Harness API is v2 (`HARNESS_API_VERSION = 2`): `TurnStart.options.holdMs` and `effect.resolved` are removed.
+  - **Breaking (`@nylorun/harness`):** held runs are gone: `createHarness` loses `holdMs`, and `apiHost` its `hold` option.
+  - **Breaking (`@nylorun/agents`):** `createActionHandler`, `executeAction`, `createActionSandbox`, `definitionDeclaresSandbox`, `isActionSandboxTool` and the `Action`, `ActionOutcome`, `ActionHandler`, `ActionHandlerOptions`, `RegisterOptions`, `ExecuteActionOptions` and `ExecutableDefinition` types are removed. `saveAgent` refuses a code tool (`tool({ run })`) or a flow tool stage before sending; its `implementationVersion` is optional (`NYLORUN_IMPLEMENTATION_VERSION`, else `dev`).
+  - **Breaking (`@nylorun/runtime`):** `/v1/endpoints` and `/v1/actions/*` answer `404`; delivery tokens, the deliverer, background tools, held runs (`TenantConfig.actionHoldMs`), `DurableExecution.deliver`, the Restate `NylorunAction` object, the `action_result` wake and the gates service's `/nylorun/v1/deliveries` are removed, and a migration drops the `actions` and `endpoints` tables. `PUT /v1/agents/:id` refuses a definition with a code tool or a flow tool stage (`400`); a tool the Runtime cannot run fails with `tool.unavailable`. The fixture model answers in text when the agent offers no `lookup_order` tool.
+  - **Breaking (`@nylorun/cli`):** `nylo endpoints` is removed (a usage error that says why); `nylo status` shows uncertain effects instead of pending Actions.
+  - **Breaking (`@nylorun/create-agent`):** the starter saves its agent with `saveAgent` and runs no server: no Action endpoint, `PORT` or `NYLORUN_ACTIONS_URL`. Its assistant has no tools, with a commented `http()` tool to start from.
+  - `nylorun`: the local stack's comments speak of MCP servers and HTTP tools on this machine, not Action endpoints.
+  - `@nylorun/studio`: the `action.*` event views and delivery status are removed; the chat shows `tool.completed`, and the Agent Manifest tab lists tools without a target as code tools.
+
+### Patch Changes
+
+- Pin agents to the tested release.
+- Pin admin to the tested release.
+- Updated dependencies [4bd2a0b]
+- Updated dependencies [a64aaca]
+- Updated dependencies [40b7648]
+- Updated dependencies [713e676]
+- Updated dependencies [c135267]
+- Updated dependencies [d36f0d9]
+- Updated dependencies [107b07d]
+- Updated dependencies
+- Updated dependencies
+  - @nylorun/agents@0.16.0-beta
+  - @nylorun/admin@0.11.1-beta
+
+## 0.11.0-beta
+
+### Minor Changes
+
+- 3b3bdc6: **The clients use management keys (Runtime and Management APIs, step A3).** The protocol stays at 7; every client keeps working against a protocol 7 Runtime's routes.
+
+  - `nylorun`: `nylorun start` keeps an application key (`project`) and a management key (`project-management`) for a Project, in `<Host root>/project-credentials.json` and the Project's `.nylorun/credentials.json` (still format 1, with new `managementKey` and `managementPrincipalId` fields). A credentials file holding only an application key gains a management key at the next start. Commands outside a project keep `cli` and `cli-management`. Keys are issued through `nylorun-operate` in the runtime container instead of the Admin API, and `nylorun key put <id> --management` puts a management key. Seeding the Tenant and `nylorun mcp connect` use the management key (`/v1/tenant/vaults`). Studio reaches the Runtime's public listener.
+  - `@nylorun/cli`: `status`, `reset`, `configure`, `doctor` and `access signing-keys` use the Management API through `@nylorun/admin` with the Project's management key, or `NYLORUN_MANAGEMENT_KEY`.
+  - `@nylorun/studio`: local Studio needs no login. A request on the published loopback address (`localhost` or `127.0.0.1` at Studio's port) acts as signed in; hosts behind a sign-in proxy and embedding keep their login, and state-changing requests still need Studio's own `Origin`. Studio learns its Tenant from `GET /v1/tenant` with its key instead of the Admin API, and its Connections page manages vaults through `@nylorun/admin/client` at `/v1/tenant/vaults`.
+  - **Breaking (`@nylorun/admin`, `@nylorun/runtime`): Studio's key is derived from the admin key alone.** `deriveStudioToken(adminKey)` takes no Tenant id (HMAC-SHA256 over `nylorun/studio/v2`). The Host registers the new key's hash at its next start, replacing the old one; an app that embeds Studio and derives its key must update.
+  - `@nylorun/core`: `ProjectCredentialsFileSchema` gains optional `managementKey` and `managementPrincipalId`.
+
+- 7f763c3: **The Admin API and the operator listener are gone (Runtime and Management APIs, step A5).** Host work moves to the machine: `nylorun` runs `nylorun-operate` inside the runtime container, and every remote client uses the Runtime API or the Management API.
+
+  - **Breaking (`@nylorun/runtime`):** `/v1/admin/*` (status, host, shutdown, keys, openapi.json) is removed; it answers like any unknown route. The operator listener, `NYLORUN_ADMIN_LISTEN_PORT`, `NYLORUN_ADMIN_LISTEN_HOST`, `NYLORUN_ADMIN_ALLOWED_HOSTS` and `host.json`'s `adminPort` are gone, and so is the `admin-openapi.json` package file. Stop the Host with SIGTERM. `nylorun-operate status [--json]` reports the version, protocol and the Tenant's id, name, state and cause, exiting 2 when the Tenant is not open. `/ready` adds `harness: { mode, connected }` while the Tenant is open. `startEphemeralRuntime` loses `operatorListener` and `adminUrl`. The admin key stays: it derives Studio's key.
+  - **Breaking (`@nylorun/admin`):** `createAdmin()` is the Management API client (`tenant`, `keys`, `models`, `vaults`, `signingKeys`, `settings`) with a management key: explicit `{ url, key }`, else `NYLORUN_RUNTIME_URL` + `NYLORUN_MANAGEMENT_KEY`, else the Project link's or the local Host root's management key. `status()`, `adminUrl`, the Admin API keys, `NYLORUN_ADMIN_URL`/`NYLORUN_ADMIN_KEY` and `OPERATOR_KEYS_FEATURE` are removed; `deriveStudioToken` and `mintStudioLoginToken` stay.
+  - **Breaking (`@nylorun/core`):** `admin-status` leaves `PROTOCOL_FEATURES` (the Host still advertises it for protocol 5–7 clients) and `operator-keys` is removed; `AdminStatusSchema`, `AdminHostStatusSchema`, `HostAggregateSchema` and `HostShutdownResponseSchema` are removed.
+  - **Breaking (`nylorun`):** no admin port: `NYLORUN_ADMIN_PORT` is no longer written or published (an existing one is ignored). `nylorun start` waits for `/ready`, and `nylorun status` reads readiness from `/ready` and the Tenant from `nylorun-operate status`.
+  - `@nylorun/cli`: `nylo status` no longer falls back to the Admin API; when the Tenant does not answer it points to `npx nylorun status`.
+
+### Patch Changes
+
+- Pin agents to the tested release.
+- Pin admin to the tested release.
+- Updated dependencies [3b3bdc6]
+- Updated dependencies [a6108f4]
+- Updated dependencies [b28bdd7]
+- Updated dependencies [7f763c3]
+- Updated dependencies [98b0d37]
+- Updated dependencies [c66d8ed]
+- Updated dependencies
+- Updated dependencies
+  - @nylorun/agents@0.15.0-beta
+  - @nylorun/admin@0.11.0-beta
+
+## 0.10.0-beta
+
+### Major Changes
+
+- bd478ee: **Subject tokens, browser keys and derived principals leave open source (F9 I3, protocol 7).** Upgrade these with the Runtime: they speak protocol 7, which this Runtime serves beside 4, 5 and 6; protocol 6 clients keep working on every route that remains. Browsers and apps present a trusted issuer's token (F9 I2), servers an operator key (F9 I1), and a person's own credentials come from the operator's credential resolver (F9 C1). See MIGRATION.md.
+
+  - **Breaking (`@nylorun/runtime`, `@nylorun/core`): subject tokens are gone.** `POST /v1/tokens`, `POST /v1/access/revocations`, subject-token verification, revocation epochs and the `subject.revoked` stream signal are removed; the routes answer `404`, and a JWT no trusted issuer signed is the opaque `404`. A stream opened with a token now ends only at its expiry (`event: nylorun.closed`, reason `token_expired`; `StreamClosedFrame` loses `revoked`). Migration `0010_oss_auth_removals` drops the `subject_epochs`, `subject_usage` and `publishable_keys` tables. The `token` caller is a trusted issuer's token only: it loses `role`, `limits` and `epoch`, and `issuer` is always set; `GET /v1/me` no longer reports `via: token`. Core drops `SUBJECT_TOKEN_TYPE`, `SUBJECT_TOKEN_AUDIENCE`, `subjectTokenIssuer` (the Runtime's own tokens use `tenantTokenIssuer`, same value), `CreateTokenRequest`/`Response`, `RevokeSubject*`, `SubjectTokenClaims`, `TOKEN_TTL_MIN_SECONDS` and `TOKEN_TTL_DEFAULT_SECONDS`; `TOKEN_SCOPES` is `agents:read`, `sessions:own`, `sandboxes:write`.
+  - **Breaking (`@nylorun/runtime`, `@nylorun/core`): the access policy and role limits are gone.** `GET`/`PUT /v1/access/policy` answer `404`, a turn is never refused with `429 limit_exceeded` for a role (limit requests at your proxy), and an existing `access.policy` setting is ignored. Core drops `AccessPolicy*`, `AccessRole*`, `RoleLimits*`, `DEFAULT_ACCESS_POLICY`, `PutAccessPolicyRequest` and `ROLE_NAME_PATTERN`.
+  - **Breaking (`@nylorun/runtime`, `@nylorun/core`): publishable keys and the Runtime's CORS are gone.** `/v1/access/publishable-keys*` answer `404`, `Nylorun-Key` is ignored, `NYLORUN_BROWSER_ACCESS` and `browserAccess` (host.json, `createHost`, `startEphemeralRuntime`) are removed, and the Runtime sends no CORS headers. A request with `Origin` reaches the Tenant routes of the public listener with no toggle: a trusted issuer's token is served, an application key or delivery token is `403 origin_rejected`; admin routes, `/health`, `/ready` and the operator listener still refuse `Origin`. Any `OPTIONS` request is `204` with `Allow` and no CORS header: the operator's proxy answers preflights. Route declarations lose `browser` (`x-nylorun-browser` leaves the OpenAPI document) and the `publishable` credential; the token security scheme is `issuerToken`. Core drops `PUBLISHABLE_KEY_HEADER`, `PUBLISHABLE_KEY_PATTERN`, `PUBLISHABLE_KEY_ID_PATTERN`, `tenantOfPublishableKey`, `newPublishableKey`, `newPublishableKeyId`, `PublishableKey*`, `OriginEntrySchema`, `originAllowed` and `LOOPBACK_ORIGIN_WILDCARDS`.
+  - **Breaking (`@nylorun/runtime`, `@nylorun/core`, `@nylorun/agents`): vault routes are application-only, and `vaults:own` is retired.** Every `/v1/vaults` route takes an application key acting for no one (operator keys, Studio); a request acting for a subject or a trusted issuer's token gets `403 scope_required`. `vaults:own` leaves `SUBJECT_SCOPES`, `TOKEN_SCOPES` and the issuer scopes; `Nylorun-Scopes` may still name it and it grants nothing. Existing user vaults stay attachable to their own owner's sessions. `client.createVault` takes `{ scope: "installation" }` or `ownerUserId`, and `client.listVaults()` takes an optional owner.
+  - **Breaking (`@nylorun/runtime`, `@nylorun/core`, `@nylorun/admin`, `nylorun`): derived principals are gone.** Only Studio's key is derived from the admin key. `NYLORUN_DERIVED_PRINCIPALS` is ignored and no longer written, `hostPrincipals` takes no `derived`, `startEphemeralRuntime` no `derivedPrincipals`, and `@nylorun/admin` drops `deriveTenantKey`, `PROJECT_PRINCIPAL_ID` and `admin.deriveTenantKey`. Keys an earlier Host derived stay in the database and keep working as ordinary keys; replace them with operator keys. Core renames `DERIVED_PRINCIPAL_ID_PATTERN` to `APPLICATION_KEY_ID_PATTERN`.
+  - **Breaking (`@nylorun/agents`):** `createTokenEndpoint`, `createBrowserClient` and the `@nylorun/agents/browser` entry, `client.tokens`, `TokensClient`, `PublishableKeysClient`, `client.access.getPolicy`/`putPolicy`/`revokeSubject`/`publishableKeys` and `Destination.publishableKey` are removed. `client.access.signingKeys` and `client.access.jwks()` stay, and `Destination.token` takes a trusted issuer's tokens.
+  - **Breaking (`@nylorun/cli`):** `nylo access policy|keys|revoke|token` are removed and name what replaces them; `nylo access signing-keys list|rotate|revoke` stays.
+  - **Breaking (`@nylorun/core`, `@nylorun/agents`, `@nylorun/studio`): the Studio embed message `open.babai` is now `open.session`** (`{ sessionId }`): it asks the embedding app to open that session in its own UI. Studio sends no such message itself.
+  - **Breaking (`nylorun`): Studio embedding is opt-in.** No origin may frame Studio by default; list your app's origins with `nylorun start --studio-embed-origin <origin>`. A Tenant's `.env` from an earlier nylorun keeps the origins it had until `--studio-embed-origin-reset`.
+  - `PROTOCOL_VERSION` is 7 and `HOST_PROTOCOL` 4–7; the Host features `subject-tokens`, `browser-access` and `derived-principals` are removed. `@nylorun/studio` and `@nylorun/create-agent` speak protocol 7.
+
+### Patch Changes
+
+- Pin agents to the tested release.
+- Pin admin to the tested release.
+- Updated dependencies [5cfaed9]
+- Updated dependencies [bd478ee]
+- Updated dependencies
+- Updated dependencies
+  - @nylorun/agents@0.14.0-beta
+  - @nylorun/admin@0.10.0-beta
+
 ## 0.9.0-beta
 
 ### Major Changes

package/README.md

@@ -17,16 +17,19 @@ npx @nylorun/cli status               # the linked Tenant
 ```sh
 nylo status [--json]                  # the Tenant, its checks and counts
 nylo reset [--sessions|--sandboxes|--all] [--yes]
-nylo endpoints [--json]|ping <agent>  # the registered Action endpoints and their health
-nylo access …                         # access policy, publishable and signing keys, subject tokens
+nylo access signing-keys …            # the Tenant's signing keys: list, rotate, revoke
 nylo configure                        # set or replace the Tenant's model provider
 nylo env                              # export lines for the linked Project
-nylo doctor sandbox [--json]          # sandbox backend via the Tenant API
+nylo doctor sandbox [--json]          # sandbox backend via the Management API
 ```
 
 Every command acts on the linked installation: the Project link and
 credentials (below), or `NYLORUN_RUNTIME_URL` and `NYLORUN_SERVER_KEY` when the
 Project has no link. An installation serves one Tenant, so nothing selects it.
+`status`, `reset`, `access`, `configure` and `doctor` use the Management API
+with the Project's management key, or `NYLORUN_MANAGEMENT_KEY` (with
+`NYLORUN_RUNTIME_URL` when there is no link); `endpoints` uses the Runtime API
+with the application key.
 
 Local Tenant commands (`up`, `down`, `start`, `stop`, `logs`, `studio`) exit 2
 naming `npx nylorun <command>`. `nylo tenant …` exits 2: `npx nylorun start`
@@ -37,11 +40,11 @@ replace `nylo tenant status|reset|endpoints`. `nylorun dev` was removed: run
 
 ## `nylo status`
 
-Reads the Tenant API status (`GET /v1/tenant`) and prints the Tenant, the
-Runtime URL, the checks, the counts and the sandbox
+Reads the Management API's status (`GET /v1/tenant`, with a management key) and
+prints the Tenant, the Runtime URL, the checks, the counts and the sandbox
 backend. When the Tenant is not open it does not answer; `nylo status` then
-asks the Admin API (`/v1/admin/status`, through the local Tenant's Host root or
-`NYLORUN_ADMIN_URL` and `NYLORUN_ADMIN_KEY`) and prints why, with the repair.
+fails and says to run `npx nylorun status`, which reports why from the
+Runtime's container (`nylorun-operate status`).
 
 ## `nylo reset`
 
@@ -55,16 +58,18 @@ not in a terminal. The Project link and credentials are kept.
 
 - `.nylorun/link.json`: `{ format: 3, tenant, hostUrl, hostId, tenantId }`
   (`tenant` is the local Tenant's name; `tenantId` is information)
-- `.nylorun/credentials.json`: the key of the derived principal `project` and
-  its id (0600)
+- `.nylorun/credentials.json` (0600): the application key `project` and the
+  management key `project-management`, with their ids (`applicationKey`,
+  `principalId`, `managementKey`, `managementPrincipalId`)
 - `.nylorun/.gitignore` containing `*`
 
 A link from an older nylorun (format 0 to 2): `nylo` refuses it and says to run
 `npx nylorun start`, which links the project again.
 
-`createActionHandler` and `createClient` in `@nylorun/agents` read the link (or
-the two variables), so the project's `npm run dev` and `npm start` need no
-Nylorun tool.
+`createClient` in `@nylorun/agents` reads the link (or the two variables), so the
+project's `npm run dev` and `npm start`, which save its agents, need no Nylorun tool.
+`nylo endpoints` was removed with Action endpoints (protocol 8): the Runtime runs no code
+of yours during a session.
 
 ```sh
 eval "$(npx @nylorun/cli env)"
@@ -86,7 +91,9 @@ eval "$(npx @nylorun/cli env)"
 | Symptom | What to do |
 | --- | --- |
 | No Runtime answers | `npx nylorun start`, then `npx nylorun status` |
-| Tenant not open | `nylo status` shows the cause and its `repair` |
+| Tenant not open | `npx nylorun status` shows the cause and its `repair` |
+| No management key | `npx nylorun start` in the project writes one; elsewhere set `NYLORUN_MANAGEMENT_KEY` |
+| `403 key_role_mismatch` | The key belongs to the other API: a management key for the Management API, an application key for the Runtime API |
 | Old Project link refused | `npx nylorun start` in the project |
 | `426` from the Runtime | Upgrade the CLI, or pin a matching older set |
 

package/dist/access/commands.d.ts

@@ -1,24 +1,8 @@
-import { type AgentsClient } from "@nylorun/agents";
-export declare const accessUsage = "nylo access <policy|keys|signing-keys|revoke|token>\n\n  policy get                         print the access policy\n  policy set <file>                  replace it with a JSON file\n  policy init                        write a starter \"user\" role (sessions:own agents:read, every agent,\n                                     60 turns per hour, 2 at once)\n  signing-keys list                  list the signing keys\n  signing-keys rotate [--force]      rotate; --force signs outstanding tokens out\n  signing-keys revoke <kid>          revoke a previous or standby key\n  keys list                          list the publishable keys\n  keys create --name <n> [--origin <o>]\u2026\n                                     a publishable key for a web page or an app\n                                     (origins: https://app.example.com or http://localhost:*)\n  keys set-origins <id> [<o>\u2026]       replace a key's origins ([] for native apps only)\n  keys revoke <id>                   revoke a publishable key\n  revoke <subject>                   end a subject's tokens and open streams\n  token --subject <s> --role <r> [--ttl <seconds>]\n                                     mint a subject token (for trying the API with curl)";
-/** The starter policy `policy init` writes. */
-export declare const STARTER_POLICY: {
-    version: 1;
-    roles: {
-        user: {
-            scopes: ("agents:read" | "sessions:own")[];
-            agents: "*";
-            limits: {
-                turnsPerHour: number;
-                concurrentTurns: number;
-            };
-        };
-    };
-    anon: {
-        scopes: never[];
-        agents: never[];
-    };
-    tokens: {
-        maxTtlSeconds: number;
-    };
-};
-export declare function accessCommand(input: readonly string[], client?: () => Promise<AgentsClient>): Promise<void>;
+/**
+ * `nylo access`: the linked Tenant's signing keys, which sign capability links and run tokens,
+ * through the Management API with the Project's management key. (Subject tokens, the
+ * access policy, browser keys and revocations left the Runtime in protocol 7.)
+ */
+import type { ManagementClient } from "@nylorun/admin";
+export declare const accessUsage = "nylo access signing-keys <list|rotate|revoke>\n\n  signing-keys list                  list the signing keys\n  signing-keys rotate [--force]      rotate; --force ends outstanding links and run tokens\n  signing-keys revoke <kid>          revoke a previous or standby key";
+export declare function accessCommand(input: readonly string[], client?: () => Promise<ManagementClient>): Promise<void>;

package/dist/access/commands.js

@@ -1,91 +1,20 @@
-/**
- * `nylo access`: the linked Tenant's access policy, signing keys and revocations, and a
- * development command that mints a subject token (Host feature `subject-tokens`). Uses the
- * Project's application key, like every other Tenant command.
- */
-import { readFile } from "node:fs/promises";
-import { createClient, resolveConnection, } from "@nylorun/agents";
 import { CliError } from "../errors.js";
-export const accessUsage = `nylo access <policy|keys|signing-keys|revoke|token>
+import { linkedConnection, managementClient } from "../project/connection.js";
+import { findProjectRoot } from "../project/root.js";
+export const accessUsage = `nylo access signing-keys <list|rotate|revoke>
 
-  policy get                         print the access policy
-  policy set <file>                  replace it with a JSON file
-  policy init                        write a starter "user" role (sessions:own agents:read, every agent,
-                                     60 turns per hour, 2 at once)
   signing-keys list                  list the signing keys
-  signing-keys rotate [--force]      rotate; --force signs outstanding tokens out
-  signing-keys revoke <kid>          revoke a previous or standby key
-  keys list                          list the publishable keys
-  keys create --name <n> [--origin <o>]…
-                                     a publishable key for a web page or an app
-                                     (origins: https://app.example.com or http://localhost:*)
-  keys set-origins <id> [<o>…]       replace a key's origins ([] for native apps only)
-  keys revoke <id>                   revoke a publishable key
-  revoke <subject>                   end a subject's tokens and open streams
-  token --subject <s> --role <r> [--ttl <seconds>]
-                                     mint a subject token (for trying the API with curl)`;
-/** The starter policy `policy init` writes. */
-export const STARTER_POLICY = {
-    version: 1,
-    roles: {
-        user: {
-            scopes: ["sessions:own", "agents:read"],
-            agents: "*",
-            limits: { turnsPerHour: 60, concurrentTurns: 2 },
-        },
-    },
-    anon: { scopes: [], agents: [] },
-    tokens: { maxTtlSeconds: 600 },
-};
+  signing-keys rotate [--force]      rotate; --force ends outstanding links and run tokens
+  signing-keys revoke <kid>          revoke a previous or standby key`;
 const usageError = (message = accessUsage) => new CliError(message, 2);
 async function linkedClient() {
-    let connection;
-    try {
-        connection = await resolveConnection();
-    }
-    catch (error) {
-        throw new CliError(error instanceof Error ? error.message : String(error), 1);
-    }
-    return createClient({ url: connection.url, key: connection.key });
+    return managementClient(await linkedConnection(findProjectRoot() ?? process.cwd()));
 }
 const print = (value) => console.log(JSON.stringify(value, null, 2));
-function option(args, name) {
-    const index = args.indexOf(name);
-    if (index === -1)
-        return undefined;
-    const value = args[index + 1];
-    if (!value || value.startsWith("--"))
-        throw usageError(`${name} requires a value.`);
-    args.splice(index, 2);
-    return value;
-}
 export async function accessCommand(input, client = linkedClient) {
-    const [topic, action, ...rest] = input;
-    const args = [...rest];
-    if (topic === "policy") {
-        if (action === "get" && args.length === 0)
-            return print(await (await client()).access.getPolicy());
-        if (action === "init" && args.length === 0)
-            return print(await (await client()).access.putPolicy(STARTER_POLICY));
-        if (action === "set" && args.length === 1) {
-            let parsed;
-            try {
-                parsed = JSON.parse(await readFile(args[0], "utf8"));
-            }
-            catch (error) {
-                throw new CliError(`Could not read ${args[0]}: ${error instanceof Error ? error.message : String(error)}`, 1);
-            }
-            // Accept the file as the policy itself or as `{ policy }`, as `policy get` prints it.
-            const candidate = parsed && typeof parsed === "object" && "policy" in parsed
-                ? parsed.policy
-                : parsed;
-            // The Runtime validates it and names what is wrong.
-            return print(await (await client()).access.putPolicy(candidate));
-        }
-        throw usageError();
-    }
+    const [topic, action, ...args] = input;
     if (topic === "signing-keys") {
-        const keys = async () => (await client()).access.signingKeys;
+        const keys = async () => (await client()).signingKeys;
         if (action === "list" && args.length === 0)
             return print(await (await keys()).list());
         if (action === "rotate") {
@@ -98,47 +27,7 @@ export async function accessCommand(input, client = linkedClient) {
             return print(await (await keys()).revoke(args[0]));
         throw usageError();
     }
-    if (topic === "keys") {
-        const keys = async () => (await client()).access.publishableKeys;
-        if (action === "list" && args.length === 0)
-            return print(await (await keys()).list());
-        if (action === "create") {
-            const name = option(args, "--name");
-            const origins = [];
-            for (let origin = option(args, "--origin"); origin; origin = option(args, "--origin"))
-                origins.push(origin);
-            if (!name || args.length > 0)
-                throw usageError();
-            return print(await (await keys()).create({ name, origins }));
-        }
-        if (action === "set-origins" && args.length >= 1) {
-            const [keyId, ...origins] = args;
-            return print(await (await keys()).update(keyId, { origins }));
-        }
-        if (action === "revoke" && args.length === 1)
-            return print(await (await keys()).revoke(args[0]));
-        throw usageError();
-    }
-    if (topic === "revoke") {
-        if (!action || args.length > 0)
-            throw usageError();
-        return print(await (await client()).access.revokeSubject(action));
-    }
-    if (topic === "token") {
-        const all = [action, ...args].filter((arg) => arg !== undefined);
-        const subject = option(all, "--subject");
-        const role = option(all, "--role");
-        const ttl = option(all, "--ttl");
-        if (!subject || !role || all.length > 0)
-            throw usageError();
-        const ttlSeconds = ttl === undefined ? undefined : Number(ttl);
-        if (ttlSeconds !== undefined && !Number.isInteger(ttlSeconds))
-            throw usageError("--ttl must be a whole number of seconds.");
-        return print(await (await client()).tokens.create({
-            subject,
-            role,
-            ...(ttlSeconds === undefined ? {} : { ttlSeconds }),
-        }));
-    }
+    if (topic === "policy" || topic === "keys" || topic === "revoke" || topic === "token")
+        throw usageError(`nylo access ${topic} was removed: the Runtime no longer mints subject tokens or keeps an access policy, browser keys or revocations (protocol 7). Trust your identity provider's tokens with an identity file, and give servers an application key (nylorun key put <id>).`);
     throw usageError();
 }

package/dist/cli.js

@@ -5,22 +5,18 @@ import { putHostModel } from "./model/host-model.js";
 import { CliError } from "./errors.js";
 import { findProjectRoot } from "./project/root.js";
 import { printLinkedEnvExports } from "./project/env.js";
-import { linkedConnection } from "./project/connection.js";
+import { linkedConnection, managementClient } from "./project/connection.js";
 import { accessCommand } from "./access/commands.js";
-import { endpointsCommand, resetCommand, statusCommand, } from "./installation/commands.js";
-const usage = `nylo <status|reset|endpoints|access|configure|env|doctor>
+import { resetCommand, statusCommand } from "./installation/commands.js";
+const usage = `nylo <status|reset|access|configure|env|doctor>
 
 Runtime client for the linked installation and its one Tenant (the Project link that
-npx nylorun start writes, or NYLORUN_RUNTIME_URL and NYLORUN_SERVER_KEY):
+npx nylorun start writes, or NYLORUN_RUNTIME_URL with NYLORUN_SERVER_KEY, and
+NYLORUN_MANAGEMENT_KEY for status, reset, access, configure and doctor):
   status [--json]                         the Tenant, its checks and counts
   reset [--sessions|--sandboxes|--all] [--yes]
                                           clear the Tenant's sessions, sandboxes or all its data
-  endpoints [--json]|ping <agent>         the registered Action endpoints and their health
-  access policy get|set <file>|init       the access policy for subject tokens (nylo access --help)
-  access keys list|create|set-origins|revoke  publishable keys for web pages and apps
-  access signing-keys list|rotate|revoke  the Tenant's token signing keys
-  access revoke <subject>                 end a subject's tokens and open streams
-  access token --subject <s> --role <r>   mint a subject token for trying the API
+  access signing-keys list|rotate|revoke  the Tenant's token signing keys (nylo access --help)
   configure                               set the linked Tenant's model provider
   env                                     print the linked Project's NYLORUN_* variables as exports
   doctor sandbox [--json]                 show which sandbox backend this Tenant's Host offers
@@ -33,7 +29,10 @@ const LOCAL_COMMANDS = new Set([
 ]);
 const TENANT_REMOVED = `nylo tenant was removed: an installation serves one Tenant.
 Run "npx nylorun start" in your project to create its Tenant and the Project link.
-Then use nylo status, nylo reset and nylo endpoints on the linked installation.`;
+Then use nylo status and nylo reset on the linked installation.`;
+const ENDPOINTS_REMOVED = `nylo endpoints was removed: the Runtime runs no code of yours during a session,
+so there are no Action endpoints. An agent's tools are http() tools and remote MCP servers
+(see MIGRATION.md).`;
 function parseFlags(args, allowed = {}) {
     const booleans = new Set();
     const values = new Map();
@@ -82,7 +81,7 @@ async function main() {
     if (command === "reset")
         return await resetCommand(args);
     if (command === "endpoints")
-        return await endpointsCommand(args);
+        throw usageError(ENDPOINTS_REMOVED);
     if (command === "access") {
         if (args[0] === "--help" || args[0] === "-h" || args.length === 0) {
             const { accessUsage } = await import("./access/commands.js");
@@ -114,6 +113,7 @@ async function main() {
             throw usageError(usage);
         const projectRoot = findProjectRoot() ?? process.cwd();
         const auth = await linkedConnection(projectRoot);
+        const admin = managementClient(auth);
         const controller = new AbortController();
         const cancel = (signal) => controller.abort(new ConfigurationCancelled(signal));
         process.once("SIGINT", () => cancel("SIGINT"));
@@ -121,12 +121,12 @@ async function main() {
         const health = await fetch(`${auth.url}/health`).catch(() => undefined);
         if (!health?.ok)
             throw new CliError(`No Runtime is listening at ${auth.url}. Start the local Tenant with "npx nylorun start".`, 6);
-        const catalog = await fetchModelCatalog({ url: auth.url, key: auth.key });
+        const catalog = await fetchModelCatalog(admin);
         const prompted = await configureProvider({
             signal: controller.signal,
             catalog,
         });
-        await putHostModel(auth.url, auth.key, prompted);
+        await putHostModel(admin, prompted);
         return;
     }
     throw usageError(usage);

package/dist/doctor.d.ts

@@ -19,7 +19,7 @@ export type SandboxReport = {
         };
     };
 };
-/** `nylo doctor sandbox`: Tenant sandbox report via the Tenant API (F2-4). */
+/** `nylo doctor sandbox`: Tenant sandbox report via the Management API (F2-4). */
 export declare function doctorSandbox(options: {
     json: boolean;
 }): Promise<void>;

package/dist/doctor.js

@@ -1,6 +1,7 @@
 import { release } from "node:os";
-import { createClient, resolveConnection } from "@nylorun/agents";
 import { CliError } from "./errors.js";
+import { linkedConnection, managementClient } from "./project/connection.js";
+import { findProjectRoot } from "./project/root.js";
 function platformLine() {
     const os = process.platform === "darwin"
         ? "macOS"
@@ -9,12 +10,12 @@ function platformLine() {
             : process.platform;
     return `${os} (kernel ${release()}) · ${process.arch}`;
 }
-async function fetchSandboxReport(options) {
-    const connection = await resolveConnection(options);
-    const client = createClient({ url: connection.url, key: connection.key });
-    return client.transport.json("/v1/tenant/sandbox", "GET", undefined);
+/** The Tenant's sandbox report (`GET /v1/tenant/sandbox`, Management API). */
+async function fetchSandboxReport() {
+    const connection = await linkedConnection(findProjectRoot() ?? process.cwd());
+    return (await managementClient(connection).settings.sandbox.get());
 }
-/** `nylo doctor sandbox`: Tenant sandbox report via the Tenant API (F2-4). */
+/** `nylo doctor sandbox`: Tenant sandbox report via the Management API (F2-4). */
 export async function doctorSandbox(options) {
     let report;
     try {

package/dist/installation/commands.d.ts

@@ -1,20 +1,7 @@
-/** `nylo status [--json]`: the Tenant, its checks and counts; the Host's cause when it is not open. */
+/**
+ * `nylo status [--json]`: the Tenant, its checks and counts. A Tenant that is not open does not
+ * answer: `npx nylorun status` reports why.
+ */
 export declare function statusCommand(args: readonly string[]): Promise<void>;
 /** `nylo reset [--sessions|--sandboxes|--all] [--yes]`; `--all` asks first. */
 export declare function resetCommand(args: readonly string[]): Promise<void>;
-/** `nylo endpoints [--json]` and `nylo endpoints ping <agent>`. */
-export declare function endpointsCommand(args: readonly string[]): Promise<void>;
-/** One line of `nylo endpoints`: the agent, its URL and version, and how it is doing. */
-export declare function endpointLine(endpoint: {
-    agentId: string;
-    url: string;
-    implementationVersion: string;
-    health: {
-        consecutiveFailures: number;
-        lastSuccessAt?: string;
-        lastError?: {
-            code: string;
-            message: string;
-        };
-    };
-}): string;

package/dist/installation/commands.js

@@ -1,63 +1,42 @@
 /**
- * `nylo status`, `nylo reset` and `nylo endpoints`: the linked installation's one Tenant,
- * through the Tenant API with the Project's application key.
+ * `nylo status` and `nylo reset`: the linked installation's one Tenant, through the Management
+ * API (the Project's management key).
  */
 import { createInterface } from "node:readline/promises";
-import { randomUUID } from "node:crypto";
-import { createAdmin } from "@nylorun/admin";
-import { createClient } from "@nylorun/agents";
 import { CliError } from "../errors.js";
-import { linkedConnection } from "../project/connection.js";
+import { linkedConnection, managementClient } from "../project/connection.js";
 import { findProjectRoot } from "../project/root.js";
 const projectRoot = () => findProjectRoot() ?? process.cwd();
-const clientFor = (connection) => createClient({ url: connection.url, key: connection.key });
-/** `nylo status [--json]`: the Tenant, its checks and counts; the Host's cause when it is not open. */
+/**
+ * `nylo status [--json]`: the Tenant, its checks and counts. A Tenant that is not open does not
+ * answer: `npx nylorun status` reports why.
+ */
 export async function statusCommand(args) {
     const json = args.includes("--json");
     if (args.some((a) => a !== "--json"))
         throw new CliError("Usage: nylo status [--json]", 2);
     const root = projectRoot();
     const connection = await linkedConnection(root);
-    let reason;
+    const admin = managementClient(connection);
+    let body;
     try {
-        const body = await clientFor(connection).transport.json("/v1/tenant", "GET");
-        if (json) {
-            console.log(JSON.stringify(body, null, 2));
-            return;
-        }
-        console.log(`${body.tenant.name}  ${body.tenant.id}`);
-        console.log(`runtime  ${connection.url}`);
-        console.log(`path     ${body.path}`);
-        console.log(`checks   ${Object.entries(body.checks)
-            .map(([k, v]) => `${k}=${v ? "ok" : "fail"}`)
-            .join(" ")}`);
-        console.log(`counts   sessions=${body.counts.sessions} running=${body.counts.runningSessions} pending=${body.counts.pendingActions}`);
-        console.log(`sandbox  ${body.sandbox.backend ?? "none"}`);
-        return;
+        body = await admin.tenant.status();
     }
     catch (error) {
-        // A Tenant that is not open does not answer: the Admin API says why.
-        reason = error;
-    }
-    let tenant;
-    try {
-        tenant = (await createAdmin({ cwd: root }).status()).tenant;
-    }
-    catch {
-        throw new CliError(reason instanceof Error
-            ? reason.message
-            : `The Tenant at ${connection.url} is not reachable.`, 1);
+        throw new CliError(`${(error instanceof Error ? error.message : `The Tenant at ${connection.url} is not reachable`).replace(/\.?$/, ".")} Run "npx nylorun status" to see the Tenant's state and why it is not open.`, 1);
     }
     if (json) {
-        console.log(JSON.stringify({ tenant }, null, 2));
+        console.log(JSON.stringify(body, null, 2));
         return;
     }
-    console.log(`${tenant.name ?? "(unreadable)"}  ${tenant.id ?? "(unknown)"}  ${tenant.state}`);
+    console.log(`${body.tenant.name}  ${body.tenant.id}`);
     console.log(`runtime  ${connection.url}`);
-    if (tenant.cause) {
-        console.log(`reason   ${tenant.cause.code}: ${tenant.cause.message}`);
-        console.log(`repair   ${tenant.cause.repair}`);
-    }
+    console.log(`path     ${body.path}`);
+    console.log(`checks   ${Object.entries(body.checks)
+        .map(([k, v]) => `${k}=${v ? "ok" : "fail"}`)
+        .join(" ")}`);
+    console.log(`counts   sessions=${body.counts.sessions} running=${body.counts.runningSessions} uncertain=${body.counts.uncertainEffects}`);
+    console.log(`sandbox  ${body.sandbox.backend ?? "none"}`);
 }
 const RESET_USAGE = "Usage: nylo reset [--sessions|--sandboxes|--all] [--yes]";
 const SCOPES = { "--sessions": "sessions", "--sandboxes": "sandboxes", "--all": "all" };
@@ -73,14 +52,11 @@ export async function resetCommand(args) {
     const connection = await linkedConnection(projectRoot());
     const tenant = connection.link?.tenant;
     const target = tenant ? `Tenant ${tenant} (${connection.url})` : `the Tenant on ${connection.url}`;
+    const admin = managementClient(connection);
     if (scope === "all" && !yes)
         await confirmOrThrow(`Reset ALL data of ${target}? The Project link and credentials are kept. [y/N] `);
     try {
-        await clientFor(connection).transport.json("/v1/tenant/reset", "POST", {
-            requestId: randomUUID(),
-            scope,
-            activeWork: "drain",
-        });
+        await admin.tenant.reset({ scope, activeWork: "drain" });
     }
     catch (error) {
         throw new CliError(error instanceof Error ? error.message : `Tenant reset failed: ${String(error)}`, 1);
@@ -102,40 +78,3 @@ async function confirmOrThrow(prompt) {
         rl.close();
     }
 }
-/** `nylo endpoints [--json]` and `nylo endpoints ping <agent>`. */
-export async function endpointsCommand(args) {
-    if (args[0] === "ping") {
-        const agentId = args[1];
-        if (!agentId || args.length > 2)
-            throw new CliError("Usage: nylo endpoints ping <agent>", 2);
-        const client = clientFor(await linkedConnection(projectRoot()));
-        const answer = await client.transport.json(`/v1/endpoints/${encodeURIComponent(agentId)}/ping`, "POST");
-        console.log(`${answer.agentId}  serves ${answer.implementationVersion}${answer.manifestHash ? `  ${answer.manifestHash}` : ""}`);
-        return;
-    }
-    const json = args.includes("--json");
-    if (args.some((a) => a !== "--json"))
-        throw new CliError("Usage: nylo endpoints [--json] | nylo endpoints ping <agent>", 2);
-    const client = clientFor(await linkedConnection(projectRoot()));
-    const body = await client.transport.json("/v1/endpoints", "GET");
-    if (json) {
-        console.log(JSON.stringify(body, null, 2));
-        return;
-    }
-    if (body.endpoints.length === 0) {
-        console.log("No Action endpoints. Register one with createActionHandler(...).register({ url }).");
-        return;
-    }
-    for (const endpoint of body.endpoints)
-        console.log(endpointLine(endpoint));
-}
-/** One line of `nylo endpoints`: the agent, its URL and version, and how it is doing. */
-export function endpointLine(endpoint) {
-    const { health } = endpoint;
-    const state = health.consecutiveFailures > 0
-        ? `failing (${health.consecutiveFailures}): ${health.lastError?.message || health.lastError?.code || "unknown"}`
-        : health.lastSuccessAt
-            ? `ok (last ${health.lastSuccessAt})`
-            : "no deliveries yet";
-    return `${endpoint.agentId}  ${endpoint.url}  ${endpoint.implementationVersion}  ${state}`;
-}

package/dist/model/configure.d.ts

@@ -1,5 +1,6 @@
 import type { Readable, Writable } from "node:stream";
 import type { Credential } from "@earendil-works/pi-ai";
+import type { ManagementClient } from "@nylorun/admin";
 export declare class ConfigurationCancelled extends Error {
     readonly signal: "SIGINT" | "SIGTERM";
     readonly exitCode: number;
@@ -37,12 +38,8 @@ export type Selection = Readonly<{
         baseUrl: string;
     }>;
 }>;
-/** Fetch GET /v1/tenant/models when a connection is available. */
-export declare function fetchModelCatalog(options: {
-    url: string;
-    key: string;
-    fetchImpl?: typeof fetch;
-}): Promise<ModelCatalog>;
+/** The Tenant's model catalog (`GET /v1/tenant/models`, Management API). */
+export declare function fetchModelCatalog(admin: ManagementClient): Promise<ModelCatalog>;
 export declare function configureProvider(options?: {
     signal?: AbortSignal;
     root?: string;

package/dist/model/configure.js

@@ -109,22 +109,9 @@ function modelsFor(selection, credentials, catalog) {
         },
     };
 }
-/** Fetch GET /v1/tenant/models when a connection is available. */
-export async function fetchModelCatalog(options) {
-    const fetchImpl = options.fetchImpl ?? fetch;
-    const { PROTOCOL_HEADER, PROTOCOL_VERSION } = await import("@nylorun/agents");
-    const response = await fetchImpl(`${options.url.replace(/\/$/, "")}/v1/tenant/models`, {
-        headers: {
-            authorization: `Bearer ${options.key}`,
-            [PROTOCOL_HEADER]: String(PROTOCOL_VERSION),
-            Accept: "application/json",
-        },
-        signal: AbortSignal.timeout(10_000),
-    });
-    if (!response.ok) {
-        throw new Error(`Runtime model catalog returned ${response.status}`);
-    }
-    return (await response.json());
+/** The Tenant's model catalog (`GET /v1/tenant/models`, Management API). */
+export async function fetchModelCatalog(admin) {
+    return await admin.models.catalog();
 }
 // Internal options also allow isolated prompt tests without changing process globals.
 export async function configureProvider(options = {}) {

package/dist/model/host-model.d.ts

@@ -1,18 +1,4 @@
+import type { ManagementClient } from "@nylorun/admin";
 import type { PromptedModel } from "./configure.js";
-/** Wire shape of GET/PUT `/v1/tenant/model` — local copy so CLI stays off `@nylorun/core`. */
-type HostModelView = {
-    readonly configured: false;
-} | {
-    readonly configured: true;
-    readonly provider: string;
-    readonly model: string;
-    readonly authType: "api_key" | "oauth";
-    readonly baseUrl?: string;
-    readonly settings?: {
-        contextWindow?: number;
-        maxTokens?: number;
-    };
-};
-/** Set the installation's Tenant model provider (`PUT /v1/tenant/model`). */
-export declare function putHostModel(runtimeUrl: string, serverKey: string, model: PromptedModel, fetchImpl?: typeof fetch): Promise<HostModelView>;
-export {};
+/** Set the installation's Tenant model provider (`PUT /v1/tenant/model`, Management API). */
+export declare function putHostModel(admin: ManagementClient, model: PromptedModel): ReturnType<ManagementClient["models"]["put"]>;

package/dist/model/host-model.js

@@ -1,26 +1,13 @@
 import { randomUUID } from "node:crypto";
-import { PROTOCOL_HEADER, PROTOCOL_VERSION } from "@nylorun/agents";
-/** Set the installation's Tenant model provider (`PUT /v1/tenant/model`). */
-export async function putHostModel(runtimeUrl, serverKey, model, fetchImpl = fetch) {
-    const response = await fetchImpl(`${runtimeUrl}/v1/tenant/model`, {
-        method: "PUT",
-        headers: {
-            authorization: `Bearer ${serverKey}`,
-            [PROTOCOL_HEADER]: String(PROTOCOL_VERSION),
-            "content-type": "application/json",
-        },
-        body: JSON.stringify({
-            requestId: randomUUID(),
-            idempotencyKey: randomUUID(),
-            provider: model.provider,
-            model: model.model,
-            ...(model.baseUrl ? { baseUrl: model.baseUrl } : {}),
-            ...(model.settings ? { settings: model.settings } : {}),
-            auth: model.auth,
-        }),
+/** Set the installation's Tenant model provider (`PUT /v1/tenant/model`, Management API). */
+export async function putHostModel(admin, model) {
+    return await admin.models.put({
+        idempotencyKey: randomUUID(),
+        provider: model.provider,
+        model: model.model,
+        ...(model.baseUrl ? { baseUrl: model.baseUrl } : {}),
+        ...(model.settings ? { settings: model.settings } : {}),
+        // A prompted credential is complete: pi-ai's type leaves its fields optional.
+        auth: model.auth,
     });
-    const body = (await response.json().catch(() => ({})));
-    if (!response.ok)
-        throw new Error(body.message ?? `Runtime rejected the model provider (${response.status})`);
-    return body;
 }

package/dist/project/connection.d.ts

@@ -1,13 +1,20 @@
+import { type ManagementClient } from "@nylorun/admin";
 import { type ProjectLink } from "./link.js";
-/** The installation `nylo` acts on: a Runtime URL and an application key. */
+/** The installation `nylo` acts on: a Runtime URL, an application key and a management key. */
 export interface LinkedConnection {
     url: string;
-    key: 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` and `NYLORUN_SERVER_KEY`. The
- * installation serves one Tenant, so nothing names it.
+ * 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/project/connection.js

@@ -1,18 +1,38 @@
+import { createManagementClient } from "@nylorun/admin";
 import { CliError } from "../errors.js";
 import { readCredentials } from "./credentials.js";
 import { readLink } from "./link.js";
 /**
- * The Project's link and credentials, else `NYLORUN_RUNTIME_URL` and `NYLORUN_SERVER_KEY`. The
- * installation serves one Tenant, so nothing names it.
+ * 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);
-    if (link && credentials)
-        return { url: link.hostUrl, key: credentials.applicationKey, link };
+    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)
-        return { url: url.replace(/\/$/, ""), key };
-    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.`, 1);
+    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/project/credentials.d.ts

@@ -1,11 +1,14 @@
 /**
- * Project-local credentials (mode 0600): the application key and its principal. A format 0
- * file may still carry a legacy `executors` map from before protocol 3; it is ignored.
+ * Project-local credentials (mode 0600): the application key and its principal, and the
+ * management key and its principal when `nylorun start` issued one. A format 0 file may still
+ * carry a legacy `executors` map from before protocol 3; it is ignored.
  */
 export interface ProjectCredentials {
     format: 0 | 1;
     applicationKey: string;
     principalId: string;
+    managementKey?: string;
+    managementPrincipalId?: string;
 }
 /** The Project's credentials, which `nylorun start` writes beside the link. */
 export declare function readCredentials(projectRoot: string): Promise<ProjectCredentials | undefined>;

package/dist/project/credentials.js

@@ -25,6 +25,11 @@ export async function readCredentials(projectRoot) {
             format,
             applicationKey: value.applicationKey,
             principalId: value.principalId,
+            ...(typeof value.managementKey === "string" &&
+                /^[0-9a-f]{64}$/.test(value.managementKey) &&
+                typeof value.managementPrincipalId === "string"
+                ? { managementKey: value.managementKey, managementPrincipalId: value.managementPrincipalId }
+                : {}),
         };
     }
     catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nylorun/cli",
-  "version": "0.9.0-beta",
+  "version": "0.12.0-beta",
   "type": "module",
   "license": "Apache-2.0",
   "description": "Nylorun Runtime client: the linked installation's Tenant, its access and its model provider",
@@ -30,8 +30,8 @@
     "prepack": "npm run build"
   },
   "dependencies": {
-    "@nylorun/agents": "0.13.0-beta",
-    "@nylorun/admin": "0.9.0-beta",
+    "@nylorun/agents": "0.16.0-beta",
+    "@nylorun/admin": "0.11.1-beta",
     "@earendil-works/pi-ai": "0.99.1"
   },
   "devDependencies": {