@nylorun/runtime 0.17.0-beta → 0.19.0-beta

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

@@ -1,8 +0,0 @@
-/**
- * Session commands, and the callbacks an Action endpoint makes about the Action it was
- * delivered: heartbeats and sandbox tools, with the Action's delivery token (Action endpoints).
- * The background result is in `endpoints.ts`.
- */
-import type { OpenAPIHono } from "@hono/zod-openapi";
-import type { TenantEnv } from "../app.js";
-export declare function actionRoutes(api: OpenAPIHono<TenantEnv>): void;

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

@@ -1,75 +0,0 @@
-import { z } from "zod";
-import { SessionCommandSchema } from "@nylorun/core/contracts";
-import { AcceptedResponse, DeliveryHeartbeatResponse, SandboxToolOutcome, SessionCommand, } from "../../components.js";
-import { actionSandboxTool } from "../../../tenant/actions.js";
-import { command } from "../../../tenant/commands.js";
-import { deliveryHeartbeat } from "../../../tenant/delivery.js";
-import { fail } from "../../../tenant/http.js";
-import { readJson } from "../body.js";
-import { tenantRoute } from "../define.js";
-import { jsonResponse } from "../respond.js";
-/** An Action's callbacks: only the delivery token of its current delivery. */
-const CALLBACK = { credentials: ["delivery"], scopes: "never" };
-const json = (schema, description) => ({
-    description,
-    content: { "application/json": { schema } },
-});
-const body = (schema) => ({
-    required: true,
-    content: { "application/json": { schema } },
-});
-const actionId = z.object({ actionId: z.string() });
-const SANDBOX_TOOLS = ["bash", "read", "write", "edit", "grep", "glob"];
-function deliveryOf(scope) {
-    if (scope.kind !== "delivery")
-        return fail(403, "A delivery token is required");
-    return scope;
-}
-export function actionRoutes(api) {
-    tenantRoute(api, CALLBACK, {
-        method: "post",
-        path: "/v1/actions/{actionId}/sandbox/{tool}",
-        tags: ["Action endpoints"],
-        summary: "Run a sandbox tool for an Action being delivered",
-        description: "Called by the Action endpoint with the Action's delivery token. The body is the tool's input.",
-        request: {
-            params: actionId.extend({ tool: z.enum(SANDBOX_TOOLS) }),
-            body: body(z.looseObject({}).meta({ description: "The tool's input" })),
-        },
-        responses: {
-            200: json(SandboxToolOutcome, "The tool's output, or why it failed"),
-            409: { description: "The delivery was cancelled, lost or sent again" },
-        },
-    }, async (c) => jsonResponse(200, await actionSandboxTool(c.env.tenant, deliveryOf(c.get("scope")), c.req.param("actionId"), c.req.param("tool"), () => readJson(c.req.raw), c.req.raw.signal)));
-    tenantRoute(api, CALLBACK, {
-        method: "post",
-        path: "/v1/actions/{actionId}/heartbeat",
-        tags: ["Action endpoints"],
-        summary: "Keep a background delivery alive",
-        description: "Called by an Action endpoint that answered a delivery with 202: extends the delivery by a " +
-            "lease and returns a fresh delivery token.",
-        request: { params: actionId },
-        responses: {
-            200: json(DeliveryHeartbeatResponse, "The delivery's new deadline, and a fresh token"),
-            409: { description: "The delivery was cancelled, lost or sent again" },
-        },
-    }, async (c) => jsonResponse(200, await deliveryHeartbeat(c.env.tenant, deliveryOf(c.get("scope")), c.req.param("actionId"))));
-    tenantRoute(api, {
-        credentials: ["application", "subject", "token"],
-        scopes: ["sessions:own"],
-    }, {
-        method: "post",
-        path: "/v1/sessions/{sessionId}/commands",
-        tags: ["Sessions"],
-        summary: "Send a command to a session",
-        description: "A message starts a turn; the others answer what the session waits on, or cancel. Idempotent on the command's `idempotencyKey`.",
-        request: {
-            params: z.object({ sessionId: z.string() }),
-            body: body(SessionCommand),
-        },
-        responses: {
-            200: json(AcceptedResponse, "The command, accepted"),
-            409: { description: "A turn is running, or the session does not wait on this" },
-        },
-    }, async (c) => jsonResponse(200, await command(c.env.tenant, c.req.param("sessionId"), SessionCommandSchema.parse(await readJson(c.req.raw)), c.get("scope"))));
-}

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

@@ -1,7 +0,0 @@
-/**
- * Action endpoints: where the Runtime delivers each agent's Actions (design: Action endpoints
- * §4.2). Registered, listed and removed with the application key; no subject reaches them.
- */
-import type { OpenAPIHono } from "@hono/zod-openapi";
-import type { TenantEnv } from "../app.js";
-export declare function endpointRoutes(api: OpenAPIHono<TenantEnv>): void;

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

@@ -1,100 +0,0 @@
-import { z } from "zod";
-import { PutEndpointsRequestSchema } from "@nylorun/core/contracts";
-import { DeleteEndpointResponse, EndpointPingResponse, ListEndpointsResponse, PutEndpointsRequest, } from "../../components.js";
-import { ActionOutcomeSchema } from "@nylorun/core/contracts";
-import { ActionOutcome, ActionResultReceipt } from "../../components.js";
-import { deliveryResult, pingEndpoint } from "../../../tenant/delivery.js";
-import { requireApplication } from "../../../tenant/auth.js";
-import { fail } from "../../../tenant/http.js";
-import { deleteEndpoint, listEndpoints, putEndpoints, } from "../../../tenant/endpoints.js";
-import { readJson } from "../body.js";
-import { tenantRoute } from "../define.js";
-import { jsonResponse } from "../respond.js";
-const APPLICATION = { credentials: ["application"], scopes: "never" };
-const json = (schema, description) => ({
-    description,
-    content: { "application/json": { schema } },
-});
-export function endpointRoutes(api) {
-    tenantRoute(api, APPLICATION, {
-        method: "get",
-        path: "/v1/endpoints",
-        tags: ["Action endpoints"],
-        summary: "List Action endpoints",
-        description: "Each agent's Action endpoint, with what recent deliveries say about it.",
-        responses: { 200: json(ListEndpointsResponse, "The endpoints") },
-    }, async (c) => {
-        requireApplication(c.get("scope"));
-        return jsonResponse(200, await listEndpoints(c.env.tenant));
-    });
-    tenantRoute(api, APPLICATION, {
-        method: "put",
-        path: "/v1/endpoints",
-        tags: ["Action endpoints"],
-        summary: "Register Action endpoints",
-        description: "Points the Runtime at the URL that runs each agent's Actions. A new URL starts with no " +
-            "health.",
-        request: {
-            body: { required: true, content: { "application/json": { schema: PutEndpointsRequest } } },
-        },
-        responses: { 200: json(ListEndpointsResponse, "The registered endpoints") },
-    }, async (c) => {
-        const principalId = requireApplication(c.get("scope"));
-        return jsonResponse(200, await putEndpoints(c.env.tenant, principalId, PutEndpointsRequestSchema.parse(await readJson(c.req.raw))));
-    });
-    tenantRoute(api, APPLICATION, {
-        method: "delete",
-        path: "/v1/endpoints/{agentId}",
-        tags: ["Action endpoints"],
-        summary: "Remove an agent's Action endpoint",
-        description: "The agent's pending Actions wait until an endpoint is registered again.",
-        request: { params: z.object({ agentId: z.string() }) },
-        responses: {
-            200: json(DeleteEndpointResponse, "The endpoint was removed"),
-            404: { description: "The agent has no endpoint" },
-        },
-    }, async (c) => {
-        requireApplication(c.get("scope"));
-        return jsonResponse(200, await deleteEndpoint(c.env.tenant, c.req.param("agentId")));
-    });
-    tenantRoute(api, APPLICATION, {
-        method: "post",
-        path: "/v1/endpoints/{agentId}/ping",
-        tags: ["Action endpoints"],
-        summary: "Ping an agent's Action endpoint",
-        description: "Sends a signed ping through the endpoint and records what it answers it serves. A " +
-            "wrong URL, a tunnel that is down or a handler that does not serve the agent answers 502.",
-        request: { params: z.object({ agentId: z.string() }) },
-        responses: {
-            200: json(EndpointPingResponse, "What the endpoint serves"),
-            404: { description: "The agent has no endpoint" },
-            502: { description: "The endpoint did not answer the ping" },
-        },
-    }, async (c) => {
-        requireApplication(c.get("scope"));
-        return jsonResponse(200, await pingEndpoint(c.env.tenant, c.req.param("agentId")));
-    });
-    tenantRoute(api, { credentials: ["delivery"], scopes: "never" }, {
-        method: "post",
-        path: "/v1/actions/{actionId}/result",
-        tags: ["Action endpoints"],
-        summary: "Post the outcome of an Action answered with 202",
-        description: "Called by an Action endpoint with the Action's delivery token after it answered the " +
-            "delivery with 202. The same result again returns the first receipt.",
-        request: {
-            params: z.object({ actionId: z.string() }),
-            body: { required: true, content: { "application/json": { schema: ActionOutcome } } },
-        },
-        responses: {
-            200: json(ActionResultReceipt, "The outcome was recorded"),
-            409: {
-                description: "The delivery was cancelled, lost or sent again, or the Action has another result",
-            },
-        },
-    }, async (c) => {
-        const scope = c.get("scope");
-        if (scope.kind !== "delivery")
-            return fail(403, "A delivery token is required");
-        return jsonResponse(200, await deliveryResult(c.env.tenant, scope, c.req.param("actionId"), ActionOutcomeSchema.parse(await readJson(c.req.raw))));
-    });
-}

package/dist/host/admin-api.d.ts

@@ -1,30 +0,0 @@
-/**
- * The Admin API (`/v1/admin/**`): the Host's status and shutdown, and the Tenant's operator
- * keys (F9 I1), for a caller with the admin key. A Host serves one Tenant, so there are no
- * Tenant routes: the status names the Tenant and, when it could not be opened, why
- * (tenancy.md §9). The Host checks the listener, the protocol and the admin key first
- * (`app.ts`); what gets here is authorized. Routes are declared once, for serving and for the
- * OpenAPI document.
- */
-import { OpenAPIHono } from "@hono/zod-openapi";
-import type { AdminStatus } from "@nylorun/core/contracts";
-import type { OperatorKeys } from "../tenant/operator-keys.js";
-import type { NodeBindings } from "../tenant/types.js";
-export interface AdminApiOptions {
-    /** `GET /v1/admin/status`. */
-    status(): Promise<AdminStatus>;
-    /** Stops the Host once the shutdown answer is sent. */
-    shutdown(): void;
-    /** `GET /v1/admin/openapi.json`: this API's OpenAPI document (`api/openapi.ts`). */
-    document?(): unknown;
-    /**
-     * The open Tenant's operator keys (`/v1/admin/keys`); undefined while the Tenant is not open.
-     * Rejects with `TenantUnavailableError` (503) when it cannot be reached.
-     */
-    operatorKeys?(): Promise<OperatorKeys | undefined>;
-}
-type AdminEnv = {
-    Bindings: NodeBindings;
-};
-export declare function createAdminApi(options: AdminApiOptions): OpenAPIHono<AdminEnv>;
-export {};

package/dist/host/admin-api.js

@@ -1,140 +0,0 @@
-/**
- * The Admin API (`/v1/admin/**`): the Host's status and shutdown, and the Tenant's operator
- * keys (F9 I1), for a caller with the admin key. A Host serves one Tenant, so there are no
- * Tenant routes: the status names the Tenant and, when it could not be opened, why
- * (tenancy.md §9). The Host checks the listener, the protocol and the admin key first
- * (`app.ts`); what gets here is authorized. Routes are declared once, for serving and for the
- * OpenAPI document.
- */
-import { OpenAPIHono } from "@hono/zod-openapi";
-import { z } from "zod";
-import { AdminStatus as AdminStatusBody, DeleteOperatorKeyResponse, HostShutdownResponse, ListOperatorKeysResponse, PutOperatorKeyResponse, ProtocolRejected, Rejected, } from "../api/components.js";
-import { serveRoute } from "../api/route.js";
-import { jsonResponse, rejectedResponse } from "./http.js";
-const json = (schema, description) => ({
-    description,
-    content: { "application/json": { schema } },
-});
-const rejected = (description) => json(Rejected, description);
-/** What every Admin route may answer before its own logic runs. */
-const gated = {
-    404: rejected("Not found: an unknown admin key, or the public listener"),
-    426: json(ProtocolRejected, "`Nylorun-Protocol` missing or unsupported"),
-};
-function adminRoute(route) {
-    return {
-        ...route,
-        tags: ["Admin"],
-        security: [{ adminKey: [] }],
-        responses: { ...gated, ...route.responses },
-    };
-}
-export function createAdminApi(options) {
-    const api = new OpenAPIHono();
-    // HEAD is not a GET here: an Admin route answers only the methods it declares.
-    api.use(async (c, next) => {
-        if (c.req.method === "HEAD")
-            return notFound();
-        await next();
-    });
-    // D12: `/v1/admin/status` and `/v1/admin/host` are one answer.
-    for (const path of ["/v1/admin/status", "/v1/admin/host"])
-        serveRoute(api, adminRoute({
-            method: "get",
-            path,
-            summary: path.endsWith("host") ? "Get the Host's status (alias)" : "Get the Host's status",
-            responses: { 200: json(AdminStatusBody, "Version, protocol, the Tenant and the Host") },
-        }), async () => jsonResponse(200, await options.status()));
-    serveRoute(api, adminRoute({
-        method: "post",
-        path: "/v1/admin/host/shutdown",
-        summary: "Shut the Host down",
-        description: "Answers, then stops the Host. Served by a self-hosted Runtime only.",
-        responses: { 200: json(HostShutdownResponse, "The Host is stopping") },
-    }), (c) => {
-        c.env.outgoing.once("finish", () => options.shutdown());
-        return jsonResponse(200, { status: "shutting_down" });
-    });
-    const keyId = z.object({
-        id: z.string().meta({ description: "The key's name: `^[a-z][a-z0-9-]{0,31}$`, never `studio`" }),
-    });
-    const keysOf = async () => (await options.operatorKeys?.()) ??
-        rejectedResponse(503, "request_rejected", "The Tenant is not open: see /v1/admin/status");
-    serveRoute(api, adminRoute({
-        method: "get",
-        path: "/v1/admin/keys",
-        summary: "List the Tenant's keys",
-        description: "Every application key of the Tenant by name, with its role and when it was issued. Keys themselves are never shown again.",
-        responses: {
-            200: json(ListOperatorKeysResponse, "The keys, by id"),
-            503: rejected("The Tenant is not open"),
-        },
-    }), async () => {
-        const keys = await keysOf();
-        if (keys instanceof Response)
-            return keys;
-        return jsonResponse(200, { keys: await keys.list() });
-    });
-    serveRoute(api, adminRoute({
-        method: "put",
-        path: "/v1/admin/keys/{id}",
-        summary: "Create or rotate a key",
-        description: "Issues a new key named `id` and returns it this once. A key of that name is replaced: the old one stops authenticating at once. `studio` is refused.",
-        request: { params: keyId },
-        responses: {
-            200: json(PutOperatorKeyResponse, "The new key, shown once"),
-            400: rejected("Not a key name, or `studio`"),
-            503: rejected("The Tenant is not open"),
-        },
-    }), async (c) => {
-        const keys = await keysOf();
-        if (keys instanceof Response)
-            return keys;
-        const put = await keys.put(c.req.param("id") ?? "");
-        return "reason" in put ? refusedResponse(put) : jsonResponse(200, put);
-    });
-    serveRoute(api, adminRoute({
-        method: "delete",
-        path: "/v1/admin/keys/{id}",
-        summary: "Delete a key",
-        description: "The key stops authenticating at once. `studio` is refused.",
-        request: { params: keyId },
-        responses: {
-            200: json(DeleteOperatorKeyResponse, "The key is deleted"),
-            400: rejected("Not a key name, or `studio`"),
-            404: rejected("No key of that name; or an unknown admin key, or the public listener"),
-            503: rejected("The Tenant is not open"),
-        },
-    }), async (c) => {
-        const keys = await keysOf();
-        if (keys instanceof Response)
-            return keys;
-        const id = c.req.param("id") ?? "";
-        const deleted = await keys.delete(id);
-        if (typeof deleted !== "boolean")
-            return refusedResponse(deleted);
-        return deleted
-            ? jsonResponse(200, { id, deleted: true })
-            : rejectedResponse(404, "not_found", `No key ${id}`);
-    });
-    serveRoute(api, adminRoute({
-        method: "get",
-        path: "/v1/admin/openapi.json",
-        summary: "Get this document",
-        responses: { 200: { description: "The Admin API's OpenAPI document" } },
-    }), () => options.document
-        ? jsonResponse(200, options.document(), { "cache-control": "no-cache" })
-        : notFound());
-    api.notFound(() => notFound());
-    // The Host answers what a route throws (`app.ts`), as it did before Hono.
-    api.onError((error) => {
-        throw error;
-    });
-    return api;
-}
-function notFound() {
-    return rejectedResponse(404, "not_found", "Route not found");
-}
-function refusedResponse(refusal) {
-    return rejectedResponse(400, refusal.reason === "invalid" ? "invalid_request" : "request_rejected", refusal.message);
-}

package/dist/mcp/stdio.d.ts

@@ -1,17 +0,0 @@
-import type { McpServerManifest } from "@nylorun/core/define";
-/** Single-pass replacement. Text inserted for a token is not scanned again. */
-export declare function expandPluginPlaceholders(value: string, pluginRoot: string, pluginData: string): string;
-export interface StdioLaunch {
-    readonly command: string;
-    readonly args: readonly string[];
-    readonly cwd: string;
-    readonly env: Readonly<Record<string, string>>;
-}
-export declare function prepareStdioLaunch(server: Extract<McpServerManifest, {
-    type: "stdio";
-}>, options: {
-    readonly pluginRoot?: string;
-    readonly pluginData: string;
-    /** Allowlisted base env (Tenant HOME/TMPDIR/PATH). Manifest env overlays it (A9). */
-    readonly childEnv?: Readonly<Record<string, string>>;
-}): StdioLaunch;

package/dist/mcp/stdio.js

@@ -1,82 +0,0 @@
-import { mkdirSync } from "node:fs";
-import { isAbsolute, relative, resolve, sep } from "node:path";
-const ROOT_TOKEN = "${PLUGIN_ROOT}";
-const DATA_TOKEN = "${PLUGIN_DATA}";
-/** Single-pass replacement. Text inserted for a token is not scanned again. */
-export function expandPluginPlaceholders(value, pluginRoot, pluginData) {
-    let out = "";
-    for (let index = 0; index < value.length;) {
-        if (value.startsWith(ROOT_TOKEN, index)) {
-            out += pluginRoot;
-            index += ROOT_TOKEN.length;
-            continue;
-        }
-        if (value.startsWith(DATA_TOKEN, index)) {
-            out += pluginData;
-            index += DATA_TOKEN.length;
-            continue;
-        }
-        out += value[index];
-        index += 1;
-    }
-    return out;
-}
-export function prepareStdioLaunch(server, options) {
-    const pluginData = options.pluginData;
-    mkdirSync(pluginData, { recursive: true });
-    const pluginRoot = options.pluginRoot;
-    if (needsPluginRoot(server) && !pluginRoot)
-        throw new Error("stdio server requires a plugin root");
-    for (const key of Object.keys(server.env ?? {})) {
-        if (key === "PLUGIN_ROOT" || key === "PLUGIN_DATA")
-            throw new Error(`stdio env must not set ${key}`);
-    }
-    const command = server.command.startsWith("./")
-        ? resolve(pluginRoot, server.command)
-        : server.command;
-    const args = (server.args ?? []).map((arg) => expand(arg, pluginRoot, pluginData));
-    const cwd = server.cwd
-        ? resolveContainedCwd(server.cwd, pluginRoot, pluginData)
-        : (pluginRoot ?? pluginData);
-    // childEnv under manifest env; HOME/TMPDIR from childEnv override Host defaults
-    // that StdioClientTransport merges via getDefaultEnvironment() (R2).
-    const env = { ...(options.childEnv ?? {}) };
-    for (const [key, value] of Object.entries(server.env ?? {}))
-        env[key] = expand(value, pluginRoot, pluginData);
-    if (pluginRoot)
-        env.PLUGIN_ROOT = pluginRoot;
-    env.PLUGIN_DATA = pluginData;
-    return { command, args, cwd, env };
-}
-function needsPluginRoot(server) {
-    if (server.command.startsWith("./"))
-        return true;
-    const values = [
-        ...(server.args ?? []),
-        ...Object.values(server.env ?? {}),
-        ...(server.cwd === undefined ? [] : [server.cwd]),
-    ];
-    return values.some((value) => value.includes(ROOT_TOKEN));
-}
-function expand(value, pluginRoot, pluginData) {
-    if (value.includes(ROOT_TOKEN) && !pluginRoot)
-        throw new Error("stdio server requires a plugin root");
-    return expandPluginPlaceholders(value, pluginRoot ?? "", pluginData);
-}
-function resolveContainedCwd(cwd, pluginRoot, pluginData) {
-    const expanded = expand(cwd, pluginRoot, pluginData);
-    const base = cwdTargetsData(cwd) ? pluginData : pluginRoot;
-    if (!base)
-        throw new Error("stdio server requires a plugin root");
-    const absolute = isAbsolute(expanded) ? expanded : resolve(base, expanded);
-    if (!isInside(base, absolute))
-        throw new Error(`Working directory escapes ${base}`);
-    return absolute;
-}
-function cwdTargetsData(cwd) {
-    return cwd === DATA_TOKEN || cwd.startsWith(`${DATA_TOKEN}/`);
-}
-function isInside(root, target) {
-    const rel = relative(root, target);
-    return rel === "" || (!rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel));
-}

package/dist/tenant/actions.d.ts

@@ -1,14 +0,0 @@
-import { type SandboxRouteDeps } from "../core/sandbox-routes.js";
-import { type TenantContext } from "./context.js";
-import type { DeliveryScope } from "./delivery-token.js";
-/** Session and Action lookups for the sandbox route handlers. */
-export declare function sandboxRouteDeps(ctx: TenantContext): SandboxRouteDeps;
-/** `POST /v1/actions/:id/sandbox/:tool`: a sandbox tool call for the Action being delivered. */
-export declare function actionSandboxTool(ctx: TenantContext, scope: DeliveryScope, actionId: string, toolName: string, body: () => Promise<unknown>, signal: AbortSignal): Promise<{
-    kind: "completed";
-    output: unknown;
-} | {
-    kind: "failed";
-    code: string;
-    message: string;
-}>;

package/dist/tenant/actions.js

@@ -1,29 +0,0 @@
-import { SandboxRouteError, handleActionSandboxTool, } from "../core/sandbox-routes.js";
-import { scoped } from "./auth.js";
-import { sandboxLookup, sessionOf } from "./context.js";
-import { fail } from "./http.js";
-/** Session and Action lookups for the sandbox route handlers. */
-export function sandboxRouteDeps(ctx) {
-    return {
-        sandbox: ctx.sandbox,
-        session: (id) => ctx.store.tx(async (t) => {
-            const session = await sessionOf(t, id);
-            return { session, lookup: await sandboxLookup(t, id) };
-        }),
-        getAction: (id) => ctx.store.tx((t) => t.get("actions", id)),
-    };
-}
-/** `POST /v1/actions/:id/sandbox/:tool`: a sandbox tool call for the Action being delivered. */
-export async function actionSandboxTool(ctx, scope, actionId, toolName, body, signal) {
-    const action = (await ctx.store.tx((t) => t.get("actions", actionId))) ??
-        fail(404, "Action not found");
-    scoped(scope, action);
-    try {
-        return await handleActionSandboxTool(sandboxRouteDeps(ctx), actionId, toolName, await body(), signal, { generation: scope.generation });
-    }
-    catch (error) {
-        if (error instanceof SandboxRouteError)
-            fail(error.status, error.message);
-        throw error;
-    }
-}

package/dist/tenant/delivery-token.d.ts

@@ -1,41 +0,0 @@
-import type { AuthScope, TenantContext } from "./context.js";
-/** What a delivery token is for: one delivery of an Action, or a ping. */
-export type DeliveryTokenFor = {
-    kind: "action";
-    actionId: string;
-    agentId: string;
-    generation: number;
-} | {
-    kind: "ping";
-    agentId: string;
-};
-export interface MintedDeliveryToken {
-    token: string;
-    /** Milliseconds since the epoch. */
-    expiresAt: number;
-    tokenId: string;
-    keyId: string;
-}
-/** The request scope of a verified delivery token (`AuthScope` kind `delivery`). */
-export type DeliveryScope = Extract<AuthScope, {
-    kind: "delivery";
-}>;
-/** base64url SHA-256 of a request body: the token's `bdy` claim. */
-export declare function bodyHash(body: string | Uint8Array): string;
-/**
- * Signs a token for `delivery`, for the endpoint at `audience`, covering `body`. `ttlSeconds`
- * is capped at `DELIVERY_TOKEN_MAX_TTL_SECONDS`.
- */
-export declare function mintDeliveryToken(ctx: TenantContext, options: {
-    for: DeliveryTokenFor;
-    audience: string;
-    body: string | Uint8Array;
-    ttlSeconds: number;
-}): Promise<MintedDeliveryToken>;
-/**
- * Verifies a delivery token presented as a bearer. Answers `401 token_expired` for an expired
- * token or a revoked key, and the opaque 404 for everything else, a ping token included: only
- * an Action's token reaches its callbacks. Whether the Action is still being delivered at the
- * token's generation is checked where the Action is read (`auth.ts` `scoped`).
- */
-export declare function verifyDeliveryToken(ctx: TenantContext, raw: string): Promise<DeliveryScope>;

package/dist/tenant/delivery-token.js

@@ -1,104 +0,0 @@
-/**
- * Delivery tokens (design: Action endpoints §8.1): the ES256 JWT the Runtime signs, with the
- * Tenant's current signing key, for one delivery of one Action, or for a ping. It travels in
- * `Nylorun-Signature` on the request to the Action endpoint, which verifies it with the
- * Tenant's public keys, and comes back as the bearer of that Action's callbacks (a background
- * result, heartbeats, sandbox tools).
- *
- * A token lives at most `DELIVERY_TOKEN_MAX_TTL_SECONDS` (`TOKEN_TTL_MAX_SECONDS`), and key
- * rotation waits at least that long before it revokes the previous key
- * (`signing-keys.ts`), so a rotation never revokes a live token.
- */
-import { createHash, randomUUID } from "node:crypto";
-import { errors, jwtVerify } from "jose";
-import { DELIVERY_TOKEN_MAX_TTL_SECONDS, DELIVERY_TOKEN_TYPE, tenantTokenIssuer, } from "@nylorun/core/contracts";
-import { failOpaque, HttpError } from "./http.js";
-import { CLOCK_TOLERANCE_SECONDS, tokenKeyId } from "./jwt.js";
-/** base64url SHA-256 of a request body: the token's `bdy` claim. */
-export function bodyHash(body) {
-    return createHash("sha256").update(body).digest("base64url");
-}
-/**
- * Signs a token for `delivery`, for the endpoint at `audience`, covering `body`. `ttlSeconds`
- * is capped at `DELIVERY_TOKEN_MAX_TTL_SECONDS`.
- */
-export async function mintDeliveryToken(ctx, options) {
-    const ttl = Math.max(1, Math.min(Math.floor(options.ttlSeconds), DELIVERY_TOKEN_MAX_TTL_SECONDS));
-    const iat = Math.floor(Date.now() / 1000);
-    const tokenId = randomUUID();
-    const delivery = options.for;
-    // Signed by the keys service (F4.2): this process never holds the private key.
-    const { token, keyId } = await ctx.keys.sign({
-        typ: DELIVERY_TOKEN_TYPE,
-        claims: {
-            agt: delivery.agentId,
-            gen: delivery.kind === "action" ? delivery.generation : 0,
-            bdy: bodyHash(options.body),
-            iss: tenantTokenIssuer(ctx.config.tenantId),
-            aud: options.audience,
-            sub: delivery.kind === "action" ? delivery.actionId : "ping",
-            iat,
-            exp: iat + ttl,
-            jti: tokenId,
-        },
-    });
-    return { token, expiresAt: (iat + ttl) * 1000, tokenId, keyId };
-}
-/**
- * Verifies a delivery token presented as a bearer. Answers `401 token_expired` for an expired
- * token or a revoked key, and the opaque 404 for everything else, a ping token included: only
- * an Action's token reaches its callbacks. Whether the Action is still being delivered at the
- * token's generation is checked where the Action is read (`auth.ts` `scoped`).
- */
-export async function verifyDeliveryToken(ctx, raw) {
-    const checked = tokenKeyId(raw, DELIVERY_TOKEN_TYPE);
-    if ("refused" in checked)
-        return refused(ctx, `delivery_token_${checked.refused}`);
-    const { kid } = checked;
-    const row = await ctx.store.tx((t) => t.signingKey(kid));
-    if (!row)
-        return refused(ctx, "delivery_token_key_unknown");
-    let claims;
-    try {
-        const verified = await jwtVerify(raw, await ctx.signingKeys.publicKey(row), {
-            algorithms: ["ES256"],
-            issuer: tenantTokenIssuer(ctx.config.tenantId),
-            typ: DELIVERY_TOKEN_TYPE,
-            clockTolerance: CLOCK_TOLERANCE_SECONDS,
-            requiredClaims: ["sub", "aud", "iat", "exp", "jti"],
-        });
-        claims = verified.payload;
-    }
-    catch (error) {
-        if (error instanceof errors.JWTExpired)
-            expired(ctx, "delivery_token_expired");
-        return refused(ctx, "delivery_token_invalid");
-    }
-    if (row.state === "revoked")
-        expired(ctx, "delivery_token_key_revoked");
-    const { sub, agt, gen, exp, iat, jti } = claims;
-    if (sub === "ping" ||
-        typeof agt !== "string" ||
-        typeof gen !== "number" ||
-        !Number.isInteger(gen) ||
-        gen < 1 ||
-        exp - iat > DELIVERY_TOKEN_MAX_TTL_SECONDS)
-        return refused(ctx, "delivery_token_claims");
-    return {
-        kind: "delivery",
-        actionId: sub,
-        agentId: agt,
-        generation: gen,
-        expiresAt: exp * 1000,
-        tokenId: jti,
-        keyId: kid,
-    };
-}
-function refused(ctx, reason) {
-    ctx.config.logger.warn("credential rejected", { reason });
-    return failOpaque();
-}
-function expired(ctx, reason) {
-    ctx.config.logger.warn("delivery token refused", { reason });
-    throw new HttpError(401, "The delivery token has expired or its key was revoked", { code: "token_expired" }, { "www-authenticate": 'Bearer error="invalid_token"' });
-}