@nylorun/runtime 0.16.0-beta → 0.17.0-beta

package/dist/api/http/routes/access.js

@@ -1,14 +1,8 @@
 import { z } from "zod";
-import { newPublishableKey, newPublishableKeyId } from "@nylorun/core/compatibility";
-import { CreatePublishableKeyRequestSchema, CreateTokenRequestSchema, PutAccessPolicyRequestSchema, RevokeSigningKeyRequestSchema, RevokeSubjectRequestSchema, RotateSigningKeysRequestSchema, UpdatePublishableKeyRequestSchema, } from "@nylorun/core/contracts";
-import { AccessPolicyResponse, CreatePublishableKeyRequest, CreateTokenRequest, CreateTokenResponse, Jwks, ListPublishableKeysResponse, PublishableKey, PutAccessPolicyRequest, RevokeSigningKeyRequest, RevokeSubjectRequest, RevokeSubjectResponse, RotateSigningKeysRequest, SigningKeyList, SigningKeyView, UpdatePublishableKeyRequest, } from "../../components.js";
-import { signalSubjectRevoked } from "../../../streams/control.js";
-import { readPolicy, writePolicy } from "../../../tenant/access-policy.js";
-import { currentBasin, endSubjectStreams } from "../../../tenant/session-streams.js";
+import { RevokeSigningKeyRequestSchema, RotateSigningKeysRequestSchema, TOKEN_TTL_MAX_SECONDS, } from "@nylorun/core/contracts";
+import { Jwks, RevokeSigningKeyRequest, RotateSigningKeysRequest, SigningKeyList, SigningKeyView, } from "../../components.js";
 import { requireApplication } from "../../../tenant/auth.js";
-import { fail } from "../../../tenant/http.js";
 import { publicJwk, signingKeyView } from "../../../tenant/signing-keys.js";
-import { mintToken } from "../../../tenant/tokens.js";
 import { readJson } from "../body.js";
 import { tenantRoute } from "../define.js";
 import { jsonResponse } from "../respond.js";
@@ -21,21 +15,19 @@ const body = (schema) => ({
     required: true,
     content: { "application/json": { schema } },
 });
-const keyId = z.object({ keyId: z.string() });
 export function accessRoutes(api) {
     tenantRoute(api, {
-        credentials: ["application", "subject", "token", "publishable"],
+        credentials: ["application", "subject", "token"],
         scopes: "any",
-        browser: true,
         // Public keys: an Action endpoint verifies delivery tokens with them and holds no key.
         anonymous: true,
     }, {
         method: "get",
         path: "/v1/access/jwks",
         tags: ["Access"],
-        summary: "Get the public keys subject and delivery tokens are signed with",
-        description: "A JSON Web Key Set, to verify a subject token or a delivery token without calling the " +
-            "Runtime. No credential is needed.",
+        summary: "Get the public keys delivery tokens are signed with",
+        description: "A JSON Web Key Set, to verify a delivery token without calling the Runtime. No " +
+            "credential is needed.",
         responses: { 200: json(Jwks, "The public keys") },
     }, async (c) => {
         // Anonymous: reads the public keys. Only when the current or standby key is missing does
@@ -49,41 +41,6 @@ export function accessRoutes(api) {
         }
         return jsonResponse(200, { keys: rows.map(publicJwk) });
     });
-    tenantRoute(api, APPLICATION, {
-        method: "post",
-        path: "/v1/tokens",
-        tags: ["Access"],
-        summary: "Mint a subject token",
-        description: "A token for one person and one role of the access policy, for their browser or app to call the Runtime with. At most 15 minutes.",
-        request: { body: body(CreateTokenRequest) },
-        responses: { 200: json(CreateTokenResponse, "The token, its scopes and expiry") },
-    }, async (c) => {
-        requireApplication(c.get("scope"));
-        return jsonResponse(200, await mintToken(c.env.tenant, CreateTokenRequestSchema.parse(await readJson(c.req.raw))));
-    });
-    tenantRoute(api, APPLICATION, {
-        method: "get",
-        path: "/v1/access/policy",
-        tags: ["Access"],
-        summary: "Get the access policy",
-        responses: { 200: json(AccessPolicyResponse, "Roles, the anonymous grant and token lifetime") },
-    }, async (c) => {
-        requireApplication(c.get("scope"));
-        return jsonResponse(200, { policy: await c.env.tenant.store.tx((t) => readPolicy(t)) });
-    });
-    tenantRoute(api, APPLICATION, {
-        method: "put",
-        path: "/v1/access/policy",
-        tags: ["Access"],
-        summary: "Set the access policy",
-        request: { body: body(PutAccessPolicyRequest) },
-        responses: { 200: json(AccessPolicyResponse, "The policy now in force") },
-    }, async (c) => {
-        requireApplication(c.get("scope"));
-        const request = PutAccessPolicyRequestSchema.parse(await readJson(c.req.raw));
-        await c.env.tenant.store.tx((t) => writePolicy(t, request.policy));
-        return jsonResponse(200, { policy: request.policy });
-    });
     tenantRoute(api, APPLICATION, {
         method: "get",
         path: "/v1/access/signing-keys",
@@ -106,7 +63,7 @@ export function accessRoutes(api) {
         path: "/v1/access/signing-keys/rotate",
         tags: ["Access"],
         summary: "Rotate the signing keys",
-        description: "The standby key signs from now on; the current one still verifies tokens it signed. `force` also ends every outstanding token.",
+        description: "The standby key signs from now on; the current one still verifies tokens it signed. `force` also ends every outstanding delivery token and capability link.",
         request: { body: body(RotateSigningKeysRequest) },
         responses: {
             200: json(SigningKeyList, "The keys after rotation"),
@@ -116,8 +73,11 @@ export function accessRoutes(api) {
         requireApplication(c.get("scope"));
         const ctx = c.env.tenant;
         const request = RotateSigningKeysRequestSchema.parse(await readJson(c.req.raw));
-        const maxTtlSeconds = await ctx.store.tx(async (t) => (await readPolicy(t)).tokens.maxTtlSeconds);
-        const keys = await ctx.keys.rotateSigningKeys({ maxTtlSeconds, force: request.force === true });
+        // The longest any token the Runtime signs lives (delivery tokens, capability links).
+        const keys = await ctx.keys.rotateSigningKeys({
+            maxTtlSeconds: TOKEN_TTL_MAX_SECONDS,
+            force: request.force === true,
+        });
         ctx.config.logger.info("signing keys rotated", { force: request.force === true });
         return jsonResponse(200, { keys });
     });
@@ -139,126 +99,6 @@ export function accessRoutes(api) {
         ctx.config.logger.info("signing key revoked", { kid: row.id });
         return jsonResponse(200, signingKeyView(row));
     });
-    tenantRoute(api, APPLICATION, {
-        method: "get",
-        path: "/v1/access/publishable-keys",
-        tags: ["Access"],
-        summary: "List publishable keys",
-        responses: { 200: json(ListPublishableKeysResponse, "The keys, revoked ones included") },
-    }, async (c) => {
-        requireApplication(c.get("scope"));
-        return jsonResponse(200, {
-            keys: (await c.env.tenant.store.tx((t) => t.publishableKeys())).map(publishableKeyView),
-        });
-    });
-    tenantRoute(api, APPLICATION, {
-        method: "post",
-        path: "/v1/access/publishable-keys",
-        tags: ["Access"],
-        summary: "Create a publishable key",
-        description: "A key a browser page on one of the origins sends as `Nylorun-Key`. Public by design; it grants the policy's anonymous scopes.",
-        request: { body: body(CreatePublishableKeyRequest) },
-        responses: {
-            200: json(PublishableKey, "The key"),
-            409: { description: "A key with this name exists" },
-        },
-    }, async (c) => {
-        requireApplication(c.get("scope"));
-        const ctx = c.env.tenant;
-        const request = CreatePublishableKeyRequestSchema.parse(await readJson(c.req.raw));
-        const row = {
-            id: newPublishableKeyId(),
-            key: newPublishableKey(ctx.config.tenantId),
-            name: request.name,
-            originsJson: JSON.stringify(request.origins),
-            createdAt: new Date().toISOString(),
-            revokedAt: null,
-        };
-        await ctx.store.tx(async (t) => {
-            if ((await t.publishableKeys()).some((other) => other.name === request.name))
-                fail(409, `A publishable key named ${request.name} exists`);
-            await t.insertPublishableKey(row);
-        });
-        ctx.config.logger.info("publishable key created", { keyId: row.id });
-        return jsonResponse(200, publishableKeyView(row));
-    });
-    for (const method of ["put", "delete"])
-        tenantRoute(api, APPLICATION, {
-            method,
-            path: "/v1/access/publishable-keys/{keyId}",
-            tags: ["Access"],
-            summary: method === "put" ? "Set a publishable key's origins" : "Revoke a publishable key",
-            request: {
-                params: keyId,
-                ...(method === "put" ? { body: body(UpdatePublishableKeyRequest) } : {}),
-            },
-            responses: {
-                200: json(PublishableKey, method === "put" ? "The key" : "The key, revoked (again: unchanged)"),
-            },
-        }, async (c) => {
-            requireApplication(c.get("scope"));
-            const ctx = c.env.tenant;
-            const id = c.req.param("keyId");
-            const patch = method === "put"
-                ? {
-                    originsJson: JSON.stringify(UpdatePublishableKeyRequestSchema.parse(await readJson(c.req.raw)).origins),
-                }
-                : { revokedAt: new Date().toISOString() };
-            const row = await ctx.store.tx(async (t) => {
-                const existing = (await t.publishableKey(id)) ?? fail(404, "Publishable key not found");
-                // Revoking twice keeps the first time.
-                if (method === "delete" && existing.revokedAt !== null)
-                    return existing;
-                await t.updatePublishableKey(id, patch);
-                return { ...existing, ...patch };
-            });
-            ctx.config.logger.info(method === "put" ? "publishable key updated" : "publishable key revoked", { keyId: row.id });
-            return jsonResponse(200, publishableKeyView(row));
-        });
-    tenantRoute(api, APPLICATION, {
-        method: "post",
-        path: "/v1/access/revocations",
-        tags: ["Access"],
-        summary: "Revoke a subject",
-        description: "Ends every token minted for the subject so far, and their open streams on every process. Turns in progress continue.",
-        request: { body: body(RevokeSubjectRequest) },
-        responses: { 200: json(RevokeSubjectResponse, "The subject's new epoch") },
-    }, async (c) => {
-        requireApplication(c.get("scope"));
-        const request = RevokeSubjectRequestSchema.parse(await readJson(c.req.raw));
-        return jsonResponse(200, await revokeSubject(c.env.tenant, request.subject));
-    });
-}
-/** A publishable key as the API shows it. */
-export function publishableKeyView(row) {
-    return {
-        id: row.id,
-        name: row.name,
-        key: row.key,
-        origins: JSON.parse(row.originsJson),
-        createdAt: row.createdAt,
-        revokedAt: row.revokedAt,
-    };
-}
-/**
- * Ends every token of `subject` minted so far: bumps its epoch, then ends its open streams
- * here and, through `tenant/control`, on every other process. Running turns continue.
- */
-export async function revokeSubject(ctx, subject) {
-    const epoch = await ctx.store.tx(async (t) => {
-        const next = await t.bumpSubjectEpoch(subject, new Date().toISOString());
-        t.afterCommit(async () => {
-            endSubjectStreams(ctx.sessionStreams, subject, next);
-            const streams = ctx.sessionStreams.wiring?.streams;
-            if (streams)
-                await signalSubjectRevoked(streams, currentBasin(ctx), subject, next).catch((error) => ctx.config.logger.warn("subject revocation signal failed", {
-                    message: error instanceof Error ? error.message : String(error),
-                }));
-        });
-        return next;
-    });
-    ctx.config.logger.info("subject revoked", { epoch });
-    return { subject, epoch };
 }
 /** True when the Tenant has a current and a standby signing key. */
 function complete(rows) {

package/dist/api/http/routes/actions.js

@@ -57,7 +57,6 @@ export function actionRoutes(api) {
     tenantRoute(api, {
         credentials: ["application", "subject", "token"],
         scopes: ["sessions:own"],
-        browser: true,
     }, {
         method: "post",
         path: "/v1/sessions/{sessionId}/commands",

package/dist/api/http/routes/artifacts.js

@@ -32,15 +32,13 @@ import { jsonResponse } from "../respond.js";
 const OWN = {
     credentials: ["application", "subject", "token"],
     scopes: ["sessions:own"],
-    browser: true,
 };
 /** An upload: the same callers, with the file's bytes as the body. */
 const UPLOAD = { ...OWN, bytes: true };
 /** A capability link: no credential, no protocol header; the token in the path is the grant. */
 const LINK = {
-    credentials: ["application", "subject", "token", "publishable"],
+    credentials: ["application", "subject", "token"],
     scopes: "any",
-    browser: true,
     anonymous: true,
     unversioned: true,
 };

package/dist/api/http/routes/me.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `GET /v1/me` (Host feature `trusted-issuers`): who the Runtime takes the caller to be, for any
+ * credential that acts on the Tenant. It shows what a trusted issuer's token renders to (its
+ * subject, scopes, agents and sandbox grants), so an operator can check an identity file, and
+ * Studio can check a forwarded token for the `studio` scope.
+ */
+import type { OpenAPIHono } from "@hono/zod-openapi";
+import { type MeResponse as MeBody } from "@nylorun/core/contracts";
+import type { AuthScope } from "../../../tenant/context.js";
+import type { TenantEnv } from "../app.js";
+/** The caller as `GET /v1/me` reports it. */
+export declare function describeCaller(scope: AuthScope): MeBody;
+export declare function meRoutes(api: OpenAPIHono<TenantEnv>): void;

package/dist/api/http/routes/me.js

@@ -0,0 +1,45 @@
+import { CALLER_SCOPES, SUBJECT_SCOPES, } from "@nylorun/core/contracts";
+import { MeResponse } from "../../components.js";
+import { fail } from "../../../tenant/http.js";
+import { tenantRoute } from "../define.js";
+import { jsonResponse } from "../respond.js";
+function ordered(scopes) {
+    const held = new Set(scopes);
+    return CALLER_SCOPES.filter((scope) => held.has(scope));
+}
+/** The caller as `GET /v1/me` reports it. */
+export function describeCaller(scope) {
+    switch (scope.kind) {
+        case "application":
+            return { scopes: [...SUBJECT_SCOPES], agents: "*", via: `application:${scope.principalId}` };
+        case "subject":
+            return { subject: scope.subject, scopes: ordered(scope.scopes), agents: "*", via: "subject" };
+        case "token":
+            return {
+                subject: scope.subject,
+                scopes: ordered(scope.scopes),
+                agents: scope.agents === "*" ? "*" : [...scope.agents].sort(),
+                sandboxes: [...(scope.sandboxes ?? [])],
+                via: `issuer:${scope.issuer}`,
+            };
+        default:
+            return fail(403, "This credential acts on no Tenant resource");
+    }
+}
+export function meRoutes(api) {
+    tenantRoute(api, { credentials: ["application", "subject", "token"], scopes: "any" }, {
+        method: "get",
+        path: "/v1/me",
+        tags: ["Access"],
+        summary: "Get who the caller is",
+        description: "The subject, scopes, agents and sandbox grants of the credential that sends it: an " +
+            "application key (alone or acting for a subject), or a trusted issuer's token " +
+            "(`via: issuer:<name>`).",
+        responses: {
+            200: {
+                description: "The caller",
+                content: { "application/json": { schema: MeResponse } },
+            },
+        },
+    }, (c) => jsonResponse(200, describeCaller(c.get("scope"))));
+}

package/dist/api/http/routes/sandboxes.d.ts

@@ -1,8 +1,8 @@
 /**
  * Sandboxes as a resource (`/v1/sandboxes/**`, Host feature `sandboxes`): create or find one by
  * id, read it, list them by label, read its lifecycle stream, and delete it. Ids may hold `/`,
- * sent percent-encoded as one path segment (`team-a%2Fproj-42`). A subject token reaches only
- * the ids its `sbx` grants match, and changes them only with `sandboxes:write`.
+ * sent percent-encoded as one path segment (`team-a%2Fproj-42`). A token caller reaches only
+ * the ids its sandbox grants match, and changes them only with `sandboxes:write`.
  */
 import type { OpenAPIHono } from "@hono/zod-openapi";
 import type { TenantEnv } from "../app.js";

package/dist/api/http/routes/sandboxes.js

@@ -10,13 +10,11 @@ import { jsonResponse } from "../respond.js";
 const READ = {
     credentials: ["application", "subject", "token"],
     scopes: ["sessions:own", "sandboxes:write"],
-    browser: true,
 };
 /** Creating or deleting one. */
 const WRITE = {
     credentials: ["application", "subject", "token"],
     scopes: ["sandboxes:write"],
-    browser: true,
 };
 const json = (schema, description) => ({
     description,
@@ -50,7 +48,7 @@ export function sandboxRoutes(api) {
         path: "/v1/sandboxes",
         tags: ["Sandboxes"],
         summary: "List sandboxes",
-        description: "Every sandbox with all the labels asked for. A subject token sees only the sandboxes its grants reach.",
+        description: "Every sandbox with all the labels asked for. A token caller sees only the sandboxes its grants reach.",
         request: {
             query: z.object({
                 label: z

package/dist/api/http/routes/sessions.js

@@ -8,7 +8,7 @@ import { accessOf, requireApplication } from "../../../tenant/auth.js";
 import { loadSession, sessionOf } from "../../../tenant/context.js";
 import { fail } from "../../../tenant/http.js";
 import { sandboxGrantsOf } from "../../../tenant/sandboxes.js";
-import { readHistory, requestCursor, streamSessionEvents } from "../../../tenant/session-streams.js";
+import { readHistory, requestCursor, streamHolderOf, streamSessionEvents } from "../../../tenant/session-streams.js";
 import { listAgentsPublic, listDefinitions, listSessions, putDefinition, putSession, sessionView, } from "../../../tenant/sessions.js";
 import { readJson } from "../body.js";
 import { tenantRoute } from "../define.js";
@@ -16,7 +16,6 @@ import { jsonResponse } from "../respond.js";
 const OWN_SESSIONS = {
     credentials: ["application", "subject", "token"],
     scopes: ["sessions:own"],
-    browser: true,
 };
 const json = (schema, description) => ({
     description,
@@ -47,23 +46,20 @@ async function sessionBelow(ctx, incoming, id, access) {
 }
 export function sessionRoutes(api) {
     tenantRoute(api, {
-        credentials: ["application", "subject", "token", "publishable"],
+        credentials: ["application", "subject", "token"],
         scopes: ["agents:read", "agents:write"],
-        browser: true,
     }, {
         method: "get",
         path: "/v1/agents",
         tags: ["Agents"],
         summary: "List agents",
-        description: "With an application key, every definition, manifest included. With a subject token or a publishable key, only the agents it may use, by name.",
+        description: "With an application key, every definition, manifest included. With a trusted issuer's token, only the agents it may use, by name.",
         responses: {
             200: json(z.union([ListAgentsResponse, ListPublicAgentsResponse]), "The agents"),
         },
     }, async (c) => {
         const scope = c.get("scope");
         const ctx = c.env.tenant;
-        if (scope.kind === "publishable")
-            return jsonResponse(200, await listAgentsPublic(ctx, scope.agents));
         return jsonResponse(200, scope.kind === "token"
             ? await listAgentsPublic(ctx, scope.agents)
             : await listDefinitions(ctx));
@@ -107,7 +103,7 @@ export function sessionRoutes(api) {
         const request = PutSessionRequestSchema.parse(await readJson(c.req.raw));
         // Agent code may trust `info`: only an app server sets it.
         if (scope.kind === "token" && request.info !== undefined)
-            fail(403, "A subject token cannot set session info", { code: "scope_required" });
+            fail(403, "A token caller cannot set session info", { code: "scope_required" });
         const grants = sandboxGrantsOf(scope);
         const session = await putSession(ctx, c.req.param("sessionId"), request, accessOf(scope), grants === undefined ? {} : { sandboxGrants: grants });
         return jsonResponse(200, await ctx.store.tx((t) => sessionView(t, session)));
@@ -152,7 +148,7 @@ export function sessionRoutes(api) {
         path: "/v1/sessions/{sessionId}/events",
         tags: ["Sessions"],
         summary: "Follow a session's events",
-        description: "Server-sent events, each with its type as `event` and its cursor as `id`, from the cursor on. Events are on the `nylorun.event/2` envelope, typed by `SessionEvent`; a client ignores a type it does not know. A subject token's stream ends with `event: nylorun.closed` when the token expires or the subject is revoked. A `: keepalive` comment every 15 seconds.",
+        description: "Server-sent events, each with its type as `event` and its cursor as `id`, from the cursor on. Events are on the `nylorun.event/2` envelope, typed by `SessionEvent`; a client ignores a type it does not know. A trusted issuer's token's stream ends with `event: nylorun.closed` when the token expires. A `: keepalive` comment every 15 seconds.",
         request: { params: sessionId, query: resume },
         responses: {
             200: {
@@ -170,9 +166,7 @@ export function sessionRoutes(api) {
         const { incoming, outgoing } = c.env;
         const id = c.req.param("sessionId");
         const cursor = await sessionBelow(ctx, incoming, id, accessOf(scope));
-        await streamSessionEvents(ctx, incoming, outgoing, id, cursor, scope.kind === "token"
-            ? { subject: scope.subject, epoch: scope.epoch, expiresAt: scope.expiresAt }
-            : undefined);
+        await streamSessionEvents(ctx, incoming, outgoing, id, cursor, streamHolderOf(scope));
         return RESPONSE_ALREADY_SENT;
     });
     tenantRoute(api, { credentials: ["application"], scopes: "never" }, {

package/dist/api/http/routes/vaults.d.ts

@@ -1,8 +1,17 @@
 /**
- * Vaults and their credentials (`/v1/vaults/**`): secrets a session's tools use, owned by one
- * person. Acting for a subject reaches only the subject's own vaults, and never on another's
- * behalf.
+ * Vaults and their credentials (`/v1/vaults/**`): secrets a session's tools use. Only an
+ * application key acting for no one (an operator key, Studio) reaches these routes (protocol 7):
+ * a request acting for a subject, or a trusted issuer's token, is `403 scope_required`. The
+ * installation's own vaults (`scope: "installation"`) attach to any session; a vault of one
+ * person (`ownerUserId`) attaches only to that person's sessions. A person's own credentials
+ * come from the operator's credential resolver (`vault/sources.ts`), not from these routes.
+ *
+ * MCP OAuth connect (F9 C2): an application key starts one into an installation vault
+ * (`/oauth/start`); the authorization server sends the browser back to the anonymous, unversioned
+ * `GET /v1/oauth/callback`. Both only route: the gateway's keys module does the OAuth (F9-D14).
  */
 import type { OpenAPIHono } from "@hono/zod-openapi";
 import type { TenantEnv } from "../app.js";
+/** Where the authorization server sends the browser back. */
+export declare const OAUTH_CALLBACK_PATH = "/v1/oauth/callback";
 export declare function vaultRoutes(api: OpenAPIHono<TenantEnv>): void;