@camstack/server 1.0.8 → 1.1.1

package/dist/api/addon-upload.js

@@ -33,6 +33,9 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDeployStageRegistry = getDeployStageRegistry;
+exports.registerDeployBundleRoute = registerDeployBundleRoute;
+exports.buildHubHttpSource = buildHubHttpSource;
 exports.registerAddonUploadRoute = registerAddonUploadRoute;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
@@ -40,6 +43,40 @@ const os = __importStar(require("node:os"));
 const node_child_process_1 = require("node:child_process");
 const scope_access_js_1 = require("./trpc/scope-access.js");
 const addon_package_service_js_1 = require("../core/addon/addon-package.service.js");
+const deploy_stage_registry_js_1 = require("./deploy-stage-registry.js");
+const deployStageRegistry = new deploy_stage_registry_js_1.DeployStageRegistry();
+function getDeployStageRegistry() {
+    return deployStageRegistry;
+}
+/**
+ * One-time-token route agents pull a staged addon tgz from. Bearer token is
+ * the per-deploy token minted in `DeployStageRegistry.stage()` and carried to
+ * the agent in the `$agent.deploy` `hub-http` source descriptor.
+ */
+function registerDeployBundleRoute(fastify) {
+    // `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) {
+            reply.status(401).send({ error: 'missing bearer token' });
+            return;
+        }
+        const buffer = deployStageRegistry.consume(request.params.id, token);
+        if (!buffer) {
+            reply
+                .status(deployStageRegistry.peekExists(request.params.id) ? 401 : 404)
+                .send({ error: 'bundle not available' });
+            return;
+        }
+        reply.header('content-type', 'application/octet-stream').send(buffer);
+    });
+}
 /**
  * Validate a `cst_*` scoped token via the `user-management` cap singleton.
  *
@@ -76,6 +113,20 @@ function isUploadAllowed(scoped) {
 const TARBALL_EXTENSIONS = ['.tgz', '.tar.gz'];
 const MAX_UPLOAD_BYTES = 50 * 1024 * 1024;
 const AGENT_DEPLOY_TIMEOUT_MS = 60_000;
+const AGENT_DEPLOY_CONTROL_TIMEOUT_MS = 30_000;
+function hubBundleBaseUrl() {
+    return process.env['CAMSTACK_HUB_PUBLIC_URL'] ?? 'https://127.0.0.1:4443';
+}
+function buildHubHttpSource(buffer, hubBaseUrl) {
+    const staged = getDeployStageRegistry().stage(buffer);
+    return {
+        kind: 'hub-http',
+        url: `${hubBaseUrl.replace(/\/$/, '')}/api/addons/deploy-bundle/${staged.id}`,
+        token: staged.token,
+        sha256: staged.sha256,
+        bytes: staged.bytes,
+    };
+}
 function isTarball(filename) {
     return TARBALL_EXTENSIONS.some((ext) => filename.endsWith(ext));
 }
@@ -119,6 +170,7 @@ async function registerAddonUploadRoute(fastify, addonBridge, authService, molec
     await fastify.register(Promise.resolve().then(() => __importStar(require('@fastify/multipart'))), {
         limits: { fileSize: MAX_UPLOAD_BYTES },
     });
+    registerDeployBundleRoute(fastify);
     fastify.post('/api/addons/upload', async (request, reply) => {
         const authHeader = request.headers.authorization;
         if (!authHeader) {
@@ -206,11 +258,12 @@ async function registerAddonUploadRoute(fastify, addonBridge, authService, molec
         // the hub AND broadcasts to every connected agent that can run any of
         // the package's addons (i.e. anything not marked hub-only). Any other
         // explicit `nodeId` value routes only to that agent via `$agent.deploy`.
+        const baseUrl = hubBundleBaseUrl();
         if (!nodeId || nodeId === 'hub') {
-            return installToHub(reply, addonBridge, addonRegistry, addonPackageService, moleculer, logger, data.filename, buffer);
+            return installToHub(reply, addonBridge, addonRegistry, addonPackageService, moleculer, logger, data.filename, buffer, baseUrl);
         }
         const agentAddonId = addonIdHint ?? manifest.name;
-        return deployToAgent(reply, moleculer, nodeId, agentAddonId, buffer);
+        return deployToAgent(reply, moleculer, nodeId, agentAddonId, buffer, baseUrl);
     });
 }
 /**
@@ -248,7 +301,7 @@ function packageHasAgentDeployable(addonsDir, packageName) {
  * without an agent restart. Agents that fail are reported per-node — one
  * unreachable agent must not block the others or the hub install.
  */
-async function propagateToAgents(moleculer, logger, packageName, buffer) {
+async function propagateToAgents(moleculer, logger, packageName, buffer, hubBaseUrl) {
     const broker = moleculer.broker;
     const nodes = broker.registry?.getNodeList?.({ onlyAvailable: true }) ?? [];
     // Moleculer reports both top-level nodes (`hub`, `dev-agent-0`, …) AND
@@ -270,7 +323,13 @@ async function propagateToAgents(moleculer, logger, packageName, buffer) {
     const results = [];
     for (const nodeId of agentNodeIds) {
         try {
-            const deployRaw = await broker.call('$agent.deploy', { addonId: packageName, bundle: buffer }, { nodeID: nodeId, timeout: AGENT_DEPLOY_TIMEOUT_MS });
+            // The hub currently only ever sends the `hub-http` source (agent streams
+            // the tgz directly from this hub). The `{kind:'npm'}` source is a reserved
+            // follow-up (published-addon optimization) and is intentionally not produced
+            // yet. Wiring it later must also make the agent's npm path evict the addon's
+            // declaration ids before `$agent.reload`, otherwise an npm update pins the
+            // stale version.
+            const deployRaw = await broker.call('$agent.deploy', { addonId: packageName, source: buildHubHttpSource(buffer, hubBaseUrl) }, { nodeID: nodeId, timeout: AGENT_DEPLOY_CONTROL_TIMEOUT_MS });
             if (!isAgentDeployResponse(deployRaw)) {
                 results.push({ nodeId, success: false, error: 'malformed deploy response' });
                 continue;
@@ -302,7 +361,7 @@ async function propagateToAgents(moleculer, logger, packageName, buffer) {
  * Without this the CLI push was write-to-disk-only and required a server
  * restart to actually run the new code.
  */
-async function installToHub(reply, addonBridge, addonRegistry, addonPackageService, moleculer, logger, filename, buffer) {
+async function installToHub(reply, addonBridge, addonRegistry, addonPackageService, moleculer, logger, filename, buffer, hubBaseUrl) {
     const tmpDir = path.join(os.tmpdir(), `camstack-addon-upload-${Date.now()}`);
     fs.mkdirSync(tmpDir, { recursive: true });
     const tgzPath = path.join(tmpDir, filename);
@@ -401,7 +460,7 @@ async function installToHub(reply, addonBridge, addonRegistry, addonPackageServi
             });
         }
         if (propagatable) {
-            void propagateToAgents(moleculer, logger, result.name, buffer).then((agentResults) => {
+            void propagateToAgents(moleculer, logger, result.name, buffer, hubBaseUrl).then((agentResults) => {
                 logger.info('propagation done', {
                     meta: { packageName: result.name, agents: agentResults },
                 });
@@ -434,10 +493,16 @@ function isAgentDeployResponse(value) {
         return false;
     return true;
 }
-async function deployToAgent(reply, moleculer, nodeId, addonId, buffer) {
+async function deployToAgent(reply, moleculer, nodeId, addonId, buffer, hubBaseUrl) {
     try {
         const broker = moleculer.broker;
-        const raw = await broker.call('$agent.deploy', { addonId, bundle: buffer }, { nodeID: nodeId, timeout: AGENT_DEPLOY_TIMEOUT_MS });
+        // The hub currently only ever sends the `hub-http` source (agent streams
+        // the tgz directly from this hub). The `{kind:'npm'}` source is a reserved
+        // follow-up (published-addon optimization) and is intentionally not produced
+        // yet. Wiring it later must also make the agent's npm path evict the addon's
+        // declaration ids before `$agent.reload`, otherwise an npm update pins the
+        // stale version.
+        const raw = await broker.call('$agent.deploy', { addonId, source: buildHubHttpSource(buffer, hubBaseUrl) }, { nodeID: nodeId, timeout: AGENT_DEPLOY_CONTROL_TIMEOUT_MS });
         if (!isAgentDeployResponse(raw)) {
             return reply.status(502).send({ error: 'Agent deploy returned malformed response' });
         }

package/dist/api/deploy-stage-registry.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeployStageRegistry = void 0;
+const node_crypto_1 = require("node:crypto");
+/**
+ * In-memory, single-use, TTL-bounded store of staged addon tarballs the hub
+ * serves to agents over HTTP. One entry per deploy target; the token is
+ * consumed on the first successful read so a bundle URL is never reusable.
+ */
+class DeployStageRegistry {
+    entries = new Map();
+    ttlMs;
+    now;
+    constructor(opts) {
+        this.ttlMs = opts?.ttlMs ?? 300_000;
+        this.now = opts?.now ?? Date.now;
+    }
+    stage(buffer) {
+        // Reclaim abandoned (never-consumed) entries before inserting a new one.
+        this.sweepExpired();
+        const id = (0, node_crypto_1.randomUUID)();
+        const token = (0, node_crypto_1.randomUUID)();
+        const sha256 = (0, node_crypto_1.createHash)('sha256').update(buffer).digest('hex');
+        this.entries.set(id, { token, buffer, sha256, expiresAt: this.now() + this.ttlMs });
+        return { id, token, sha256, bytes: buffer.length };
+    }
+    consume(id, token) {
+        const entry = this.entries.get(id);
+        if (!entry)
+            return null;
+        if (this.now() > entry.expiresAt) {
+            this.entries.delete(id);
+            return null;
+        }
+        // Constant-time comparison: different byte lengths → not equal (no timing oracle).
+        const entryBuf = Buffer.from(entry.token);
+        const tokenBuf = Buffer.from(token);
+        if (entryBuf.length !== tokenBuf.length || !(0, node_crypto_1.timingSafeEqual)(entryBuf, tokenBuf))
+            return null;
+        this.entries.delete(id); // single-use
+        return entry.buffer;
+    }
+    peekExists(id) {
+        const e = this.entries.get(id);
+        if (!e)
+            return false;
+        if (this.now() > e.expiresAt) {
+            this.entries.delete(id);
+            return false;
+        }
+        return true;
+    }
+    sweepExpired() {
+        const t = this.now();
+        for (const [id, e] of this.entries)
+            if (t > e.expiresAt)
+                this.entries.delete(id);
+    }
+}
+exports.DeployStageRegistry = DeployStageRegistry;

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),