@camstack/server 1.2.501 → 1.2.502

package/dist/agent/agent-service.js

@@ -44,6 +44,8 @@ const moleculer_1 = require("moleculer");
 const agent_deploy_swap_js_1 = require("./agent-deploy-swap.js");
 const agent_undeploy_js_1 = require("./agent-undeploy.js");
 const apply_model_distribution_js_1 = require("./apply-model-distribution.js");
+const apply_stage_dev_uploads_js_1 = require("./apply-stage-dev-uploads.js");
+const dev_uploads_bundle_js_1 = require("../api/dev-uploads-bundle.js");
 const fetch_bundle_from_hub_js_1 = require("./fetch-bundle-from-hub.js");
 /**
  * Console-backed scoped logger for the deploy swap (the only consumer in this
@@ -459,6 +461,23 @@ function createAgentService(deps) {
                     return resolveDeployAction(seam)({ addonId, source, bundle });
                 },
             },
+            /**
+             * Stage a hub-packed `dev-uploads/<version>/` set under this node's
+             * `server-root/dev-uploads/` so a subsequent `applyServerUpdate` for a
+             * `-dev.<epoch>` version can promote locally (Path B fan-out). Does not
+             * restart or promote — only writes the upload layout.
+             */
+            stageDevUploads: {
+                handler: async (ctx) => {
+                    const { params } = ctx;
+                    const seam = {
+                        dataDir: deps.dataDir,
+                        fetchBundle: (s) => (0, fetch_bundle_from_hub_js_1.fetchBundleFromHub)(s),
+                        unpack: dev_uploads_bundle_js_1.unpackDevUploadVersionBundle,
+                    };
+                    return (0, apply_stage_dev_uploads_js_1.applyStageDevUploads)(seam, params);
+                },
+            },
             /**
              * Pull a staged model tarball from the hub and untar it into this node's
              * `<dataDir>/models` (Model Studio P2). Reuses the agent-pull machinery:

package/dist/agent/apply-stage-dev-uploads.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyStageDevUploads = applyStageDevUploads;
+/**
+ * Pure seam for `$agent.stageDevUploads` — fetch a hub-staged pack of
+ * `dev-uploads/<version>/` and write it under this node's server-root.
+ */
+const node_crypto_1 = require("node:crypto");
+const index_js_1 = require("../server-root/index.js");
+async function applyStageDevUploads(seam, params) {
+    const { version, source } = params;
+    if (!(0, index_js_1.isDevChannelVersion)(version)) {
+        throw new Error(`$agent.stageDevUploads: version "${version}" is not dev-channel shaped`);
+    }
+    const bundle = await seam.fetchBundle(source);
+    const appliedSha256 = (0, node_crypto_1.createHash)('sha256').update(bundle).digest('hex');
+    const unpacked = await seam.unpack({
+        serverRoot: (0, index_js_1.serverRootDir)(seam.dataDir),
+        version,
+        bundle,
+    });
+    return {
+        success: true,
+        version,
+        path: unpacked.versionDir,
+        packageCount: unpacked.packageCount,
+        appliedSha256,
+    };
+}

package/dist/api/dev-uploads-bundle.js

@@ -0,0 +1,170 @@
+"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.isSafeDevUploadVersion = isSafeDevUploadVersion;
+exports.packDevUploadVersionDir = packDevUploadVersionDir;
+exports.unpackDevUploadVersionBundle = unpackDevUploadVersionBundle;
+/**
+ * Pack / unpack a hub `server-root/dev-uploads/<version>/` directory for
+ * agent fan-out (`POST /api/server-upload/propagate` → `$agent.stageDevUploads`).
+ *
+ * One gzipped tar carries every tarball + `manifest.json`. Fail-closed on
+ * path traversal and on a layout that would not satisfy RootUpdateService.
+ */
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const tar = __importStar(require("tar"));
+const index_js_1 = require("../server-root/index.js");
+/** Version chars safe as a single path segment (matches server-upload). */
+const SAFE_VERSION_RE = /^[0-9A-Za-z][0-9A-Za-z.-]*$/;
+function isSafeDevUploadVersion(version) {
+    return SAFE_VERSION_RE.test(version) && (0, index_js_1.isDevChannelVersion)(version);
+}
+function hasPathTraversal(name) {
+    return name.includes('/') || name.includes('\\') || name.includes('..');
+}
+/**
+ * Pack every file in `versionDir` (basename entries only) into a gzipped tar.
+ * Refuses if the manifest is missing/invalid or lists a missing tarball.
+ */
+async function packDevUploadVersionDir(versionDir) {
+    const manifest = (0, index_js_1.readDevUploadManifest)(versionDir);
+    if (manifest === null) {
+        throw new Error(`dev-uploads manifest missing or invalid in ${versionDir}`);
+    }
+    for (const filename of Object.values(manifest.packages)) {
+        if (hasPathTraversal(filename)) {
+            throw new Error(`dev-uploads package filename refuses path traversal: ${filename}`);
+        }
+        const abs = path.join(versionDir, filename);
+        if (!fs.existsSync(abs)) {
+            throw new Error(`dev-uploads tarball listed in manifest is missing: ${filename}`);
+        }
+    }
+    if (!fs.existsSync(path.join(versionDir, index_js_1.DEV_UPLOAD_MANIFEST_FILE))) {
+        throw new Error(`dev-uploads manifest file missing in ${versionDir}`);
+    }
+    const entries = fs.readdirSync(versionDir).filter((name) => {
+        const st = fs.statSync(path.join(versionDir, name));
+        return st.isFile() && !hasPathTraversal(name);
+    });
+    if (entries.length === 0) {
+        throw new Error(`dev-uploads version dir is empty: ${versionDir}`);
+    }
+    const chunks = [];
+    await new Promise((resolve, reject) => {
+        const stream = tar.c({ gzip: true, cwd: versionDir, portable: true }, entries);
+        stream.on('data', (chunk) => {
+            chunks.push(chunk);
+        });
+        stream.on('error', reject);
+        stream.on('end', () => resolve());
+    });
+    return Buffer.concat(chunks);
+}
+/**
+ * Extract a packed version dir into `serverRoot/dev-uploads/<version>/`
+ * atomically (stage sibling + rename). Validates version shape, entry names,
+ * and that the extracted layout matches the manifest.
+ */
+async function unpackDevUploadVersionBundle(args) {
+    const { serverRoot, version, bundle } = args;
+    if (!isSafeDevUploadVersion(version)) {
+        throw new Error(`Refused: version "${version}" is not a safe dev-channel version for staging`);
+    }
+    const uploadsRoot = path.join(serverRoot, 'dev-uploads');
+    fs.mkdirSync(uploadsRoot, { recursive: true });
+    const finalDir = path.join(uploadsRoot, version);
+    const stagingDir = path.join(uploadsRoot, `.staging-${version}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
+    fs.mkdirSync(stagingDir, { recursive: true });
+    const tmpTgz = path.join(os.tmpdir(), `camstack-dev-uploads-${version.replace(/[^\w.-]/g, '_')}-${Date.now()}.tgz`);
+    try {
+        fs.writeFileSync(tmpTgz, bundle);
+        let refusedEntry = null;
+        await tar.x({
+            file: tmpTgz,
+            cwd: stagingDir,
+            gzip: true,
+            // Basename-only layout. Skipping the entry (filter false) then failing
+            // after extract avoids an unhandled throw from tar's async parser.
+            filter: (entryPath) => {
+                const name = entryPath.replace(/^\.\//, '');
+                if (hasPathTraversal(name) || path.isAbsolute(name) || name.includes('/')) {
+                    refusedEntry = entryPath;
+                    return false;
+                }
+                return true;
+            },
+        });
+        if (refusedEntry !== null) {
+            throw new Error(`Refused: archive entry is not a basename: ${refusedEntry}`);
+        }
+        const manifest = (0, index_js_1.readDevUploadManifest)(stagingDir);
+        if (manifest === null) {
+            throw new Error('extracted archive has no valid manifest.json');
+        }
+        if (manifest.version !== version) {
+            throw new Error(`extracted manifest version mismatch: expected ${version}, got ${manifest.version}`);
+        }
+        for (const filename of Object.values(manifest.packages)) {
+            if (hasPathTraversal(filename)) {
+                throw new Error(`manifest package filename refuses path traversal: ${filename}`);
+            }
+            if (!fs.existsSync(path.join(stagingDir, filename))) {
+                throw new Error(`extracted archive missing package tarball: ${filename}`);
+            }
+        }
+        // Replace any previous incomplete/stale version dir.
+        fs.rmSync(finalDir, { recursive: true, force: true });
+        fs.renameSync(stagingDir, finalDir);
+        return {
+            versionDir: finalDir,
+            packageCount: Object.keys(manifest.packages).length,
+        };
+    }
+    catch (err) {
+        fs.rmSync(stagingDir, { recursive: true, force: true });
+        throw err;
+    }
+    finally {
+        try {
+            fs.unlinkSync(tmpTgz);
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+}

package/dist/api/server-upload-propagate.js

@@ -0,0 +1,178 @@
+"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.registerServerUploadPropagateRoute = registerServerUploadPropagateRoute;
+/**
+ * POST /api/server-upload/propagate — deliver an already-uploaded
+ * `dev-uploads/<version>/` set from the hub onto one agent, then leave
+ * `applyServerUpdate` to the caller (CLI).
+ *
+ * Mirrors addon fan-out: pack the version dir → stage one-shot hub-http
+ * ticket → `$agent.stageDevUploads`. Does NOT promote the closure.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const agent_addon_delivery_js_1 = require("./agent-addon-delivery.js");
+const addon_upload_js_1 = require("./addon-upload.js");
+const dev_uploads_bundle_js_1 = require("./dev-uploads-bundle.js");
+const upload_auth_js_1 = require("./upload-auth.js");
+const index_js_1 = require("../server-root/index.js");
+function isStageResponse(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    return typeof value.success === 'boolean';
+}
+function readBody(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        return { error: 'Expected JSON body { version, nodeId }' };
+    }
+    const body = value;
+    if (typeof body.version !== 'string' || body.version.length === 0) {
+        return { error: 'Missing "version" field' };
+    }
+    if (typeof body.nodeId !== 'string' || body.nodeId.length === 0) {
+        return { error: 'Missing "nodeId" field' };
+    }
+    if (body.nodeId === 'hub' || body.nodeId.includes('/')) {
+        return {
+            error: 'nodeId must be a top-level agent id (not "hub" and not a child runner id)',
+        };
+    }
+    if (!(0, dev_uploads_bundle_js_1.isSafeDevUploadVersion)(body.version)) {
+        return {
+            error: `Refused: version "${body.version}" is not a safe dev-channel version ` +
+                '(expected `<base>-dev.<epochSeconds>`)',
+        };
+    }
+    return { version: body.version, nodeId: body.nodeId };
+}
+function registerServerUploadPropagateRoute(fastify, options) {
+    const { authService, addonRegistry, logger, broker, resolveClusterBaseUrl } = options;
+    fastify.post('/api/server-upload/propagate', async (request, reply) => {
+        const auth = await (0, upload_auth_js_1.authorizeUploadRequest)({
+            authHeader: request.headers.authorization,
+            authService,
+            addonRegistry,
+        });
+        if (!auth.ok) {
+            return reply.status(auth.status).send({ error: auth.error });
+        }
+        const parsed = readBody(request.body);
+        if ('error' in parsed) {
+            return reply.status(400).send({ error: parsed.error });
+        }
+        const { version, nodeId } = parsed;
+        const dataDir = path.resolve(options.dataDir ?? process.env['CAMSTACK_DATA'] ?? 'camstack-data');
+        const versionDir = (0, index_js_1.devUploadVersionDir)((0, index_js_1.serverRootDir)(dataDir), version);
+        if (!fs.existsSync(versionDir)) {
+            return reply.status(404).send({
+                error: `No hub-side upload for ${version} at ${versionDir}. ` +
+                    'Upload first with `camstack deploy-server` (POST /api/server-upload).',
+            });
+        }
+        const manifest = (0, index_js_1.readDevUploadManifest)(versionDir);
+        if (manifest === null) {
+            return reply.status(400).send({
+                error: `Hub upload for ${version} has a missing or invalid manifest.json`,
+            });
+        }
+        let hubBaseUrl;
+        try {
+            hubBaseUrl = await resolveClusterBaseUrl();
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            logger.error('server-upload propagate: no hub address agents can reach', {
+                meta: { version, nodeId, error: message },
+            });
+            return reply.status(502).send({ error: `Agent propagate failed: ${message}` });
+        }
+        let bundle;
+        let source;
+        try {
+            bundle = await (0, dev_uploads_bundle_js_1.packDevUploadVersionDir)(versionDir);
+            source = (0, addon_upload_js_1.buildHubHttpSource)(bundle, hubBaseUrl);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            logger.error('server-upload propagate: pack/stage failed', {
+                meta: { version, nodeId, error: message },
+            });
+            return reply.status(500).send({ error: `Failed to stage upload pack: ${message}` });
+        }
+        try {
+            const raw = await broker.call('$agent.stageDevUploads', { version, source }, { nodeID: nodeId, timeout: agent_addon_delivery_js_1.AGENT_DEPLOY_CONTROL_TIMEOUT_MS });
+            if (!isStageResponse(raw) || raw.success !== true) {
+                logger.warn('server-upload propagate: malformed agent response', {
+                    meta: { version, nodeId },
+                });
+                return reply.status(502).send({ error: 'Agent returned a malformed stage response' });
+            }
+            const applied = raw.appliedSha256;
+            if (applied !== undefined && applied !== source.sha256) {
+                logger.error('server-upload propagate: applied hash mismatch', {
+                    meta: { version, nodeId, expected: source.sha256, applied },
+                });
+                return reply.status(502).send({
+                    error: `applied bundle hash mismatch (shipped ${source.sha256}, agent applied ${applied})`,
+                });
+            }
+            logger.info('server-upload propagate: staged on agent', {
+                meta: {
+                    version,
+                    nodeId,
+                    path: raw.path,
+                    packageCount: raw.packageCount,
+                    verifiedSha256: applied,
+                },
+            });
+            return reply.send({
+                success: true,
+                version,
+                nodeId,
+                path: raw.path,
+                packageCount: raw.packageCount ?? Object.keys(manifest.packages).length,
+                verifiedSha256: applied,
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            logger.warn('server-upload propagate: agent call failed', {
+                meta: { version, nodeId, error: message },
+            });
+            return reply.status(502).send({ error: `Agent propagate failed: ${message}` });
+        }
+    });
+}

package/dist/main.js

@@ -71,6 +71,7 @@ const hub_cluster_url_1 = require("./api/hub-cluster-url");
 const model_distributor_js_1 = require("./api/model-distributor.js");
 const oauth2_routes_js_1 = require("./api/oauth2/oauth2-routes.js");
 const server_upload_1 = require("./api/server-upload");
+const server_upload_propagate_1 = require("./api/server-upload-propagate");
 const sse_no_compression_js_1 = require("./api/sse-no-compression.js");
 const frame_policy_1 = require("./api/static/frame-policy");
 const precompressed_asset_js_1 = require("./api/static/precompressed-asset.js");
@@ -453,6 +454,16 @@ async function bootstrap() {
             logger: app.get(logging_service_1.LoggingService).createLogger('server-upload'),
         });
         console.log('[bootstrap] Server upload route registered at POST /api/server-upload');
+        (0, server_upload_propagate_1.registerServerUploadPropagateRoute)(fastify, {
+            authService: uploadAuthService,
+            addonRegistry: uploadAddonRegistry,
+            logger: app.get(logging_service_1.LoggingService).createLogger('server-upload-propagate'),
+            broker: uploadMoleculer.broker,
+            resolveClusterBaseUrl: (0, hub_cluster_url_1.clusterBaseUrlResolver)(() => uploadAddonRegistry
+                .getCapabilityRegistry()
+                .getSingleton('local-network')),
+        });
+        console.log('[bootstrap] Server upload propagate route registered at POST /api/server-upload/propagate');
         // Companion endpoint: /api/auth/whoami — validates JWT or cst_*
         // scoped tokens, returns the resolved identity + scope summary.
         // Mirrors the addon-upload auth chain so the CLI can ping for

package/dist/server-root/index.js

@@ -1474,7 +1474,7 @@ var require_dist = __commonJS({
         if (isDevChannelVersion(target)) {
           const uploadsDir = devUploadVersionDir(this.rootDir(), target);
           if (!fs6.existsSync(uploadsDir)) {
-            return this.refuseUpdate("dev-uploads-missing", target, `Refused: dev-channel version ${target} has no uploaded tarballs on this node (${uploadsDir} is missing). Dev server deploys are hub-only in this phase \u2014 upload via \`camstack deploy-server\` against this node first.`);
+            return this.refuseUpdate("dev-uploads-missing", target, `Refused: dev-channel version ${target} has no uploaded tarballs on this node (${uploadsDir} is missing). On the hub: \`camstack deploy-server\`. On an agent: \`camstack deploy-server -n <nodeId>\` (or \`--all\`) so the hub can POST /api/server-upload/propagate first.`);
           }
         }
         this.inFlight = "staging";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/server",
-  "version": "1.2.501",
+  "version": "1.2.502",
   "license": "MIT",
   "private": false,
   "files": [
@@ -46,7 +46,7 @@
     "@camstack/addon-pipeline-orchestrator": "1.2.305",
     "@camstack/addon-post-analysis": "1.2.352",
     "@camstack/sdk": "1.2.129",
-    "@camstack/system": "1.2.394",
+    "@camstack/system": "1.2.395",
     "@camstack/types": "1.2.340",
     "@camstack/ui-library": "1.2.260",
     "@fastify/compress": "^9.0.0",