@celonis/content-cli 1.8.0 → 1.9.0

package/commands/api/api.service.js

@@ -0,0 +1,81 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../../core/utils/logger", "../../core/utils/file-service", "uuid"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ApiService = void 0;
+    const logger_1 = require("../../core/utils/logger");
+    const file_service_1 = require("../../core/utils/file-service");
+    const uuid_1 = require("uuid");
+    class ApiService {
+        constructor(context) {
+            this.httpClient = () => context.httpClient;
+        }
+        request(path, method, body, jsonFile) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!path.startsWith("/")) {
+                    throw new logger_1.FatalError("Path must start with /");
+                }
+                const validMethods = ["GET", "POST", "PUT", "DELETE"];
+                if (!validMethods.includes(method)) {
+                    throw new logger_1.FatalError(`Invalid method '${method}'. Must be one of: ${validMethods.join(", ")}`);
+                }
+                logger_1.logger.info(`${method} ${path}`);
+                let parsedBody;
+                if (body) {
+                    try {
+                        parsedBody = JSON.parse(body);
+                    }
+                    catch (_a) {
+                        throw new logger_1.FatalError("--body must be valid JSON");
+                    }
+                }
+                const data = yield this.execute(method, path, parsedBody);
+                if (jsonFile) {
+                    const filename = (0, uuid_1.v4)() + ".json";
+                    file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(data, null, 2), filename);
+                    logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + filename);
+                }
+                else {
+                    const output = typeof data === "string" ? data : JSON.stringify(data, null, 2);
+                    logger_1.logger.info(output);
+                }
+            });
+        }
+        execute(method, path, body) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    switch (method) {
+                        case "GET":
+                            return yield this.httpClient().get(path);
+                        case "POST":
+                            return yield this.httpClient().post(path, body !== null && body !== void 0 ? body : {});
+                        case "PUT":
+                            return yield this.httpClient().put(path, body !== null && body !== void 0 ? body : {});
+                        case "DELETE":
+                            return yield this.httpClient().delete(path);
+                    }
+                }
+                catch (e) {
+                    throw new logger_1.FatalError(`${method} ${path} failed: ${e}`);
+                }
+            });
+        }
+    }
+    exports.ApiService = ApiService;
+});

package/commands/api/module.js

@@ -0,0 +1,42 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../../core/command/module-handler", "./api.service"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    const module_handler_1 = require("../../core/command/module-handler");
+    const api_service_1 = require("./api.service");
+    class Module extends module_handler_1.IModule {
+        register(context, configurator) {
+            configurator.command("api")
+                .description("Send raw HTTP requests to Celonis APIs on the configured team (beta — testing only).")
+                .beta()
+                .command("request")
+                .description("Send a request to the given Celonis API path (e.g. /package-manager/api/packages)")
+                .requiredOption("--path <path>", "API path starting with / (e.g. /package-manager/api/packages)")
+                .option("--method <method>", "HTTP method: GET, POST, PUT, DELETE", "GET")
+                .option("--body <body>", "Request body as JSON string (for POST/PUT)")
+                .option("--json", "Write the response to a JSON file instead of printing it")
+                .action(this.request);
+        }
+        request(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new api_service_1.ApiService(context).request(options.path, options.method.toUpperCase(), options.body, !!options.json);
+            });
+        }
+    }
+    return Module;
+});

package/commands/asset-registry/asset-registry-api.js

@@ -0,0 +1,47 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../../core/utils/logger"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AssetRegistryApi = void 0;
+    const logger_1 = require("../../core/utils/logger");
+    class AssetRegistryApi {
+        constructor(context) {
+            this.httpClient = () => context.httpClient;
+        }
+        listTypes() {
+            return __awaiter(this, void 0, void 0, function* () {
+                return this.httpClient()
+                    .get("/pacman/api/core/asset-registry/types")
+                    .catch((e) => {
+                    throw new logger_1.FatalError(`Problem listing asset registry types: ${e}`);
+                });
+            });
+        }
+        getType(assetType) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return this.httpClient()
+                    .get(`/pacman/api/core/asset-registry/types/${encodeURIComponent(assetType)}`)
+                    .catch((e) => {
+                    throw new logger_1.FatalError(`Problem getting asset type '${assetType}': ${e}`);
+                });
+            });
+        }
+    }
+    exports.AssetRegistryApi = AssetRegistryApi;
+});

package/commands/asset-registry/asset-registry.interfaces.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/commands/asset-registry/asset-registry.service.js

@@ -0,0 +1,87 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./asset-registry-api", "../../core/utils/file-service", "../../core/utils/logger", "uuid"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AssetRegistryService = void 0;
+    const asset_registry_api_1 = require("./asset-registry-api");
+    const file_service_1 = require("../../core/utils/file-service");
+    const logger_1 = require("../../core/utils/logger");
+    const uuid_1 = require("uuid");
+    class AssetRegistryService {
+        constructor(context) {
+            this.api = new asset_registry_api_1.AssetRegistryApi(context);
+        }
+        listTypes(jsonResponse) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const metadata = yield this.api.listTypes();
+                const descriptors = Object.values(metadata.types);
+                if (jsonResponse) {
+                    const filename = (0, uuid_1.v4)() + ".json";
+                    file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(metadata), filename);
+                    logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + filename);
+                }
+                else {
+                    if (descriptors.length === 0) {
+                        logger_1.logger.info("No asset types registered.");
+                        return;
+                    }
+                    descriptors.forEach((descriptor) => {
+                        this.logDescriptorSummary(descriptor);
+                    });
+                }
+            });
+        }
+        getType(assetType, jsonResponse) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const descriptor = yield this.api.getType(assetType);
+                if (jsonResponse) {
+                    const filename = (0, uuid_1.v4)() + ".json";
+                    file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(descriptor), filename);
+                    logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + filename);
+                }
+                else {
+                    this.logDescriptorDetail(descriptor);
+                }
+            });
+        }
+        logDescriptorSummary(descriptor) {
+            logger_1.logger.info(`${descriptor.assetType} - ${descriptor.displayName} [${descriptor.group}] (basePath: ${descriptor.service.basePath})`);
+        }
+        logDescriptorDetail(descriptor) {
+            logger_1.logger.info(`Asset Type:   ${descriptor.assetType}`);
+            logger_1.logger.info(`Display Name: ${descriptor.displayName}`);
+            if (descriptor.description) {
+                logger_1.logger.info(`Description:  ${descriptor.description}`);
+            }
+            logger_1.logger.info(`Group:        ${descriptor.group}`);
+            logger_1.logger.info(`Schema:       v${descriptor.assetSchema.version}`);
+            logger_1.logger.info(`Base Path:    ${descriptor.service.basePath}`);
+            logger_1.logger.info(`Endpoints:`);
+            logger_1.logger.info(`  schema:     ${descriptor.endpoints.schema}`);
+            logger_1.logger.info(`  validate:   ${descriptor.endpoints.validate}`);
+            if (descriptor.endpoints.methodology) {
+                logger_1.logger.info(`  methodology: ${descriptor.endpoints.methodology}`);
+            }
+            if (descriptor.endpoints.examples) {
+                logger_1.logger.info(`  examples:   ${descriptor.endpoints.examples}`);
+            }
+        }
+    }
+    exports.AssetRegistryService = AssetRegistryService;
+});

package/commands/asset-registry/module.js

@@ -0,0 +1,48 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../../core/command/module-handler", "./asset-registry.service"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    const module_handler_1 = require("../../core/command/module-handler");
+    const asset_registry_service_1 = require("./asset-registry.service");
+    class Module extends module_handler_1.IModule {
+        register(context, configurator) {
+            const assetRegistryCommand = configurator.command("asset-registry")
+                .description("Manage the asset registry — discover registered asset types and their service descriptors.");
+            assetRegistryCommand.command("list")
+                .description("List all registered asset types")
+                .option("--json", "Return the response as a JSON file")
+                .action(this.listTypes);
+            assetRegistryCommand.command("get")
+                .description("Get the descriptor for a specific asset type")
+                .requiredOption("--assetType <assetType>", "The asset type identifier (e.g., BOARD_V2)")
+                .option("--json", "Return the response as a JSON file")
+                .action(this.getType);
+        }
+        listTypes(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new asset_registry_service_1.AssetRegistryService(context).listTypes(!!options.json);
+            });
+        }
+        getType(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new asset_registry_service_1.AssetRegistryService(context).getType(options.assetType, !!options.json);
+            });
+        }
+    }
+    return Module;
+});

package/commands/configuration-management/api/batch-import-export-api.js

@@ -96,9 +96,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 });
             });
         }
-        importPackages(data, overwrite) {
+        importPackages(data, overwrite, performValidation) {
             return __awaiter(this, void 0, void 0, function* () {
-                return this.httpClient().postFile("/package-manager/api/core/packages/import/batch", data, { overwrite });
+                return this.httpClient().postFile("/package-manager/api/core/packages/import/batch", data, { overwrite, performValidation });
             });
         }
         findVariablesWithValuesByPackageKeysAndVersion(packagesByKeyAndVersion) {

package/commands/configuration-management/api/package-validation-api.js

@@ -0,0 +1,36 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../../../core/utils/logger"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.PackageValidationApi = void 0;
+    const logger_1 = require("../../../core/utils/logger");
+    class PackageValidationApi {
+        constructor(context) {
+            this.httpClient = () => context.httpClient;
+        }
+        validatePackage(packageKey, request) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return this.httpClient().post(`/pacman/api/core/packages/${packageKey}/validate`, request).catch(e => {
+                    throw new logger_1.FatalError(`Problem validating package "${packageKey}": ${e}`);
+                });
+            });
+        }
+    }
+    exports.PackageValidationApi = PackageValidationApi;
+});

package/commands/configuration-management/api/staging-package-variables-api.js

@@ -0,0 +1,39 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../../../core/utils/logger"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.StagingPackageVariablesApi = void 0;
+    const logger_1 = require("../../../core/utils/logger");
+    class StagingPackageVariablesApi {
+        constructor(context) {
+            this.httpClient = () => context.httpClient;
+        }
+        findAllByPackageKeys(packageKeys) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const path = `/pacman/api/core/staging/packages/variables/by-package-keys`;
+                return yield this.httpClient()
+                    .post(path, packageKeys)
+                    .catch(e => {
+                    throw new logger_1.FatalError(`Problem listing staging variables for packages: ${e}`);
+                });
+            });
+        }
+    }
+    exports.StagingPackageVariablesApi = StagingPackageVariablesApi;
+});

package/commands/configuration-management/batch-import-export.service.js

@@ -124,7 +124,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 }
             });
         }
-        batchImportPackages(sourcePath, overwrite, gitBranch) {
+        batchImportPackages(sourcePath, overwrite, gitBranch, performValidation = false) {
             return __awaiter(this, void 0, void 0, function* () {
                 let sourceToBeImported;
                 if (gitBranch) {
@@ -142,7 +142,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 configs = yield this.studioService.mapSpaces(configs, studioManifests);
                 const existingStudioPackages = yield this.studioPackageApi.findAllPackages();
                 const formData = this.buildBodyForImport(configs, sourceToBeImported, variablesManifests);
-                const postPackageImportData = yield this.batchImportExportApi.importPackages(formData, overwrite);
+                const postPackageImportData = yield this.batchImportExportApi.importPackages(formData, overwrite, performValidation);
                 yield this.studioService.processImportedPackages(configs, existingStudioPackages, studioManifests);
                 if (gitBranch) {
                     fs.rmSync(sourceToBeImported);

package/commands/configuration-management/config-command.service.js

@@ -46,9 +46,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 }
             });
         }
-        listVariables(jsonResponse, keysByVersion, keysByVersionFile) {
+        listVariables(jsonResponse, keysByVersion, keysByVersionFile, packageKeys) {
             return __awaiter(this, void 0, void 0, function* () {
-                if (jsonResponse) {
+                if (packageKeys.length > 0) {
+                    if (jsonResponse) {
+                        yield this.variableService.exportStagingVariables(packageKeys);
+                    }
+                    else {
+                        yield this.variableService.listStagingVariables(packageKeys);
+                    }
+                }
+                else if (jsonResponse) {
                     yield this.variableService.exportVariables(keysByVersion, keysByVersionFile);
                 }
                 else {
@@ -62,7 +70,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         batchExportPackagesMetadata(packageKeys, jsonResponse) {
             return this.batchImportExportService.batchExportPackagesMetadata(packageKeys, jsonResponse);
         }
-        batchImportPackages(file, directory, overwrite, gitBranch) {
+        batchImportPackages(file, directory, overwrite, gitBranch, performValidation = false) {
             if ((directory || file) && gitBranch) {
                 throw new Error("You cannot use both file/directory and gitBranch options at the same time. Only one import source can be defined.");
             }
@@ -79,7 +87,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 throw new Error("The directory option accepts only directories.");
             }
             const sourcePath = file !== null && file !== void 0 ? file : directory;
-            return this.batchImportExportService.batchImportPackages(sourcePath, overwrite, gitBranch);
+            return this.batchImportExportService.batchImportPackages(sourcePath, overwrite, gitBranch, performValidation);
         }
         diffPackages(file, hasChanges, jsonResponse) {
             return this.diffService.diffPackages(file, hasChanges, jsonResponse);

package/commands/configuration-management/interfaces/package-validation.interfaces.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/commands/configuration-management/module.js

@@ -16,7 +16,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "../../core/command/module-handler", "./config-command.service", "./variable-command.service", "./node.service", "./node-diff.service", "./node-dependency.service", "./package-version-command.service"], factory);
+        define(["require", "exports", "../../core/command/module-handler", "./config-command.service", "./variable-command.service", "./node.service", "./node-diff.service", "./node-dependency.service", "./package-version-command.service", "./package-validation.service"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -27,6 +27,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     const node_diff_service_1 = require("./node-diff.service");
     const node_dependency_service_1 = require("./node-dependency.service");
     const package_version_command_service_1 = require("./package-version-command.service");
+    const package_validation_service_1 = require("./package-validation.service");
     class Module extends module_handler_1.IModule {
         register(context, configurator) {
             const configCommand = configurator.command("config");
@@ -60,11 +61,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             configCommand.command("import")
                 .description("Command to import package configs")
                 .option("--overwrite", "Flag to allow overwriting of packages")
+                .option("--validate", "Validate node configurations before import", false)
                 .option("--gitProfile <gitProfile>", "Git profile which you want to use for the Git operations")
                 .option("--gitBranch <gitBranch>", "Git branch from which you want to pull the exported file and import")
                 .option("-f, --file <file>", "Exported packages file (relative path)")
                 .option("-d, --directory <directory>", "Exported packages directory (relative path)")
                 .action(this.batchImportPackages);
+            configCommand.command("validate")
+                .description("Validate package node configurations")
+                .requiredOption("--packageKey <packageKey>", "Key of the package to validate")
+                .option("--layers <layers...>", "Validation layers to run", ["SCHEMA"])
+                .option("--nodeKeys <nodeKeys...>", "Specific node keys to validate (default: all nodes)")
+                .option("--json", "Return the response as a JSON file")
+                .action(this.validatePackage);
             configCommand.command("diff")
                 .description("Command to diff configs of packages")
                 .option("--hasChanges", "Flag to return only the information if the package has changes without the actual changes")
@@ -91,9 +100,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             const variablesCommand = configCommand.command("variables")
                 .description("Commands related to variable configs");
             variablesCommand.command("list")
-                .description("Command to list versioned variables of packages")
+                .description("List package variables: use --packageKeys for unversioned, or --keysByVersion / --keysByVersionFile for versioned packages")
                 .option("--json", "Return response as json type", "")
-                .option("--keysByVersion <keysByVersion...>", "Mapping of package keys and versions", "")
+                .option("--packageKeys <packageKeys...>", "Package keys (unversioned variables only; mutually exclusive with versioned options)", [])
+                .option("--keysByVersion <keysByVersion...>", "Mapping of package keys and versions", [])
                 .option("--keysByVersionFile <keysByVersionFile>", "Package keys by version mappings file path.", "")
                 .action(this.listVariables);
             const nodesCommand = configCommand.command("nodes")
@@ -189,7 +199,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 if (options.gitProfile && !options.gitBranch) {
                     throw new Error("Please specify a branch using --gitBranch when using a Git profile.");
                 }
-                yield new config_command_service_1.ConfigCommandService(context).batchImportPackages(options.file, options.directory, options.overwrite, options.gitBranch);
+                yield new config_command_service_1.ConfigCommandService(context).batchImportPackages(options.file, options.directory, options.overwrite, options.gitBranch, options.validate);
             });
         }
         diffPackages(context, command, options) {
@@ -197,9 +207,22 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 yield new config_command_service_1.ConfigCommandService(context).diffPackages(options.file, options.hasChanges, options.json);
             });
         }
+        validatePackage(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new package_validation_service_1.PackageValidationService(context).validatePackage(options.packageKey, options.layers, options.nodeKeys, options.json);
+            });
+        }
         listVariables(context, command, options) {
             return __awaiter(this, void 0, void 0, function* () {
-                yield new config_command_service_1.ConfigCommandService(context).listVariables(options.json, options.keysByVersion, options.keysByVersionFile);
+                const hasStagingKeys = options.packageKeys.length > 0;
+                const hasVersioned = options.keysByVersion.length > 0 || options.keysByVersionFile !== "";
+                if (hasStagingKeys && hasVersioned) {
+                    throw new Error("Please provide either --packageKeys or --keysByVersion/--keysByVersionFile, but not both.");
+                }
+                if (!hasStagingKeys && !hasVersioned) {
+                    throw new Error("Please provide --packageKeys for staging, or --keysByVersion / --keysByVersionFile for versioned packages.");
+                }
+                yield new config_command_service_1.ConfigCommandService(context).listVariables(options.json, options.keysByVersion, options.keysByVersionFile, options.packageKeys);
             });
         }
         listAssignments(context, command, options) {

package/commands/configuration-management/package-validation.service.js

@@ -0,0 +1,62 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "uuid", "./api/package-validation-api", "../../core/utils/logger", "../../core/utils/file-service"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.PackageValidationService = void 0;
+    const uuid_1 = require("uuid");
+    const package_validation_api_1 = require("./api/package-validation-api");
+    const logger_1 = require("../../core/utils/logger");
+    const file_service_1 = require("../../core/utils/file-service");
+    class PackageValidationService {
+        constructor(context) {
+            this.packageValidationApi = new package_validation_api_1.PackageValidationApi(context);
+        }
+        validatePackage(packageKey, layers, nodeKeys, jsonOutput) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const request = { layers };
+                if (nodeKeys && nodeKeys.length > 0) {
+                    request.nodeKeys = nodeKeys;
+                }
+                const response = yield this.packageValidationApi.validatePackage(packageKey, request);
+                if (jsonOutput) {
+                    const reportFileName = "config_validate_report_" + (0, uuid_1.v4)() + ".json";
+                    file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(response), reportFileName);
+                    logger_1.logger.info("Validation report file: " + reportFileName);
+                }
+                else {
+                    this.printValidationResult(response);
+                }
+            });
+        }
+        printValidationResult(response) {
+            const status = response.valid ? "VALID" : "INVALID";
+            logger_1.logger.info("");
+            logger_1.logger.info(`Validation result: ${status}`);
+            logger_1.logger.info(`Errors: ${response.summary.errors} | Warnings: ${response.summary.warnings} | Info: ${response.summary.info}`);
+            if (response.results.length > 0) {
+                logger_1.logger.info("");
+                response.results.forEach((result) => {
+                    const prefix = result.severity.toUpperCase().padEnd(7);
+                    logger_1.logger.info(`  ${prefix} ${result.nodeKey} (${result.assetType}) - ${result.message} [${result.code}]`);
+                });
+            }
+        }
+    }
+    exports.PackageValidationService = PackageValidationService;
+});

package/commands/configuration-management/variable.service.js

@@ -13,7 +13,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "uuid", "../../core/utils/logger", "./studio.service", "../../core/utils/file-service", "./api/batch-import-export-api", "url", "./api/variable-assignment-candidates-api"], factory);
+        define(["require", "exports", "uuid", "../../core/utils/logger", "./studio.service", "../../core/utils/file-service", "./api/batch-import-export-api", "url", "./api/variable-assignment-candidates-api", "./api/staging-package-variables-api"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -26,10 +26,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     const batch_import_export_api_1 = require("./api/batch-import-export-api");
     const url_1 = require("url");
     const variable_assignment_candidates_api_1 = require("./api/variable-assignment-candidates-api");
+    const staging_package_variables_api_1 = require("./api/staging-package-variables-api");
     class VariableService {
         constructor(context) {
             this.batchImportExportApi = new batch_import_export_api_1.BatchImportExportApi(context);
             this.variableAssignmentCandidatesApi = new variable_assignment_candidates_api_1.VariableAssignmentCandidatesApi(context);
+            this.stagingPackageVariablesApi = new staging_package_variables_api_1.StagingPackageVariablesApi(context);
             this.studioService = new studio_service_1.StudioService(context);
         }
         listVariables(keysByVersion, keysByVersionFile) {
@@ -62,6 +64,25 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 this.exportToJson(variableManifests);
             });
         }
+        listStagingVariables(packageKeys) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const byPackage = yield this.fetchStagingVariablesByPackageKeys(packageKeys);
+                byPackage.forEach(entry => {
+                    logger_1.logger.info(JSON.stringify(entry));
+                });
+            });
+        }
+        exportStagingVariables(packageKeys) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const byPackage = yield this.fetchStagingVariablesByPackageKeys(packageKeys);
+                this.exportToJson(byPackage);
+            });
+        }
+        fetchStagingVariablesByPackageKeys(packageKeys) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return yield this.stagingPackageVariablesApi.findAllByPackageKeys(packageKeys);
+            });
+        }
         getVersionedVariablesByKeyVersionPairs(keysByVersion, keysByVersionFile) {
             return __awaiter(this, void 0, void 0, function* () {
                 const variablesExportRequest = yield this.buildKeyVersionPairs(keysByVersion, keysByVersionFile);

package/lib/commands/api/api.service.d.ts

@@ -0,0 +1,7 @@
+import { Context } from "../../core/command/cli-context";
+export declare class ApiService {
+    private httpClient;
+    constructor(context: Context);
+    request(path: string, method: string, body?: string, jsonFile?: boolean): Promise<void>;
+    private execute;
+}

package/lib/commands/api/module.d.ts

@@ -0,0 +1,7 @@
+import { Configurator, IModule } from "../../core/command/module-handler";
+import { Context } from "../../core/command/cli-context";
+declare class Module extends IModule {
+    register(context: Context, configurator: Configurator): void;
+    private request;
+}
+export = Module;

package/lib/commands/asset-registry/asset-registry-api.d.ts

@@ -0,0 +1,8 @@
+import { Context } from "../../core/command/cli-context";
+import { AssetRegistryDescriptor, AssetRegistryMetadata } from "./asset-registry.interfaces";
+export declare class AssetRegistryApi {
+    private httpClient;
+    constructor(context: Context);
+    listTypes(): Promise<AssetRegistryMetadata>;
+    getType(assetType: string): Promise<AssetRegistryDescriptor>;
+}

package/lib/commands/asset-registry/asset-registry.interfaces.d.ts

@@ -0,0 +1,30 @@
+export interface AssetRegistryMetadata {
+    types: Record<string, AssetRegistryDescriptor>;
+}
+export interface AssetRegistryDescriptor {
+    assetType: string;
+    displayName: string;
+    description: string | null;
+    group: string;
+    assetSchema: AssetSchema;
+    service: AssetService;
+    endpoints: AssetEndpoints;
+    contributions: AssetContributions;
+}
+export interface AssetSchema {
+    version: string;
+}
+export interface AssetService {
+    basePath: string;
+}
+export interface AssetEndpoints {
+    schema: string;
+    validate: string;
+    methodology?: string;
+    examples?: string;
+}
+export interface AssetContributions {
+    pigEntityTypes: string[];
+    dataPipelineEntityTypes: string[];
+    actionTypes: string[];
+}

package/lib/commands/asset-registry/asset-registry.service.d.ts

@@ -0,0 +1,9 @@
+import { Context } from "../../core/command/cli-context";
+export declare class AssetRegistryService {
+    private api;
+    constructor(context: Context);
+    listTypes(jsonResponse: boolean): Promise<void>;
+    getType(assetType: string, jsonResponse: boolean): Promise<void>;
+    private logDescriptorSummary;
+    private logDescriptorDetail;
+}

package/lib/commands/asset-registry/module.d.ts

@@ -0,0 +1,8 @@
+import { Configurator, IModule } from "../../core/command/module-handler";
+import { Context } from "../../core/command/cli-context";
+declare class Module extends IModule {
+    register(context: Context, configurator: Configurator): void;
+    private listTypes;
+    private getType;
+}
+export = Module;

package/lib/commands/configuration-management/api/batch-import-export-api.d.ts

@@ -12,6 +12,6 @@ export declare class BatchImportExportApi {
     exportPackages(packageKeys: string[], withDependencies: boolean): Promise<Buffer>;
     exportPackagesByVersions(packageKeysWithVersion: string[], withDependencies: boolean): Promise<Buffer>;
     batchExportPackagesMetadata(packageKeys: string[]): Promise<PackageMetadataExportTransport[]>;
-    importPackages(data: FormData, overwrite: boolean): Promise<PostPackageImportData[]>;
+    importPackages(data: FormData, overwrite: boolean, performValidation: boolean): Promise<PostPackageImportData[]>;
     findVariablesWithValuesByPackageKeysAndVersion(packagesByKeyAndVersion: PackageKeyAndVersionPair[]): Promise<VariableManifestTransport[]>;
 }

package/lib/commands/configuration-management/api/package-validation-api.d.ts

@@ -0,0 +1,7 @@
+import { Context } from "../../../core/command/cli-context";
+import { PackageValidationRequest, SchemaValidationResponse } from "../interfaces/package-validation.interfaces";
+export declare class PackageValidationApi {
+    private httpClient;
+    constructor(context: Context);
+    validatePackage(packageKey: string, request: PackageValidationRequest): Promise<SchemaValidationResponse>;
+}

package/lib/commands/configuration-management/api/staging-package-variables-api.d.ts

@@ -0,0 +1,7 @@
+import { Context } from "../../../core/command/cli-context";
+import { StagingVariableManifestTransport } from "../interfaces/package-export.interfaces";
+export declare class StagingPackageVariablesApi {
+    private readonly httpClient;
+    constructor(context: Context);
+    findAllByPackageKeys(packageKeys: string[]): Promise<StagingVariableManifestTransport[]>;
+}

package/lib/commands/configuration-management/batch-import-export.service.d.ts

@@ -10,7 +10,7 @@ export declare class BatchImportExportService {
     listPackagesByKeysWithVersion(keysByVersion: string[], withDependencies: boolean): Promise<void>;
     batchExportPackages(packageKeys: string[], packageKeysByVersion: string[], withDependencies: boolean, gitBranch: string, unzip: boolean): Promise<void>;
     batchExportPackagesMetadata(packageKeys: string[], jsonResponse: boolean): Promise<void>;
-    batchImportPackages(sourcePath: string, overwrite: boolean, gitBranch: string): Promise<void>;
+    batchImportPackages(sourcePath: string, overwrite: boolean, gitBranch: string, performValidation?: boolean): Promise<void>;
     findAndExportListOfActivePackagesByVariableValue(flavors: string[], variableValue: string, variableType: string): Promise<void>;
     listActivePackagesByVariableValue(flavors: string[], variableValue: string, variableType: string): Promise<void>;
     private exportListOfPackages;

package/lib/commands/configuration-management/config-command.service.d.ts

@@ -5,10 +5,10 @@ export declare class ConfigCommandService {
     private diffService;
     constructor(context: Context);
     listPackages(jsonResponse: boolean, flavors: string[], withDependencies: boolean, packageKeys: string[], keysByVersion: string[], variableValue: string, variableType: string): Promise<void>;
-    listVariables(jsonResponse: boolean, keysByVersion: string[], keysByVersionFile: string): Promise<void>;
+    listVariables(jsonResponse: boolean, keysByVersion: string[], keysByVersionFile: string, packageKeys: string[]): Promise<void>;
     batchExportPackages(packageKeys: string[], packageKeysByVersion: string[], withDependencies: boolean, gitBranch: string, unzip: boolean): Promise<void>;
     batchExportPackagesMetadata(packageKeys: string[], jsonResponse: boolean): Promise<void>;
-    batchImportPackages(file: string, directory: string, overwrite: boolean, gitBranch: string): Promise<void>;
+    batchImportPackages(file: string, directory: string, overwrite: boolean, gitBranch: string, performValidation?: boolean): Promise<void>;
     diffPackages(file: string, hasChanges: boolean, jsonResponse: boolean): Promise<void>;
     private listPackagesByVariableValue;
 }

package/lib/commands/configuration-management/interfaces/package-export.interfaces.d.ts

@@ -39,6 +39,10 @@ export interface VariableManifestTransport {
     version: string;
     variables?: VariableExportTransport[];
 }
+export interface StagingVariableManifestTransport {
+    packageKey: string;
+    variables?: VariableExportTransport[];
+}
 export interface PackageKeyAndVersionPair {
     packageKey: string;
     version: string;

package/lib/commands/configuration-management/interfaces/package-validation.interfaces.d.ts

@@ -0,0 +1,25 @@
+export interface PackageValidationRequest {
+    layers: string[];
+    nodeKeys?: string[];
+}
+export interface SchemaValidationResponse {
+    packageKey: string;
+    valid: boolean;
+    summary: SchemaValidationSummary;
+    results: SchemaValidationResult[];
+}
+export interface SchemaValidationSummary {
+    errors: number;
+    warnings: number;
+    info: number;
+}
+export interface SchemaValidationResult {
+    layer: string;
+    severity: string;
+    nodeKey: string;
+    assetType: string;
+    path: string;
+    code: string;
+    message: string;
+    suggestion?: string;
+}

package/lib/commands/configuration-management/module.d.ts

@@ -12,6 +12,7 @@ declare class Module extends IModule {
     private createPackageVersion;
     private batchImportPackages;
     private diffPackages;
+    private validatePackage;
     private listVariables;
     private listAssignments;
     private findNode;

package/lib/commands/configuration-management/package-validation.service.d.ts

@@ -0,0 +1,7 @@
+import { Context } from "../../core/command/cli-context";
+export declare class PackageValidationService {
+    private packageValidationApi;
+    constructor(context: Context);
+    validatePackage(packageKey: string, layers: string[], nodeKeys: string[], jsonOutput: boolean): Promise<void>;
+    private printValidationResult;
+}

package/lib/commands/configuration-management/variable.service.d.ts

@@ -2,12 +2,16 @@ import { Context } from "../../core/command/cli-context";
 export declare class VariableService {
     private batchImportExportApi;
     private variableAssignmentCandidatesApi;
+    private readonly stagingPackageVariablesApi;
     private studioService;
     constructor(context: Context);
     listVariables(keysByVersion: string[], keysByVersionFile: string): Promise<void>;
     listCandidateAssignments(type: string, params: string): Promise<void>;
     findAndExportCandidateAssignments(type: string, params: string): Promise<void>;
     exportVariables(keysByVersion: string[], keysByVersionFile: string): Promise<void>;
+    listStagingVariables(packageKeys: string[]): Promise<void>;
+    exportStagingVariables(packageKeys: string[]): Promise<void>;
+    private fetchStagingVariablesByPackageKeys;
     private getVersionedVariablesByKeyVersionPairs;
     private buildKeyVersionPairs;
     private buildKeyAndVersionPairsFromArrayInput;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celonis/content-cli",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "description": "CLI Tool to help manage content in Celonis Platform",
   "main": "content-cli.js",
   "bin": {
@@ -31,7 +31,7 @@
     "simple-git": "3.32.3",
     "valid-url": "1.0.9",
     "winston": "3.17.0",
-    "yaml": "2.7.0"
+    "yaml": "2.8.3"
   },
   "devDependencies": {
     "@types/adm-zip": "0.5.7",