@nylorun/runtime 0.25.0-beta → 0.27.0-beta

package/dist/keys/contract.d.ts

@@ -4,12 +4,10 @@
  * gates token. Internal: only core calls it, so it is not in the published OpenAPI documents.
  *
  * `200 {result}` when the operation succeeded, `200 {error}` when it refused: a vault error or
- * a Tenant API error with its status, code and details, so the route that called it answers
+ * a Runtime or Management API error with its status, code and details, so the route that called it answers
  * exactly what it answered when the operation ran in its own process.
  */
 export declare const KEYS_PATH = "/nylorun/v1/keys";
-/** Largest request body: a credential with its secret, or a token's claims. */
-export declare const MAX_KEYS_BODY_BYTES: number;
 export interface KeysError {
     readonly kind: "vault" | "http";
     readonly status: number;

package/dist/keys/contract.js

@@ -4,9 +4,7 @@
  * gates token. Internal: only core calls it, so it is not in the published OpenAPI documents.
  *
  * `200 {result}` when the operation succeeded, `200 {error}` when it refused: a vault error or
- * a Tenant API error with its status, code and details, so the route that called it answers
+ * a Runtime or Management API error with its status, code and details, so the route that called it answers
  * exactly what it answered when the operation ran in its own process.
  */
 export const KEYS_PATH = "/nylorun/v1/keys";
-/** Largest request body: a credential with its secret, or a token's claims. */
-export const MAX_KEYS_BODY_BYTES = 1024 * 1024;

package/dist/keys/egress-ca.d.ts

@@ -1,6 +1,4 @@
 import type { SessionStore } from "../store/types.js";
-/** How long a leaf egress-gate presents is valid: one connection rarely lasts this long. */
-export declare const EGRESS_LEAF_MINUTES = 60;
 export declare class EgressAuthority {
     private readonly store;
     private readonly kek;

package/dist/keys/egress-ca.js

@@ -10,8 +10,6 @@ import { X509Certificate } from "node:crypto";
 import { decryptSecret, encryptSecret } from "../vault/crypto.js";
 import { createCertificateAuthority, issueLeafCertificate } from "./x509.js";
 const SETTING = "egress.ca";
-/** How long a leaf egress-gate presents is valid: one connection rarely lasts this long. */
-export const EGRESS_LEAF_MINUTES = 60;
 function aad(certificate) {
     return Buffer.from(`nylorun.egress-ca:${new X509Certificate(certificate).fingerprint256}`);
 }
@@ -30,7 +28,8 @@ export class EgressAuthority {
     }
     /** A leaf for `host` and the caller's P-256 public key (SPKI PEM); the caller keeps its key. */
     async signLeaf(host, publicKey) {
-        return issueLeafCertificate({ authority: await this.load(), host, publicKey, minutes: EGRESS_LEAF_MINUTES });
+        // Valid for `keys.leafLifetimeMs` (Host tuning): one connection rarely lasts this long.
+        return issueLeafCertificate({ authority: await this.load(), host, publicKey });
     }
     async load() {
         if (this.authority)

package/dist/keys/keys.js

@@ -16,6 +16,7 @@
 import { EgressAuthority } from "./egress-ca.js";
 import { SignJWT } from "jose";
 import { previewMcpServer } from "../mcp/preview.js";
+import { readRuntimeLimits } from "../tenant/runtime-limits.js";
 import { signingKeyView } from "../tenant/signing-keys.js";
 /** The operations, by the name the HTTP route carries. */
 export const KEYS_OPERATIONS = [
@@ -56,7 +57,11 @@ export function inProcessKeys(options) {
             const key = kek();
             await store.tx((t) => signingKeys.ensure(t, key));
         },
-        previewMcp: (body) => previewMcpServer(body, { vault, policy: options.policy ?? {} }),
+        previewMcp: async (body) => previewMcpServer(body, {
+            vault,
+            policy: options.policy ?? {},
+            limits: await store.tx((t) => readRuntimeLimits(t)),
+        }),
         egressCa: () => egress.certificate(),
         signEgressLeaf: (host, publicKey) => egress.signLeaf(host, publicKey),
     };

package/dist/keys/x509.d.ts

@@ -4,22 +4,26 @@ export interface CertificateAuthority {
     /** PKCS#8 PEM of the CA key: sealed in the vault, used only by keys. */
     readonly privateKey: string;
 }
-/** A new P-256 CA, valid from an hour ago for `days` days. */
+/**
+ * A new P-256 CA, valid from `keys.caBackdateMs` ago (Host tuning, an hour) for `days` days
+ * (default `keys.caLifetimeDays`).
+ */
 export declare function createCertificateAuthority(options: {
     readonly commonName: string;
     readonly days?: number;
     readonly now?: Date;
 }): CertificateAuthority;
 /**
- * A leaf for `host` and the caller's `publicKey` (SPKI PEM), signed by the CA, valid from five
- * minutes ago for `minutes` minutes. The caller keeps the leaf's private key: only the
+ * A leaf for `host` and the caller's `publicKey` (SPKI PEM), signed by the CA, valid from
+ * `keys.leafBackdateMs` ago (Host tuning, five minutes) for `lifetimeMs` (default
+ * `keys.leafLifetimeMs`, an hour: one connection rarely lasts this long). The caller keeps the leaf's private key: only the
  * certificate comes back, so no private key leaves whoever holds it.
  */
 export declare function issueLeafCertificate(options: {
     readonly authority: CertificateAuthority;
     readonly host: string;
     readonly publicKey: string;
-    readonly minutes?: number;
+    readonly lifetimeMs?: number;
     readonly now?: Date;
 }): string;
 /** A P-256 key pair for a leaf, as PEM: SPKI for the public key, PKCS#8 for the private key. */

package/dist/keys/x509.js

@@ -10,6 +10,7 @@
  * CA's key identifier. Go (`gh`), OpenSSL (`curl`, `git`), Node and Python accept that shape.
  */
 import { isIP } from "node:net";
+import { hostTuning } from "../tuning.js";
 import { createHash, createPrivateKey, createPublicKey, generateKeyPairSync, randomBytes, sign, X509Certificate, } from "node:crypto";
 const OID = {
     ecdsaWithSha256: "1.2.840.10045.4.3.2",
@@ -96,21 +97,28 @@ function pem(der) {
     const body = der.toString("base64").replace(/(.{64})/g, "$1\n").replace(/\n$/, "");
     return `-----BEGIN CERTIFICATE-----\n${body}\n-----END CERTIFICATE-----\n`;
 }
-/** A new P-256 CA, valid from an hour ago for `days` days. */
+/** Milliseconds in a day: a unit, not a setting. */
+const DAY_MS = 86_400_000;
+/**
+ * A new P-256 CA, valid from `keys.caBackdateMs` ago (Host tuning, an hour) for `days` days
+ * (default `keys.caLifetimeDays`).
+ */
 export function createCertificateAuthority(options) {
     const { publicKey, privateKey } = generateKeyPairSync("ec", { namedCurve: "P-256" });
     const now = options.now ?? new Date();
+    const tuning = hostTuning().keys;
     const subject = name({ commonName: options.commonName, organization: "Nylorun" });
     const ski = keyIdentifier(publicKey);
-    const tbs = seq(explicit(0, integer(Buffer.from([2]))), serial(), seq(oid(OID.ecdsaWithSha256)), subject, seq(time(new Date(now.getTime() - 3_600_000)), time(new Date(now.getTime() + (options.days ?? 3650) * 86_400_000))), subject, spki(publicKey), explicit(3, seq(extension(OID.basicConstraints, true, seq(bool(true), integer(Buffer.from([0])))), extension(OID.keyUsage, true, bits(Buffer.from([0x06]), 1)), extension(OID.subjectKeyIdentifier, false, octets(ski)))));
+    const tbs = seq(explicit(0, integer(Buffer.from([2]))), serial(), seq(oid(OID.ecdsaWithSha256)), subject, seq(time(new Date(now.getTime() - tuning.caBackdateMs)), time(new Date(now.getTime() + (options.days ?? tuning.caLifetimeDays) * DAY_MS))), subject, spki(publicKey), explicit(3, seq(extension(OID.basicConstraints, true, seq(bool(true), integer(Buffer.from([0])))), extension(OID.keyUsage, true, bits(Buffer.from([0x06]), 1)), extension(OID.subjectKeyIdentifier, false, octets(ski)))));
     return {
         certificate: pem(certificate(tbs, privateKey)),
         privateKey: privateKey.export({ type: "pkcs8", format: "pem" }).toString(),
     };
 }
 /**
- * A leaf for `host` and the caller's `publicKey` (SPKI PEM), signed by the CA, valid from five
- * minutes ago for `minutes` minutes. The caller keeps the leaf's private key: only the
+ * A leaf for `host` and the caller's `publicKey` (SPKI PEM), signed by the CA, valid from
+ * `keys.leafBackdateMs` ago (Host tuning, five minutes) for `lifetimeMs` (default
+ * `keys.leafLifetimeMs`, an hour: one connection rarely lasts this long). The caller keeps the leaf's private key: only the
  * certificate comes back, so no private key leaves whoever holds it.
  */
 export function issueLeafCertificate(options) {
@@ -122,8 +130,9 @@ export function issueLeafCertificate(options) {
     if (publicKey.asymmetricKeyType !== "ec" || publicKey.asymmetricKeyDetails?.namedCurve !== "prime256v1")
         throw new Error("A leaf key must be ECDSA P-256");
     const now = options.now ?? new Date();
+    const tuning = hostTuning().keys;
     const issuer = Buffer.from(ca.raw);
-    const tbs = seq(explicit(0, integer(Buffer.from([2]))), serial(), seq(oid(OID.ecdsaWithSha256)), subjectOf(issuer), seq(time(new Date(now.getTime() - 300_000)), time(new Date(now.getTime() + (options.minutes ?? 60) * 60_000))), name({ commonName: options.host }), spki(publicKey), explicit(3, seq(extension(OID.keyUsage, true, bits(Buffer.from([0x80]), 7)), extension(OID.extKeyUsage, false, seq(oid(OID.serverAuth))), extension(OID.subjectAltName, false, seq(tlv(0x82, Buffer.from(options.host, "ascii")))), extension(OID.authorityKeyIdentifier, false, seq(tlv(0x80, keyIdentifier(ca.publicKey)))))));
+    const tbs = seq(explicit(0, integer(Buffer.from([2]))), serial(), seq(oid(OID.ecdsaWithSha256)), subjectOf(issuer), seq(time(new Date(now.getTime() - tuning.leafBackdateMs)), time(new Date(now.getTime() + (options.lifetimeMs ?? tuning.leafLifetimeMs)))), name({ commonName: options.host }), spki(publicKey), explicit(3, seq(extension(OID.keyUsage, true, bits(Buffer.from([0x80]), 7)), extension(OID.extKeyUsage, false, seq(oid(OID.serverAuth))), extension(OID.subjectAltName, false, seq(tlv(0x82, Buffer.from(options.host, "ascii")))), extension(OID.authorityKeyIdentifier, false, seq(tlv(0x80, keyIdentifier(ca.publicKey)))))));
     return pem(certificate(tbs, caKey));
 }
 /** A P-256 key pair for a leaf, as PEM: SPKI for the public key, PKCS#8 for the private key. */