@lensmcp/cluster 1.8.0 → 1.10.0

package/executors/gateway/ssrf-guard.d.ts

@@ -0,0 +1,97 @@
+/**
+ * SSRF guard for OUTBOUND fetches of a request- or config-supplied URL.
+ *
+ * The prod gateway today never fetches an attacker-controlled URL — upstreams
+ * are pinned in the manifest, the JWKS URL is operator env, and reply-from /
+ * undici do not chase redirects. This module exists so that the MOMENT a sink
+ * IS added (a remote-MCP / OpenAPI schema import, a webhook callback, a
+ * dynamically-discovered upstream — anything that fetches a URL it did not
+ * author) there is a ready, tested guard to wrap it with, instead of a naive
+ * `if (host === '127.0.0.1')` string check that the classic bypasses defeat.
+ *
+ * It defends the three canonical bypasses:
+ *   1. DNS name that RESOLVES to an internal IP (`127.0.0.1.nip.io`, rebinding)
+ *      → we resolve the host and check the RESOLVED addresses, not the string.
+ *   2. Redirect chase (`/redirect` 3xx → loopback) → `safeFetch` re-validates
+ *      EVERY hop with `redirect:'manual'`; it never blindly follows a Location.
+ *   3. IPv4-mapped IPv6 loopback (`[::ffff:127.0.0.1]`, `[::ffff:7f00:1]`) →
+ *      `net.BlockList` normalizes mapped forms against the IPv4 rules.
+ *
+ * Residual TOCTOU: between the resolve-and-check and the socket connect, a
+ * rebinding resolver could flip the record. Close it by pinning the connection
+ * to the validated address(es) with `pinnedLookup()` (pass to
+ * `new http.Agent({ lookup })` or an undici `connect:{ lookup }` dispatcher).
+ *
+ * Defaults are operator-overridable but FAIL CLOSED: anything unparseable, any
+ * non-http(s) scheme, embedded credentials, an empty host, or a host that
+ * resolves to no records is rejected.
+ */
+import { BlockList } from 'node:net';
+import type { LookupAddress } from 'node:dns';
+/** Thrown for every blocked URL — carries a machine-readable `reason` and, when
+ *  the block was an address, the offending `address` (the resolved IP, not the
+ *  hostname, so logs show what the name actually pointed at). */
+export declare class SsrfBlockedError extends Error {
+    readonly reason: string;
+    readonly url?: string;
+    readonly address?: string;
+    constructor(reason: string, url?: string, address?: string, cause?: unknown);
+}
+/** True if `ip` (a literal address) falls in a blocked range. Mapped IPv6 is
+ *  normalized by BlockList; an unparseable string is treated as blocked. */
+export declare function isBlockedAddress(ip: string, blockList?: BlockList): boolean;
+export interface FetchableUrlOptions {
+    /** Allowed URL schemes. Default `['http:', 'https:']`. */
+    allowedProtocols?: string[];
+    /** DNS resolver (injectable for tests). Default `dns.lookup(host, {all:true})`. */
+    resolve?: (host: string) => Promise<string[]>;
+    /** Override the blocked-range set. Default = the internal/non-routable set. */
+    blockList?: BlockList;
+    /** Escape hatch: skip all internal-range checks (e.g. a trusted-loopback dev
+     *  sink). Off by default — opt in explicitly, never from request input. */
+    allowPrivate?: boolean;
+}
+export interface FetchableUrl {
+    /** The parsed, validated URL. */
+    url: URL;
+    /** The host (brackets stripped for IPv6 literals). */
+    hostname: string;
+    /** Validated addresses: the literal IP, or every resolved DNS record. Feed to
+     *  `pinnedLookup()` to pin the connection and close the rebinding TOCTOU. */
+    addresses: string[];
+}
+/**
+ * Validate that `rawUrl` is safe to fetch. Rejects (throws `SsrfBlockedError`)
+ * a malformed URL, a disallowed scheme, embedded credentials, a missing host,
+ * a literal internal IP, or a host that resolves to ANY internal address.
+ * Returns the parsed URL and the validated address set on success.
+ */
+export declare function assertFetchableUrl(rawUrl: string | URL, opts?: FetchableUrlOptions): Promise<FetchableUrl>;
+export interface SafeFetchOptions extends FetchableUrlOptions {
+    /** Max redirect hops before giving up. Default 5. */
+    maxRedirects?: number;
+    /** Injectable fetch (tests). Default global `fetch`. */
+    fetchImpl?: typeof fetch;
+}
+/**
+ * A `fetch` that validates the target — and re-validates every redirect hop —
+ * with the SSRF guard. Redirects are handled manually (`redirect:'manual'`) so
+ * a 3xx Location to an internal host is checked BEFORE it is followed, never
+ * chased blindly. Returns the final non-redirect `Response`.
+ *
+ * Note: each hop re-issues with the original `init` (method + body preserved —
+ * the security-relevant worst case for 307/308). A streamed request body cannot
+ * be replayed across hops.
+ */
+export declare function safeFetch(rawUrl: string | URL, init?: RequestInit, opts?: SafeFetchOptions): Promise<Response>;
+type LookupCallback = (err: NodeJS.ErrnoException | null, address?: string | LookupAddress[], family?: number) => void;
+/**
+ * A `dns.lookup`-compatible function that ONLY ever returns the pre-validated
+ * `addresses`. Pass it to `new http.Agent({ lookup })` or an undici
+ * `connect:{ lookup }` dispatcher so the socket connects to an address the
+ * guard already cleared — closing the DNS-rebinding TOCTOU between check and
+ * connect. Use the `addresses` from `assertFetchableUrl()`.
+ */
+export declare function pinnedLookup(addresses: readonly string[]): (hostname: string, options: unknown, callback?: LookupCallback) => void;
+export {};
+//# sourceMappingURL=ssrf-guard.d.ts.map

package/executors/gateway/ssrf-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssrf-guard.d.ts","sourceRoot":"","sources":["../../../../../libs/cluster/src/executors/gateway/ssrf-guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,EAAQ,SAAS,EAAE,MAAM,UAAU,CAAC;AAE3C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C;;iEAEiE;AACjE,qBAAa,gBAAiB,SAAQ,KAAK;IACzC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;gBACd,MAAM,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO;CAU5E;AA6BD;4EAC4E;AAC5E,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,EAAE,SAAS,GAAE,SAA8B,GAAG,OAAO,CAI/F;AAQD,MAAM,WAAW,mBAAmB;IAClC,0DAA0D;IAC1D,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B,mFAAmF;IACnF,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAC9C,+EAA+E;IAC/E,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB;+EAC2E;IAC3E,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,YAAY;IAC3B,iCAAiC;IACjC,GAAG,EAAE,GAAG,CAAC;IACT,sDAAsD;IACtD,QAAQ,EAAE,MAAM,CAAC;IACjB;iFAC6E;IAC7E,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;;;;GAKG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,MAAM,GAAG,GAAG,EACpB,IAAI,GAAE,mBAAwB,GAC7B,OAAO,CAAC,YAAY,CAAC,CAgDvB;AAED,MAAM,WAAW,gBAAiB,SAAQ,mBAAmB;IAC3D,qDAAqD;IACrD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,wDAAwD;IACxD,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;CAC1B;AAED;;;;;;;;;GASG;AACH,wBAAsB,SAAS,CAC7B,MAAM,EAAE,MAAM,GAAG,GAAG,EACpB,IAAI,GAAE,WAAgB,EACtB,IAAI,GAAE,gBAAqB,GAC1B,OAAO,CAAC,QAAQ,CAAC,CAgBnB;AAED,KAAK,cAAc,GAAG,CACpB,GAAG,EAAE,MAAM,CAAC,cAAc,GAAG,IAAI,EACjC,OAAO,CAAC,EAAE,MAAM,GAAG,aAAa,EAAE,EAClC,MAAM,CAAC,EAAE,MAAM,KACZ,IAAI,CAAC;AAEV;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,SAAS,EAAE,SAAS,MAAM,EAAE,GAC3B,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,cAAc,KAAK,IAAI,CAezE"}

package/executors/gateway/ssrf-guard.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SsrfBlockedError = void 0;
+exports.isBlockedAddress = isBlockedAddress;
+exports.assertFetchableUrl = assertFetchableUrl;
+exports.safeFetch = safeFetch;
+exports.pinnedLookup = pinnedLookup;
+/**
+ * SSRF guard for OUTBOUND fetches of a request- or config-supplied URL.
+ *
+ * The prod gateway today never fetches an attacker-controlled URL — upstreams
+ * are pinned in the manifest, the JWKS URL is operator env, and reply-from /
+ * undici do not chase redirects. This module exists so that the MOMENT a sink
+ * IS added (a remote-MCP / OpenAPI schema import, a webhook callback, a
+ * dynamically-discovered upstream — anything that fetches a URL it did not
+ * author) there is a ready, tested guard to wrap it with, instead of a naive
+ * `if (host === '127.0.0.1')` string check that the classic bypasses defeat.
+ *
+ * It defends the three canonical bypasses:
+ *   1. DNS name that RESOLVES to an internal IP (`127.0.0.1.nip.io`, rebinding)
+ *      → we resolve the host and check the RESOLVED addresses, not the string.
+ *   2. Redirect chase (`/redirect` 3xx → loopback) → `safeFetch` re-validates
+ *      EVERY hop with `redirect:'manual'`; it never blindly follows a Location.
+ *   3. IPv4-mapped IPv6 loopback (`[::ffff:127.0.0.1]`, `[::ffff:7f00:1]`) →
+ *      `net.BlockList` normalizes mapped forms against the IPv4 rules.
+ *
+ * Residual TOCTOU: between the resolve-and-check and the socket connect, a
+ * rebinding resolver could flip the record. Close it by pinning the connection
+ * to the validated address(es) with `pinnedLookup()` (pass to
+ * `new http.Agent({ lookup })` or an undici `connect:{ lookup }` dispatcher).
+ *
+ * Defaults are operator-overridable but FAIL CLOSED: anything unparseable, any
+ * non-http(s) scheme, embedded credentials, an empty host, or a host that
+ * resolves to no records is rejected.
+ */
+const node_net_1 = require("node:net");
+const promises_1 = require("node:dns/promises");
+/** Thrown for every blocked URL — carries a machine-readable `reason` and, when
+ *  the block was an address, the offending `address` (the resolved IP, not the
+ *  hostname, so logs show what the name actually pointed at). */
+class SsrfBlockedError extends Error {
+    constructor(reason, url, address, cause) {
+        super(`SSRF guard blocked ${url ?? 'request'}: ${reason}${address ? ` (${address})` : ''}`, cause !== undefined ? { cause } : undefined);
+        this.name = 'SsrfBlockedError';
+        this.reason = reason;
+        this.url = url;
+        this.address = address;
+    }
+}
+exports.SsrfBlockedError = SsrfBlockedError;
+/** The internal / non-routable ranges an outbound fetch must never reach.
+ *  Mapped IPv4-in-IPv6 (`::ffff:a.b.c.d`) is matched by the IPv4 rules — verified
+ *  in the spec — so we do NOT blanket-block `::ffff:0:0/96` (mapped *public*
+ *  IPv4 is legitimate). */
+function buildDefaultBlockList() {
+    const b = new node_net_1.BlockList();
+    // ── IPv4 ──
+    b.addSubnet('0.0.0.0', 8, 'ipv4'); // "this host" / 0.0.0.0
+    b.addSubnet('10.0.0.0', 8, 'ipv4'); // RFC1918 private
+    b.addSubnet('100.64.0.0', 10, 'ipv4'); // RFC6598 CGNAT
+    b.addSubnet('127.0.0.0', 8, 'ipv4'); // loopback
+    b.addSubnet('169.254.0.0', 16, 'ipv4'); // link-local incl. cloud metadata 169.254.169.254
+    b.addSubnet('172.16.0.0', 12, 'ipv4'); // RFC1918 private (172.16–172.31)
+    b.addSubnet('192.0.0.0', 24, 'ipv4'); // IETF protocol assignments
+    b.addSubnet('192.168.0.0', 16, 'ipv4'); // RFC1918 private
+    b.addSubnet('198.18.0.0', 15, 'ipv4'); // benchmarking
+    b.addSubnet('240.0.0.0', 4, 'ipv4'); // reserved + 255.255.255.255 broadcast
+    // ── IPv6 ──
+    b.addAddress('::', 'ipv6'); // unspecified
+    b.addAddress('::1', 'ipv6'); // loopback
+    b.addSubnet('fc00::', 7, 'ipv6'); // unique-local (ULA)
+    b.addSubnet('fe80::', 10, 'ipv6'); // link-local
+    return b;
+}
+const DEFAULT_BLOCK_LIST = buildDefaultBlockList();
+/** True if `ip` (a literal address) falls in a blocked range. Mapped IPv6 is
+ *  normalized by BlockList; an unparseable string is treated as blocked. */
+function isBlockedAddress(ip, blockList = DEFAULT_BLOCK_LIST) {
+    const fam = (0, node_net_1.isIP)(ip);
+    if (fam === 0)
+        return true; // not an IP → fail closed
+    return blockList.check(ip, fam === 6 ? 'ipv6' : 'ipv4');
+}
+const stripBrackets = (host) => host.startsWith('[') && host.endsWith(']') ? host.slice(1, -1) : host;
+const defaultResolve = async (host) => (await (0, promises_1.lookup)(host, { all: true, verbatim: true })).map((r) => r.address);
+/**
+ * Validate that `rawUrl` is safe to fetch. Rejects (throws `SsrfBlockedError`)
+ * a malformed URL, a disallowed scheme, embedded credentials, a missing host,
+ * a literal internal IP, or a host that resolves to ANY internal address.
+ * Returns the parsed URL and the validated address set on success.
+ */
+async function assertFetchableUrl(rawUrl, opts = {}) {
+    const protocols = opts.allowedProtocols ?? ['http:', 'https:'];
+    let url;
+    try {
+        url = new URL(rawUrl);
+    }
+    catch {
+        throw new SsrfBlockedError('malformed-url', String(rawUrl));
+    }
+    if (!protocols.includes(url.protocol)) {
+        throw new SsrfBlockedError(`scheme-not-allowed:${url.protocol}`, url.href);
+    }
+    if (url.username !== '' || url.password !== '') {
+        throw new SsrfBlockedError('embedded-credentials', url.href);
+    }
+    const hostname = stripBrackets(url.hostname);
+    if (hostname === '')
+        throw new SsrfBlockedError('missing-host', url.href);
+    if (opts.allowPrivate) {
+        return { url, hostname, addresses: (0, node_net_1.isIP)(hostname) ? [hostname] : [] };
+    }
+    const blockList = opts.blockList ?? DEFAULT_BLOCK_LIST;
+    // Literal IP (covers IPv4, IPv6, and IPv4-mapped IPv6 like [::ffff:127.0.0.1]).
+    if ((0, node_net_1.isIP)(hostname) !== 0) {
+        if (isBlockedAddress(hostname, blockList)) {
+            throw new SsrfBlockedError('blocked-address', url.href, hostname);
+        }
+        return { url, hostname, addresses: [hostname] };
+    }
+    // DNS name → resolve and check EVERY record (defeats nip.io / rebinding).
+    const resolve = opts.resolve ?? defaultResolve;
+    let addresses;
+    try {
+        addresses = await resolve(hostname);
+    }
+    catch (e) {
+        throw new SsrfBlockedError('dns-resolution-failed', url.href, undefined, e);
+    }
+    if (addresses.length === 0)
+        throw new SsrfBlockedError('dns-no-records', url.href);
+    for (const addr of addresses) {
+        if (isBlockedAddress(addr, blockList)) {
+            throw new SsrfBlockedError('blocked-resolved-address', url.href, addr);
+        }
+    }
+    return { url, hostname, addresses };
+}
+/**
+ * A `fetch` that validates the target — and re-validates every redirect hop —
+ * with the SSRF guard. Redirects are handled manually (`redirect:'manual'`) so
+ * a 3xx Location to an internal host is checked BEFORE it is followed, never
+ * chased blindly. Returns the final non-redirect `Response`.
+ *
+ * Note: each hop re-issues with the original `init` (method + body preserved —
+ * the security-relevant worst case for 307/308). A streamed request body cannot
+ * be replayed across hops.
+ */
+async function safeFetch(rawUrl, init = {}, opts = {}) {
+    const doFetch = opts.fetchImpl ?? globalThis.fetch;
+    const maxRedirects = opts.maxRedirects ?? 5;
+    let current = rawUrl;
+    for (let hop = 0;; hop++) {
+        const { url } = await assertFetchableUrl(current, opts); // re-validate THIS hop
+        const res = await doFetch(url, { ...init, redirect: 'manual' });
+        const location = res.headers.get('location');
+        if (res.status >= 300 && res.status < 400 && location) {
+            if (hop >= maxRedirects)
+                throw new SsrfBlockedError('too-many-redirects', url.href);
+            current = new URL(location, url).href; // resolve relative; loop re-validates next hop
+            continue;
+        }
+        return res;
+    }
+}
+/**
+ * A `dns.lookup`-compatible function that ONLY ever returns the pre-validated
+ * `addresses`. Pass it to `new http.Agent({ lookup })` or an undici
+ * `connect:{ lookup }` dispatcher so the socket connects to an address the
+ * guard already cleared — closing the DNS-rebinding TOCTOU between check and
+ * connect. Use the `addresses` from `assertFetchableUrl()`.
+ */
+function pinnedLookup(addresses) {
+    const recs = addresses.map((address) => ({
+        address,
+        family: (0, node_net_1.isIP)(address) === 6 ? 6 : 4,
+    }));
+    return (hostname, options, callback) => {
+        const cb = (typeof options === 'function' ? options : callback);
+        const all = typeof options === 'object' && options !== null && options.all === true;
+        if (recs.length === 0) {
+            cb(new Error(`SSRF guard: no pinned address for ${hostname}`));
+            return;
+        }
+        if (all)
+            cb(null, recs);
+        else
+            cb(null, recs[0].address, recs[0].family);
+    };
+}

package/gateway.d.ts

@@ -0,0 +1,21 @@
+/**
+ * `@lensmcp/cluster/gateway` — the PRODUCTION gateway's public, extendable surface.
+ *
+ * This is the **deployable edge** (`startProdGateway` — Fastify + undici reverse
+ * proxy, manifest-driven, the thing `Dockerfile.prod-gateway` runs). A consumer
+ * (e.g. tetros' `server/apps/gateway`) imports from here to run or extend it with
+ * its own providers/middleware and ship a specialized image.
+ *
+ * ⚠️ This is NOT the DEV cluster gateway. The dev gateway is the
+ * `@lensmcp/cluster:gateway` nx EXECUTOR (`gateway.lib.ts` → `startGateway`) — a
+ * local-only HTTPS front door on :443 that fronts unix-socket pods for
+ * development. The two share a routing core (`manifest.ts`) but are separate
+ * lifecycles: dev = an nx target you run locally; prod = a containerized service
+ * you deploy. Kept on a separate subpath so the build-time webpack-config exports
+ * in the main `@lensmcp/cluster` entry never pull in fastify/undici.
+ */
+export { startProdGateway, type ProdGatewayOptions, type ProdGatewayHandle, type ServiceStatus, } from './executors/gateway/prod-gateway.lib';
+export { staticManifestProvider, endpointsPodProvider } from './executors/gateway/providers-prod';
+export { createRegistryProviders, redisRegistrySource, type RegistrySource, type RedisLike, DEFAULT_REGISTRY_PREFIX, } from './executors/gateway/registry-source';
+export { type RouteManifest, type RouteMount, type AuthMode, type AuthPolicy, type ManifestProvider, type PodProvider, type Upstream, type Route, manifestFromClusterDecl, } from './executors/gateway/manifest';
+//# sourceMappingURL=gateway.d.ts.map

package/gateway.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateway.d.ts","sourceRoot":"","sources":["../../../libs/cluster/src/gateway.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EACL,gBAAgB,EAChB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,aAAa,GACnB,MAAM,sCAAsC,CAAC;AAG9C,OAAO,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAGlG,OAAO,EACL,uBAAuB,EACvB,mBAAmB,EACnB,KAAK,cAAc,EACnB,KAAK,SAAS,EACd,uBAAuB,GACxB,MAAM,qCAAqC,CAAC;AAI7C,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,UAAU,EACf,KAAK,QAAQ,EACb,KAAK,UAAU,EACf,KAAK,gBAAgB,EACrB,KAAK,WAAW,EAChB,KAAK,QAAQ,EACb,KAAK,KAAK,EACV,uBAAuB,GACxB,MAAM,8BAA8B,CAAC"}

package/gateway.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * `@lensmcp/cluster/gateway` — the PRODUCTION gateway's public, extendable surface.
+ *
+ * This is the **deployable edge** (`startProdGateway` — Fastify + undici reverse
+ * proxy, manifest-driven, the thing `Dockerfile.prod-gateway` runs). A consumer
+ * (e.g. tetros' `server/apps/gateway`) imports from here to run or extend it with
+ * its own providers/middleware and ship a specialized image.
+ *
+ * ⚠️ This is NOT the DEV cluster gateway. The dev gateway is the
+ * `@lensmcp/cluster:gateway` nx EXECUTOR (`gateway.lib.ts` → `startGateway`) — a
+ * local-only HTTPS front door on :443 that fronts unix-socket pods for
+ * development. The two share a routing core (`manifest.ts`) but are separate
+ * lifecycles: dev = an nx target you run locally; prod = a containerized service
+ * you deploy. Kept on a separate subpath so the build-time webpack-config exports
+ * in the main `@lensmcp/cluster` entry never pull in fastify/undici.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manifestFromClusterDecl = exports.DEFAULT_REGISTRY_PREFIX = exports.redisRegistrySource = exports.createRegistryProviders = exports.endpointsPodProvider = exports.staticManifestProvider = exports.startProdGateway = void 0;
+// The prod gateway engine + its option/handle contract.
+var prod_gateway_lib_1 = require("./executors/gateway/prod-gateway.lib");
+Object.defineProperty(exports, "startProdGateway", { enumerable: true, get: function () { return prod_gateway_lib_1.startProdGateway; } });
+// Static (in-memory) providers — build a gateway from explicit manifests/endpoints.
+var providers_prod_1 = require("./executors/gateway/providers-prod");
+Object.defineProperty(exports, "staticManifestProvider", { enumerable: true, get: function () { return providers_prod_1.staticManifestProvider; } });
+Object.defineProperty(exports, "endpointsPodProvider", { enumerable: true, get: function () { return providers_prod_1.endpointsPodProvider; } });
+// Redis-backed registry providers — the prod path (manifests/rollout read live from Redis).
+var registry_source_1 = require("./executors/gateway/registry-source");
+Object.defineProperty(exports, "createRegistryProviders", { enumerable: true, get: function () { return registry_source_1.createRegistryProviders; } });
+Object.defineProperty(exports, "redisRegistrySource", { enumerable: true, get: function () { return registry_source_1.redisRegistrySource; } });
+Object.defineProperty(exports, "DEFAULT_REGISTRY_PREFIX", { enumerable: true, get: function () { return registry_source_1.DEFAULT_REGISTRY_PREFIX; } });
+// Manifest/route types + the cluster-decl → manifest converter (derive prod
+// manifests from the SAME project.json `cluster` declarations dev uses).
+var manifest_1 = require("./executors/gateway/manifest");
+Object.defineProperty(exports, "manifestFromClusterDecl", { enumerable: true, get: function () { return manifest_1.manifestFromClusterDecl; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lensmcp/cluster",
-  "version": "1.8.0",
+  "version": "1.10.0",
   "description": "Run your Nx workspace as a local production cluster: pods on unix sockets with true HMR, one https gateway with per-project domains, scale-from-zero, autoscale, idle-kill, local-CA TLS — observed by the LensMCP lens.",
   "main": "./index.js",
   "types": "./index.d.ts",
@@ -65,8 +65,8 @@
     }
   },
   "dependencies": {
-    "@lensmcp/node-instrumentation": "1.8.0",
-    "@lensmcp/nx-plugin": "1.8.0",
+    "@lensmcp/node-instrumentation": "1.10.0",
+    "@lensmcp/nx-plugin": "1.10.0",
     "fork-ts-checker-webpack-plugin": "^9.0.0",
     "glob": "^11.0.0",
     "http-proxy": "^1.18.0",