@camstack/server 1.2.486 → 1.2.488

package/dist/api/health/adaptive-probe.routes.js

@@ -53,7 +53,7 @@ function registerAdaptiveProbeRoute(fastify, deps) {
         }, deps.verifyToken);
         if (!authorized)
             return reply.status(401).send({ ok: false, error: 'unauthorized' });
-        const key = (0, auth_rate_limit_js_1.clientKeyFromRequest)(req);
+        const key = (0, auth_rate_limit_js_1.clientKeyFromRequest)(req, deps.network);
         if (key !== null) {
             const verdict = deps.limiter.check(`adaptive-probe:${key}`);
             if (!verdict.allowed) {

package/dist/api/mesh/enroll.routes.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerMeshEnrollRoute = registerMeshEnrollRoute;
+const system_1 = require("@camstack/system");
+function registerMeshEnrollRoute(fastify) {
+    fastify.post('/api/mesh/enroll', async (request, reply) => {
+        const caState = (0, system_1.getProcessMeshCaState)();
+        if (caState.state !== 'ready') {
+            return reply.status(503).send({
+                ok: false,
+                error: `mesh CA unavailable: ${caState.reason}`,
+            });
+        }
+        const body = request.body ?? {};
+        const result = await (0, system_1.enrollMeshNode)({ token: body.token ?? '', csr: body.csr ?? '' }, { ca: caState.ca });
+        if (!result.ok) {
+            return reply.status(result.status).send({ ok: false, error: result.error });
+        }
+        return reply.send({
+            ok: true,
+            cert: result.cert,
+            caCert: result.caCert,
+            nodeId: result.nodeId,
+            notAfter: result.notAfter,
+            serialNumber: result.serialNumber,
+        });
+    });
+}

package/dist/api/trpc/core-cap-bridge.js

@@ -18,10 +18,15 @@
  * routes the call exactly like any addon-provided cap.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.REMOTE_PRIVILEGE_LOG_ONLY = exports.CORE_CAP_REMOTE_FORBIDDEN_TYPE = exports.REMOTE_DENIED_NAMESPACES = void 0;
+exports.setRemotePrivilegeLogSink = setRemotePrivilegeLogSink;
+exports.__resetRemotePrivilegeObservationForTests = __resetRemotePrivilegeObservationForTests;
+exports.observeRemotePrivilege = observeRemotePrivilege;
 exports.isCoreServiceCapName = isCoreServiceCapName;
 exports.describeMeshOrigin = describeMeshOrigin;
 exports.buildCoreCapService = buildCoreCapService;
 const system_1 = require("@camstack/system");
+const moleculer_1 = require("moleculer");
 const http_request_census_singleton_js_1 = require("./http-request-census.singleton.js");
 const server_provided_caps_js_1 = require("./server-provided-caps.js");
 const trpc_context_js_1 = require("./trpc.context.js");
@@ -37,6 +42,10 @@ const trpc_middleware_js_1 = require("./trpc.middleware.js");
  *  - `auth` — issuing service / scoped tokens over the trusted mesh
  *    would let any forked addon mint admin credentials. Addons must
  *    not perform authentication operations; this stays hub-local.
+ *  - `repl` — `repl.execute` runs code in the hub process (`vm` is no
+ *    boundary). The admin UI's REPL reaches it over HTTP tRPC as an admin
+ *    session; nothing calls it over the mesh, and a mesh caller must never
+ *    be able to (D802, security plan §1).
  *  - `live`, `systemEvents` — listed in `NEVER_BRIDGED_CAPS`
  *    (`trpc-links.ts`). They are hub-only push streams, not
  *    request/reply, and the worker side fast-fails on them by design.
@@ -51,9 +60,57 @@ const CORE_NAMESPACES = new Set([
     'hwaccel',
     'streamProbe',
     'eventBusProxy',
-    'repl',
     'addonSettingsRaw',
 ]);
+/**
+ * Bridged namespaces another NODE may not call (D802) — only the hub's own
+ * runners may. `logs` reads the hub's whole log store, `addonSettingsRaw` every
+ * addon's raw config (tokens included). No addon calls either over the mesh
+ * (they read their own settings through the settings door), so refusing them
+ * to an agent costs nothing and takes them off the LAN.
+ */
+exports.REMOTE_DENIED_NAMESPACES = new Set([
+    'logs',
+    'addonSettingsRaw',
+]);
+/** Moleculer error `type` of a bridged call another node may not make. */
+exports.CORE_CAP_REMOTE_FORBIDDEN_TYPE = 'CORE_CAP_REMOTE_FORBIDDEN';
+/**
+ * When true, a remote node's allowed bridged calls are logged once per
+ * `(nodeId, path)` per process — still admin, not refused. Granting least
+ * privilege waits on census; this is the log-only week before that.
+ */
+exports.REMOTE_PRIVILEGE_LOG_ONLY = true;
+let remotePrivilegeLogSink = null;
+/** Attach the warn sink used by {@link observeRemotePrivilege}. */
+function setRemotePrivilegeLogSink(sink) {
+    remotePrivilegeLogSink = sink;
+}
+const remotePrivilegeObserved = new Set();
+/** Clears dedupe state and the sink — tests only. */
+function __resetRemotePrivilegeObservationForTests() {
+    remotePrivilegeObserved.clear();
+    remotePrivilegeLogSink = null;
+}
+function remotePrivilegeKey(nodeId, path) {
+    return `${nodeId}\0${path}`;
+}
+/**
+ * One warn per `(nodeId, path)` while {@link REMOTE_PRIVILEGE_LOG_ONLY} is on.
+ * Call only after {@link REMOTE_DENIED_NAMESPACES} has passed.
+ */
+function observeRemotePrivilege(nodeId, path) {
+    if (!exports.REMOTE_PRIVILEGE_LOG_ONLY)
+        return;
+    const key = remotePrivilegeKey(nodeId, path);
+    if (remotePrivilegeObserved.has(key))
+        return;
+    remotePrivilegeObserved.add(key);
+    const message = `mesh privilege: node:${nodeId} called ${path} (log-only; still allowed)`;
+    remotePrivilegeLogSink?.warn(message, {
+        meta: { nodeId, path, principal: `node:${nodeId}` },
+    });
+}
 /**
  * camelCase → kebab-case. Mirrors `toKebab` in `trpc-links.ts` so the
  * action name matches what `brokerTransportLink` derives from `op.path`.
@@ -164,9 +221,21 @@ function resolveInvoker(caller, path) {
  * appRouter. Query + mutation procedures in {@link CORE_NAMESPACES} are
  * exposed; subscriptions are skipped (the broker transport is
  * request/reply only).
+ *
+ * Each call runs under a principal naming its origin (D802): `mesh` for the
+ * hub's own runners, `node:<nodeId>` for another node.
  */
-function buildCoreCapService(appRouter, census = (0, http_request_census_singleton_js_1.getHttpRequestCensus)()) {
-    const meshCaller = (0, trpc_middleware_js_1.createCallerFactory)(appRouter)((0, trpc_context_js_1.createMeshTrpcContext)());
+function buildCoreCapService(appRouter, census = (0, http_request_census_singleton_js_1.getHttpRequestCensus)(), options = {}) {
+    const callerFactory = (0, trpc_middleware_js_1.createCallerFactory)(appRouter);
+    const callers = new Map();
+    const callerFor = (principal) => {
+        let caller = callers.get(principal);
+        if (caller === undefined) {
+            caller = callerFactory((0, trpc_context_js_1.createMeshTrpcContext)(principal));
+            callers.set(principal, caller);
+        }
+        return caller;
+    };
     const discovered = [];
     collectProcedures(appRouter._def.procedures, '', discovered);
     const actions = [];
@@ -179,17 +248,31 @@ function buildCoreCapService(appRouter, census = (0, http_request_census_singlet
             continue;
         if (type === 'subscription')
             continue;
-        const invoke = resolveInvoker(meshCaller, path);
-        if (invoke === null)
+        if (resolveInvoker(callerFor('mesh'), path) === null)
             continue;
         const method = path.slice(dot + 1);
         actions.push({
             actionName: `${toKebab(namespace)}.${method}`,
             invoke: (input, origin) => {
                 countMeshCall(census, path, origin);
+                const remoteNode = remoteOrigin(origin, options.ownNodeId);
+                if (remoteNode !== null && exports.REMOTE_DENIED_NAMESPACES.has(namespace)) {
+                    throw new moleculer_1.Errors.MoleculerClientError(`"${path}" is not callable from another node (caller "${remoteNode}")`, 403, exports.CORE_CAP_REMOTE_FORBIDDEN_TYPE);
+                }
+                if (remoteNode !== null)
+                    observeRemotePrivilege(remoteNode, path);
+                const invoke = resolveInvoker(callerFor(remoteNode === null ? 'mesh' : `node:${remoteNode}`), path);
+                if (invoke === null)
+                    throw new Error(`$core-caps: "${path}" is not invocable`);
                 return invoke(input);
             },
         });
     }
     return (0, system_1.createCoreCapService)({ actions });
 }
+/** The calling node when it is not the hub itself; `null` for the hub's own calls. */
+function remoteOrigin(origin, ownNodeId) {
+    if (ownNodeId === undefined || origin.nodeId === null)
+        return null;
+    return origin.nodeId === ownNodeId ? null : origin.nodeId;
+}

package/dist/api/trpc/generated-cap-mounts.js

@@ -2,7 +2,7 @@
 // AUTO-GENERATED by scripts/generate-cap-mounts.ts — DO NOT EDIT
 // Re-run: npx tsx scripts/generate-cap-mounts.ts
 //
-// Mounted: 164    Skipped (legacy): 3
+// Mounted: 166    Skipped (legacy): 3
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LEGACY_SHAPE_SKIP = void 0;
 exports.mountAllCaps = mountAllCaps;
@@ -530,6 +530,24 @@ function mountAllCaps(services) {
         terminalSession: (0, generated_cap_routers_js_1.createCapRouter_terminalSession)((_ctx) => reg?.getSingleton('terminal-session') ??
             null, remoteCapProxy),
         toast: (0, generated_cap_routers_js_1.createCapRouter_toast)((_ctx) => reg?.getSingleton('toast') ?? null, remoteCapProxy),
+        training: (0, generated_cap_routers_js_1.createCapRouter_training)((_ctx) => reg?.getSingleton('training') ?? null, remoteCapProxy),
+        trainingProvider: (0, generated_cap_routers_js_1.createCapRouter_trainingProvider)((_ctx, addonId) => {
+            if (!reg)
+                return null;
+            if (addonId !== undefined) {
+                return reg.getProviderByAddonId('training-provider', addonId);
+            }
+            const entries = reg.getCollectionEntries('training-provider');
+            if (entries.length === 0)
+                return null;
+            const providers = entries.map(([, p]) => p);
+            const first = providers[0];
+            return {
+                ...first,
+                describe: (0, cap_mount_helpers_js_1.concatCollection)(providers, 'describe'),
+                listJobs: (0, cap_mount_helpers_js_1.concatCollection)(providers, 'listJobs'),
+            };
+        }, remoteCapProxy),
         turnProvider: (0, generated_cap_routers_js_1.createCapRouter_turnProvider)((_ctx, addonId) => {
             if (!reg)
                 return null;