@camstack/server 1.1.0 → 1.1.1

package/dist/api/addon-upload.js

@@ -54,7 +54,13 @@ function getDeployStageRegistry() {
  * the agent in the `$agent.deploy` `hub-http` source descriptor.
  */
 function registerDeployBundleRoute(fastify) {
-    fastify.get('/api/addons/deploy-bundle/:id', (request, reply) => {
+    // `compress: false` — never gzip/brotli this route. The body is a large
+    // binary tarball (addon bundle / model artifact) the agent pulls with undici
+    // + sha256 verification. With global @fastify/compress on, the 1–2MB response
+    // was Brotli-encoded and undici's BrotliDecompress aborted the stream
+    // ("TypeError: terminated"), silently breaking EVERY agent-pull (addon-deploy
+    // AND model distribution). Identity bytes also keep the byte-length check valid.
+    fastify.get('/api/addons/deploy-bundle/:id', { compress: false }, (request, reply) => {
         const auth = request.headers.authorization ?? '';
         const token = auth.startsWith('Bearer ') ? auth.slice('Bearer '.length) : '';
         if (!token) {

package/dist/api/model-distributor.js

@@ -0,0 +1,128 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tarModelFiles = tarModelFiles;
+exports.distributeModelWith = distributeModelWith;
+exports.buildModelDistributorProvider = buildModelDistributorProvider;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const system_1 = require("@camstack/system");
+const addon_upload_js_1 = require("./addon-upload.js");
+const AGENT_DISTRIBUTE_TIMEOUT_MS = 60_000;
+function hubModelsDir() {
+    return path.join(process.env['CAMSTACK_DATA'] ?? 'camstack-data', 'models');
+}
+function hubBundleBaseUrl() {
+    return process.env['CAMSTACK_HUB_PUBLIC_URL'] ?? 'https://127.0.0.1:4443';
+}
+/**
+ * `tar -czf -` the given files relative to `cwd`, buffering the gzip stream.
+ * Async (spawn, not execFileSync) so a large model doesn't block the event
+ * loop. The agent untars this exact buffer into its own modelsDir.
+ */
+function tarModelFiles(cwd, files) {
+    return new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)('tar', ['-czf', '-', '-C', cwd, ...files]);
+        const chunks = [];
+        const errChunks = [];
+        child.stdout.on('data', (c) => chunks.push(c));
+        child.stderr.on('data', (c) => errChunks.push(c));
+        child.on('error', reject);
+        child.on('close', (code) => {
+            if (code === 0)
+                resolve(Buffer.concat(chunks));
+            else
+                reject(new Error(`tar exited ${code}: ${Buffer.concat(errChunks).toString().slice(0, 300)}`));
+        });
+    });
+}
+/**
+ * Core distribution logic (pure orchestration over the seam):
+ * precondition-check → collect → tar → stage → trigger the agent pull.
+ * `nodeId === 'hub'` is a no-op (the artifact is already resident).
+ */
+async function distributeModelWith(seam, input) {
+    const { nodeId, modelId, format, entry } = input;
+    if (nodeId === 'hub') {
+        return { ok: true, sha256: '', bytes: 0, path: seam.modelsDir };
+    }
+    if (!seam.isPresent(entry, format)) {
+        throw new Error(`model ${modelId}/${format} not present on hub — download or convert it first`);
+    }
+    const files = (0, system_1.collectModelFiles)(entry, format).filter((f) => seam.fileExists(f));
+    if (files.length === 0) {
+        throw new Error(`model ${modelId}/${format} resolved no files to distribute`);
+    }
+    const tgz = await seam.tar(files);
+    const source = seam.stage(tgz);
+    const res = await seam.callAgent(nodeId, { modelId, format, source });
+    return { ok: true, sha256: source.sha256, bytes: source.bytes, path: res.path ?? '' };
+}
+/**
+ * Build the hub-resident `model-distributor` singleton provider. Mounted as a
+ * service-backed cap override in `trpc.router.ts` because it needs the
+ * Moleculer broker + the deploy-stage registry, which a forked addon can't
+ * reach.
+ */
+function buildModelDistributorProvider(moleculer, loggingService) {
+    const logger = loggingService.createLogger('model-distributor');
+    const modelsDir = hubModelsDir();
+    const seam = {
+        modelsDir,
+        isPresent: (entry, format) => (0, system_1.isModelDownloaded)(modelsDir, entry, format),
+        fileExists: (rel) => fs.existsSync(path.join(modelsDir, rel)),
+        tar: (files) => tarModelFiles(modelsDir, files),
+        stage: (buffer) => (0, addon_upload_js_1.buildHubHttpSource)(buffer, hubBundleBaseUrl()),
+        callAgent: async (nodeId, payload) => {
+            const broker = moleculer?.broker;
+            if (!broker)
+                throw new Error('model-distributor: Moleculer broker unavailable');
+            const raw = await broker.call('$agent.distributeModel', payload, {
+                nodeID: nodeId,
+                timeout: AGENT_DISTRIBUTE_TIMEOUT_MS,
+            });
+            return (raw ?? {});
+        },
+    };
+    return {
+        distributeModel: async (input) => {
+            logger.info('Distributing model to node', {
+                meta: { modelId: input.modelId, format: input.format, nodeId: input.nodeId },
+            });
+            return distributeModelWith(seam, input);
+        },
+    };
+}

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: 127    Skipped (legacy): 6
+// Mounted: 130    Skipped (legacy): 6
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LEGACY_SHAPE_SKIP = void 0;
 exports.mountAllCaps = mountAllCaps;
@@ -121,6 +121,22 @@ function mountAllCaps(services) {
         contact: (0, generated_cap_routers_js_1.createCapRouter_contact)((_ctx) => (0, cap_mount_helpers_js_1.requireDeviceScoped)(reg, 'contact'), remoteCapProxy),
         control: (0, generated_cap_routers_js_1.createCapRouter_control)((_ctx) => (0, cap_mount_helpers_js_1.requireDeviceScoped)(reg, 'control'), remoteCapProxy),
         cover: (0, generated_cap_routers_js_1.createCapRouter_cover)((_ctx) => (0, cap_mount_helpers_js_1.requireDeviceScoped)(reg, 'cover'), remoteCapProxy),
+        customModelRegistry: (0, generated_cap_routers_js_1.createCapRouter_customModelRegistry)((_ctx, addonId) => {
+            if (!reg)
+                return null;
+            if (addonId !== undefined) {
+                return reg.getProviderByAddonId('custom-model-registry', addonId);
+            }
+            const entries = reg.getCollectionEntries('custom-model-registry');
+            if (entries.length === 0)
+                return null;
+            const providers = entries.map(([, p]) => p);
+            const first = providers[0];
+            return {
+                ...first,
+                listModels: (0, cap_mount_helpers_js_1.concatCollection)(providers, 'listModels'),
+            };
+        }, remoteCapProxy),
         decoder: (0, generated_cap_routers_js_1.createCapRouter_decoder)((_ctx) => reg?.getSingleton('decoder') ?? null, remoteCapProxy),
         detectionPipeline: (0, generated_cap_routers_js_1.createCapRouter_detectionPipeline)((_ctx) => reg?.getSingleton('detection-pipeline') ?? null, remoteCapProxy),
         deviceAdoption: (0, generated_cap_routers_js_1.createCapRouter_deviceAdoption)((_ctx) => reg?.getSingleton('device-adoption') ??
@@ -204,6 +220,9 @@ function mountAllCaps(services) {
         }, remoteCapProxy),
         metricsProvider: (0, generated_cap_routers_js_1.createCapRouter_metricsProvider)((_ctx) => reg?.getSingleton('metrics-provider') ??
             null, remoteCapProxy),
+        modelConvert: (0, generated_cap_routers_js_1.createCapRouter_modelConvert)((_ctx) => reg?.getSingleton('model-convert') ?? null, remoteCapProxy),
+        modelDistributor: (0, generated_cap_routers_js_1.createCapRouter_modelDistributor)((_ctx) => reg?.getSingleton('model-distributor') ??
+            null, remoteCapProxy),
         motion: (0, generated_cap_routers_js_1.createCapRouter_motion)((_ctx) => reg?.getSingleton('motion') ?? null, remoteCapProxy),
         motionDetection: (0, generated_cap_routers_js_1.createCapRouter_motionDetection)((_ctx) => reg?.getSingleton('motion-detection') ??
             null, remoteCapProxy),