@nylorun/runtime 0.16.0-beta → 0.19.0-beta

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,23 +0,0 @@
-/**
- * The Admin API (`/v1/admin/**`): the Host's status and shutdown, 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 { 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;
-}
-type AdminEnv = {
-    Bindings: NodeBindings;
-};
-export declare function createAdminApi(options: AdminApiOptions): OpenAPIHono<AdminEnv>;
-export {};

package/dist/host/admin-api.js

@@ -1,74 +0,0 @@
-/**
- * The Admin API (`/v1/admin/**`): the Host's status and shutdown, 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, HostShutdownResponse, 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" });
-    });
-    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");
-}

package/dist/host/cors.d.ts

@@ -1,27 +0,0 @@
-/**
- * Browser access at the Host (Host feature `browser-access`). A preflight carries no
- * credentials and no header values, so it cannot name a Tenant: the Host answers it from the
- * route alone, permissively for browser routes, and the Tenant enforces the publishable key's
- * origin allowlist on the actual request (`tenant/browser.ts`). A cached preflight therefore
- * never widens access, and it grants no credentials.
- */
-import type { IncomingMessage, ServerResponse } from "node:http";
-/** Request headers a browser may send to the Runtime. */
-export declare const BROWSER_REQUEST_HEADERS: readonly ["authorization", "content-type", "nylorun-key", "nylorun-tenant", "nylorun-protocol", "last-event-id"];
-/**
- * Tenant routes a browser may call: agents (list), sessions (not the sandbox tool route),
- * vaults, AG-UI and the JWKS. Tokens, access management, endpoints, actions and Tenant
- * settings never are.
- */
-/** The `Origin` header if it is a serialized origin (not `null`, not a path). */
-export declare function browserOrigin(request: IncomingMessage): string | undefined;
-/**
- * Answers a CORS preflight: `204` with the allowed methods and headers for a browser route,
- * `403` without any CORS header otherwise.
- */
-export declare function answerPreflight(request: IncomingMessage, response: ServerResponse, segments: readonly string[], isBrowserRoute: (method: string, segments: readonly string[]) => boolean): number;
-/**
- * CORS headers for an actual request from an allowed origin; set once with `setHeader`, so
- * every response that follows (JSON, errors, SSE) carries them.
- */
-export declare function setCorsHeaders(response: ServerResponse, origin: string): void;

package/dist/host/cors.js

@@ -1,64 +0,0 @@
-import { isSerializedOrigin } from "@nylorun/core/contracts";
-/** Request headers a browser may send to the Runtime. */
-export const BROWSER_REQUEST_HEADERS = [
-    "authorization",
-    "content-type",
-    "nylorun-key",
-    "nylorun-tenant",
-    "nylorun-protocol",
-    "last-event-id",
-];
-const BROWSER_METHODS = ["GET", "POST", "PUT", "DELETE"];
-const PREFLIGHT_MAX_AGE_SECONDS = 600;
-/**
- * Tenant routes a browser may call: agents (list), sessions (not the sandbox tool route),
- * vaults, AG-UI and the JWKS. Tokens, access management, endpoints, actions and Tenant
- * settings never are.
- */
-/** The `Origin` header if it is a serialized origin (not `null`, not a path). */
-export function browserOrigin(request) {
-    const raw = request.headers.origin;
-    const origin = Array.isArray(raw) ? raw[0] : raw;
-    return origin !== undefined && isSerializedOrigin(origin) ? origin : undefined;
-}
-/**
- * Answers a CORS preflight: `204` with the allowed methods and headers for a browser route,
- * `403` without any CORS header otherwise.
- */
-export function answerPreflight(request, response, segments, isBrowserRoute) {
-    const origin = browserOrigin(request);
-    const method = String(request.headers["access-control-request-method"] ?? "").toUpperCase();
-    const requested = String(request.headers["access-control-request-headers"] ?? "")
-        .split(",")
-        .map((name) => name.trim().toLowerCase())
-        .filter(Boolean);
-    const allowed = origin !== undefined &&
-        BROWSER_METHODS.includes(method) &&
-        isBrowserRoute(method, segments) &&
-        requested.every((name) => BROWSER_REQUEST_HEADERS.includes(name));
-    if (!allowed) {
-        response.writeHead(403, { "content-length": "0" });
-        response.end();
-        return 403;
-    }
-    response.writeHead(204, {
-        "access-control-allow-origin": origin,
-        "access-control-allow-methods": BROWSER_METHODS.join(", "),
-        "access-control-allow-headers": requested.join(", "),
-        "access-control-max-age": String(PREFLIGHT_MAX_AGE_SECONDS),
-        vary: "Origin, Access-Control-Request-Method, Access-Control-Request-Headers",
-        "content-length": "0",
-    });
-    response.end();
-    return 204;
-}
-/**
- * CORS headers for an actual request from an allowed origin; set once with `setHeader`, so
- * every response that follows (JSON, errors, SSE) carries them.
- */
-export function setCorsHeaders(response, origin) {
-    response.setHeader("access-control-allow-origin", origin);
-    response.setHeader("vary", "Origin");
-    response.setHeader("access-control-expose-headers", "retry-after, www-authenticate");
-    response.setHeader("cache-control", "no-store");
-}

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/access-policy.d.ts

@@ -1,30 +0,0 @@
-/**
- * The Tenant's access policy (Host feature `subject-tokens`): the roles subject tokens are
- * minted for, what a publishable key grants alone (`anon`), and how long tokens live. One
- * validated JSON document in the Tenant settings; a Tenant that never set one has no roles,
- * so nothing can be minted.
- *
- * A token's permissions are resolved from the policy on every request, so editing a role
- * changes outstanding tokens at their next request and removing one ends them.
- */
-import { type AccessPolicy, type RoleLimits, type TokenScope } from "@nylorun/core/contracts";
-import type { Tx } from "../store/types.js";
-export declare const ACCESS_POLICY_SETTING = "access.policy";
-export declare function readPolicy(t: Tx): Promise<AccessPolicy>;
-export declare function writePolicy(t: Tx, policy: AccessPolicy): Promise<void>;
-/** What a token may do right now: its role narrowed by what the mint asked for. */
-export interface EffectiveAccess {
-    readonly role: string;
-    readonly scopes: ReadonlySet<TokenScope>;
-    readonly agents: ReadonlySet<string> | "*";
-    readonly limits?: RoleLimits;
-}
-/** Agents both lists allow; `"*"` allows every agent. */
-export declare function intersectAgents(a: readonly string[] | "*", b: readonly string[] | "*" | undefined): ReadonlySet<string> | "*";
-/**
- * The role's permissions narrowed to `scopes` and `agents`, or undefined when the role no
- * longer exists.
- */
-export declare function resolveRole(policy: AccessPolicy, role: string, scopes: readonly TokenScope[], agents?: readonly string[]): EffectiveAccess | undefined;
-/** True when `agentId` is allowed by `agents`. */
-export declare function agentAllowed(agents: ReadonlySet<string> | "*", agentId: string): boolean;

package/dist/tenant/access-policy.js

@@ -1,52 +0,0 @@
-/**
- * The Tenant's access policy (Host feature `subject-tokens`): the roles subject tokens are
- * minted for, what a publishable key grants alone (`anon`), and how long tokens live. One
- * validated JSON document in the Tenant settings; a Tenant that never set one has no roles,
- * so nothing can be minted.
- *
- * A token's permissions are resolved from the policy on every request, so editing a role
- * changes outstanding tokens at their next request and removing one ends them.
- */
-import { AccessPolicySchema, DEFAULT_ACCESS_POLICY, } from "@nylorun/core/contracts";
-export const ACCESS_POLICY_SETTING = "access.policy";
-export async function readPolicy(t) {
-    const stored = await t.getSetting(ACCESS_POLICY_SETTING);
-    if (stored === undefined)
-        return DEFAULT_ACCESS_POLICY;
-    // Only `writePolicy` stores it, after validation.
-    return AccessPolicySchema.parse(JSON.parse(stored));
-}
-export async function writePolicy(t, policy) {
-    await t.putSetting(ACCESS_POLICY_SETTING, JSON.stringify(AccessPolicySchema.parse(policy)));
-}
-/** Agents both lists allow; `"*"` allows every agent. */
-export function intersectAgents(a, b) {
-    if (b === undefined || b === "*")
-        return a === "*" ? "*" : new Set(a);
-    if (a === "*")
-        return new Set(b);
-    const allowed = new Set(a);
-    return new Set(b.filter((agent) => allowed.has(agent)));
-}
-/**
- * The role's permissions narrowed to `scopes` and `agents`, or undefined when the role no
- * longer exists.
- */
-export function resolveRole(policy, role, scopes, agents) {
-    const entry = Object.hasOwn(policy.roles, role)
-        ? policy.roles[role]
-        : undefined;
-    if (!entry)
-        return undefined;
-    const allowed = new Set(entry.scopes);
-    return {
-        role,
-        scopes: new Set(scopes.filter((scope) => allowed.has(scope))),
-        agents: intersectAgents(entry.agents, agents),
-        ...(entry.limits ? { limits: entry.limits } : {}),
-    };
-}
-/** True when `agentId` is allowed by `agents`. */
-export function agentAllowed(agents, agentId) {
-    return agents === "*" || agents.has(agentId);
-}

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/browser.d.ts

@@ -1,15 +0,0 @@
-/**
- * Which client app a request comes from (Host feature `browser-access`), decided before the
- * bearer is looked at. `Nylorun-Key` names a publishable key of this Tenant; an `Origin` must
- * be on that key's allowlist, and only then does the response carry CORS headers. The
- * allowlist protects browsers from other sites' pages; it is not authentication, since a
- * non-browser can send any `Origin`: tokens authorize.
- */
-import type { IncomingMessage, ServerResponse } from "node:http";
-import type { TenantContext } from "./context.js";
-/** The client app of a request: its publishable key, and the origin when from a browser. */
-export interface BrowserClient {
-    readonly keyId: string;
-    readonly origin?: string;
-}
-export declare function identifyClient(ctx: TenantContext, request: IncomingMessage, response: ServerResponse): Promise<BrowserClient | undefined>;

package/dist/tenant/browser.js

@@ -1,39 +0,0 @@
-import { PUBLISHABLE_KEY_HEADER } from "@nylorun/core/compatibility";
-import { originAllowed } from "@nylorun/core/contracts";
-import { browserOrigin, setCorsHeaders } from "../host/cors.js";
-import { fail, failOpaque } from "./http.js";
-function single(request, name) {
-    const raw = request.headers[name.toLowerCase()];
-    return Array.isArray(raw) ? raw[0] : raw;
-}
-export async function identifyClient(ctx, request, response) {
-    const key = single(request, PUBLISHABLE_KEY_HEADER);
-    const hasOrigin = request.headers.origin !== undefined;
-    if (key === undefined) {
-        if (hasOrigin)
-            fail(403, `Browser requests need ${PUBLISHABLE_KEY_HEADER}`, {
-                code: "origin_rejected",
-            });
-        return undefined;
-    }
-    const row = await ctx.store.tx((t) => t.publishableKeyByKey(key));
-    if (!row || row.revokedAt !== null) {
-        ctx.config.logger.warn("credential rejected", {
-            reason: "publishable_key_rejected",
-        });
-        return failOpaque();
-    }
-    if (!hasOrigin)
-        return { keyId: row.id };
-    const origin = browserOrigin(request);
-    const origins = JSON.parse(row.originsJson);
-    if (origin === undefined || !originAllowed(origins, origin)) {
-        ctx.config.logger.warn("credential rejected", {
-            reason: "origin_not_allowed",
-            keyId: row.id,
-        });
-        return failOpaque();
-    }
-    setCorsHeaders(response, origin);
-    return { keyId: row.id, origin };
-}

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>;