@celonis/content-cli 1.4.1 → 1.6.0

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

@@ -57,6 +57,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 });
             });
         }
+        findPackagesByKeysAndVersion(packageKeysWithVersion, withDependencies = false) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const queryParams = new URLSearchParams();
+                packageKeysWithVersion.forEach(keyWithVersion => queryParams.append("packageKeysWithVersion", keyWithVersion));
+                queryParams.set("withDependencies", withDependencies.toString());
+                return this.httpClient().get(`/package-manager/api/core/packages/versions/export/list?${queryParams.toString()}`).catch(e => {
+                    throw new logger_1.FatalError(`Problem getting packages by keys and versions: ${e}`);
+                });
+            });
+        }
         exportPackages(packageKeys, withDependencies) {
             return __awaiter(this, void 0, void 0, function* () {
                 const queryParams = new URLSearchParams();

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

@@ -47,10 +47,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 });
             });
         }
-        findAndExportListOfActivePackages(flavors, packageKeys, withDependencies) {
+        findAndExportListOfPackages(flavors, packageKeys, keysByVersion, withDependencies) {
             return __awaiter(this, void 0, void 0, function* () {
                 let packagesToExport;
-                if (packageKeys.length) {
+                if (keysByVersion.length) {
+                    packagesToExport = yield this.batchImportExportApi.findPackagesByKeysAndVersion(keysByVersion, withDependencies);
+                }
+                else if (packageKeys.length) {
                     packagesToExport = yield this.batchImportExportApi.findActivePackagesByKeys(packageKeys, withDependencies);
                 }
                 else {
@@ -60,6 +63,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 this.exportListOfPackages(packagesToExport);
             });
         }
+        listPackagesByKeysWithVersion(keysByVersion, withDependencies) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const exportedPackages = yield this.batchImportExportApi.findPackagesByKeysAndVersion(keysByVersion, withDependencies);
+                exportedPackages.forEach(pkg => {
+                    logger_1.logger.info(`${pkg.name} - Key: "${pkg.key}"`);
+                });
+            });
+        }
         batchExportPackages(packageKeys, packageKeysByVersion, withDependencies, gitBranch, unzip) {
             return __awaiter(this, void 0, void 0, function* () {
                 let exportedPackagesData;

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

@@ -29,14 +29,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             this.variableService = new variable_service_1.VariableService(context);
             this.diffService = new diff_service_1.DiffService(context);
         }
-        listActivePackages(jsonResponse, flavors, withDependencies, packageKeys, variableValue, variableType) {
+        listPackages(jsonResponse, flavors, withDependencies, packageKeys, keysByVersion, variableValue, variableType) {
             return __awaiter(this, void 0, void 0, function* () {
                 if (variableValue) {
                     yield this.listPackagesByVariableValue(jsonResponse, flavors, variableValue, variableType);
                     return;
                 }
                 if (jsonResponse) {
-                    yield this.batchImportExportService.findAndExportListOfActivePackages(flavors !== null && flavors !== void 0 ? flavors : [], packageKeys !== null && packageKeys !== void 0 ? packageKeys : [], withDependencies);
+                    yield this.batchImportExportService.findAndExportListOfPackages(flavors !== null && flavors !== void 0 ? flavors : [], packageKeys !== null && packageKeys !== void 0 ? packageKeys : [], keysByVersion !== null && keysByVersion !== void 0 ? keysByVersion : [], withDependencies);
+                }
+                else if (keysByVersion) {
+                    yield this.batchImportExportService.listPackagesByKeysWithVersion(keysByVersion, withDependencies);
                 }
                 else {
                     yield this.batchImportExportService.listActivePackages(flavors !== null && flavors !== void 0 ? flavors : []);

package/commands/configuration-management/module.js

@@ -31,14 +31,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         register(context, configurator) {
             const configCommand = configurator.command("config");
             configCommand.command("list")
-                .description("Command to list active packages that can be exported")
+                .description("Command to list packages")
                 .option("--json", "Return response as json type", "")
                 .option("--flavors <flavors...>", "Lists only active packages of the given flavors")
                 .option("--withDependencies", "Include dependencies", "")
-                .option("--packageKeys <packageKeys...>", "Lists only given package keys")
+                .option("--packageKeys <packageKeys...>", "Lists only active versions of given package keys")
+                .option("--keysByVersion <keysByVersion...>", "Lists packages by given key and version [packageKey.version]")
                 .option("--variableValue <variableValue>", "Variable value for filtering packages by.")
                 .option("--variableType <variableType>", "Variable type for filtering packages by.")
-                .action(this.listActivePackages);
+                .action(this.listPackages);
             configCommand.command("export")
                 .description("Command to export package configs")
                 .option("--packageKeys <packageKeys...>", "Keys of packages to export. Exports the latest deployed version only")
@@ -130,9 +131,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 .option("--params <params>", "Variable query params")
                 .action(this.listAssignments);
         }
-        listActivePackages(context, command, options) {
+        listPackages(context, command, options) {
             return __awaiter(this, void 0, void 0, function* () {
-                yield new config_command_service_1.ConfigCommandService(context).listActivePackages(options.json, options.flavors, options.withDependencies, options.packageKeys, options.variableValue, options.variableType);
+                if (options.packageKeys && options.keysByVersion) {
+                    throw new Error("Please provide either --packageKeys or --keysByVersion, but not both.");
+                }
+                yield new config_command_service_1.ConfigCommandService(context).listPackages(options.json, options.flavors, options.withDependencies, options.packageKeys, options.keysByVersion, options.variableValue, options.variableType);
             });
         }
         batchExportPackages(context, command, options) {

package/commands/studio/command-service/package-command.service.js

@@ -54,16 +54,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 }
             });
         }
-        batchExportPackages(packageKeys, includeDependencies, excludeActionFlows) {
-            return __awaiter(this, void 0, void 0, function* () {
-                yield this.packageService.batchExportPackages(packageKeys, includeDependencies, excludeActionFlows);
-            });
-        }
-        batchImportPackages(spaceMappings, dataModelMappingsFilePath, exportedPackagesFile, overwrite, excludeActionFlows) {
-            return __awaiter(this, void 0, void 0, function* () {
-                yield this.packageService.batchImportPackages(spaceMappings !== null && spaceMappings !== void 0 ? spaceMappings : [], dataModelMappingsFilePath, exportedPackagesFile, overwrite, excludeActionFlows);
-            });
-        }
     }
     exports.PackageCommandService = PackageCommandService;
 });

package/commands/studio/module.js

@@ -27,26 +27,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     const space_command_service_1 = require("./command-service/space-command.service");
     class Module extends module_handler_1.IModule {
         register(context, configurator) {
-            const exportCommand = configurator.command("export");
-            exportCommand.command("packages")
-                .description("Command to export all given packages")
-                .requiredOption("--packageKeys <packageKeys...>", "Exports only given package keys")
-                .option("--includeDependencies", "Include variables and dependencies", "")
-                .option("--excludeActionFlows", "Don't export action flows")
-                .deprecationNotice("`content-cli export packages` is deprecated and is expected to be removed in subsequent updates around: 01-09-2025.\n" +
-                "Please use `content-cli config export` instead.\n")
-                .action(this.batchExportPackages);
-            const importCommand = configurator.command("import");
-            importCommand.command("packages")
-                .description("Command to import all given packages")
-                .option("--spaceMappings <spaceMappings...>", "List of mappings for importing packages to different target spaces. Mappings should follow format 'packageKey:targetSpaceKey'")
-                .option("--overwrite", "Flag to allow overwriting of packages")
-                .option("--excludeActionFlows", "Skip overwrite of action flows of package")
-                .option("--dataModelMappingsFile <dataModelMappingsFile>", "DataModel variable mappings file path. If missing, variables will be mapped from manifest file.")
-                .requiredOption("-f, --file <file>", "Exported packages file (relative path)")
-                .deprecationNotice("`content-cli import packages` is deprecated and is expected to be removed in subsequent updates around: 01-09-2025.\n" +
-                "Please use `content-cli config import` instead.\n")
-                .action(this.batchImportPackages);
             const listCommand = configurator.command("list");
             listCommand.command("packages")
                 .description("Command to list all packages")
@@ -103,17 +83,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 .option("--packageManager", "Upload widget to package manager (deprecated)") // Deprecated
                 .action(this.pushWidget);
         }
-        batchExportPackages(context, command, options) {
-            var _a;
-            return __awaiter(this, void 0, void 0, function* () {
-                yield new package_command_service_1.PackageCommandService(context).batchExportPackages(options.packageKeys, options.includeDependencies, (_a = options.excludeActionFlows) !== null && _a !== void 0 ? _a : false);
-            });
-        }
-        batchImportPackages(context, command, options) {
-            return __awaiter(this, void 0, void 0, function* () {
-                yield new package_command_service_1.PackageCommandService(context).batchImportPackages(options.spaceMappings, options.dataModelMappingsFile, options.file, options.overwrite, options.excludeActionFlows);
-            });
-        }
         listPackages(context, command, options) {
             return __awaiter(this, void 0, void 0, function* () {
                 yield new package_command_service_1.PackageCommandService(context).listPackages(options.json, options.includeDependencies, options.packageKeys);

package/commands/studio/service/package.service.js

@@ -13,39 +13,27 @@ 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", "fs", "adm-zip", "path", "os", "form-data", "../api/package-api", "../../../core/utils/logger", "../interfaces/package-manager.interfaces", "../../../core/utils/file-service", "../../../core/utils/yaml", "yaml", "../utils/semantic-versioning", "../api/node-api", "../api/package-dependencies-api", "./data-model.service", "./studio-variable.service", "./space.service"], factory);
+        define(["require", "exports", "uuid", "../api/package-api", "../../../core/utils/logger", "../interfaces/package-manager.interfaces", "../../../core/utils/file-service", "../api/package-dependencies-api", "./data-model.service", "./studio-variable.service"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.PackageService = void 0;
     const uuid_1 = require("uuid");
-    const fs = require("fs");
-    const AdmZip = require("adm-zip");
-    const path = require("path");
-    const os_1 = require("os");
-    const FormData = require("form-data");
     const package_api_1 = require("../api/package-api");
     const logger_1 = require("../../../core/utils/logger");
     const package_manager_interfaces_1 = require("../interfaces/package-manager.interfaces");
     const file_service_1 = require("../../../core/utils/file-service");
-    const yaml_1 = require("../../../core/utils/yaml");
-    const yaml_2 = require("yaml");
-    const semantic_versioning_1 = require("../utils/semantic-versioning");
-    const node_api_1 = require("../api/node-api");
     const package_dependencies_api_1 = require("../api/package-dependencies-api");
     const data_model_service_1 = require("./data-model.service");
     const studio_variable_service_1 = require("./studio-variable.service");
-    const space_service_1 = require("./space.service");
     class PackageService {
         constructor(context) {
             this.fileDownloadedMessage = "File downloaded successfully. New filename: ";
             this.packageApi = new package_api_1.PackageApi(context);
-            this.nodeApi = new node_api_1.NodeApi(context);
             this.packageDependenciesApi = new package_dependencies_api_1.PackageDependenciesApi(context);
             this.dataModelService = new data_model_service_1.DataModelService(context);
             this.variableService = new studio_variable_service_1.StudioVariableService(context);
-            this.spaceService = new space_service_1.SpaceService(context);
         }
         listPackages() {
             return __awaiter(this, void 0, void 0, function* () {
@@ -85,247 +73,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 this.exportListOfPackages(nodesListToExport, fieldsToInclude);
             });
         }
-        batchImportPackages(spaceMappings, dataModelMappingsFilePath, exportedPackagesFile, overwrite, excludeActionFlows) {
-            return __awaiter(this, void 0, void 0, function* () {
-                exportedPackagesFile = exportedPackagesFile + (exportedPackagesFile.includes(".zip") ? "" : ".zip");
-                const zip = new AdmZip(exportedPackagesFile);
-                const importedFilePath = path.resolve((0, os_1.tmpdir)(), "export_" + (0, uuid_1.v4)());
-                yield fs.mkdirSync(importedFilePath);
-                yield zip.extractAllTo(importedFilePath);
-                const manifestNodes = yield this.readManifestFile(importedFilePath);
-                if (!overwrite) {
-                    const allTargetPackages = yield this.packageApi.findAllPackages();
-                    const manifestNodeKeys = manifestNodes.map(node => node.packageKey);
-                    const packagesWithDraftChanges = allTargetPackages
-                        .filter(node => manifestNodeKeys.includes(node.key) && node.workingDraftId !== node.activatedDraftId)
-                        .map(node => node.key)
-                        .join(", ");
-                    if (!!packagesWithDraftChanges) {
-                        throw new logger_1.FatalError(`Failed to import. Cannot overwrite packages with key(s) ${packagesWithDraftChanges}`);
-                    }
-                }
-                let dmTargetIdsBySourceIds = new Map();
-                if (dataModelMappingsFilePath) {
-                    const dataModelMappings = yield file_service_1.fileService.readFileToJson(dataModelMappingsFilePath);
-                    dmTargetIdsBySourceIds = new Map(Object.entries(dataModelMappings.dataModelIdMappings));
-                }
-                manifestNodes.map(node => node.dependenciesByVersion = new Map(Object.entries(node.dependenciesByVersion)));
-                const importedVersionsByNodeKey = new Map();
-                const sourceToTargetVersionsByNodeKey = new Map();
-                for (const node of manifestNodes) {
-                    for (const version of node.dependenciesByVersion.keys()) {
-                        yield this.checkNodeForCircularDependency(node, version, manifestNodes, []);
-                    }
-                }
-                const customSpacesMap = new Map();
-                spaceMappings.forEach(spaceMap => {
-                    const packageAndSpaceid = spaceMap.split(":");
-                    customSpacesMap.set(packageAndSpaceid[0], packageAndSpaceid[1]);
-                });
-                const draftIdsByPackageKeyAndVersion = new Map();
-                for (const node of manifestNodes) {
-                    yield this.importPackage(node, manifestNodes, sourceToTargetVersionsByNodeKey, customSpacesMap, dmTargetIdsBySourceIds, importedVersionsByNodeKey, draftIdsByPackageKeyAndVersion, importedFilePath, excludeActionFlows);
-                }
-            });
-        }
-        checkNodeForCircularDependency(node, version, manifestNodes, iteratedNodeAndVersions) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const dependencies = node.dependenciesByVersion.get(version);
-                if (iteratedNodeAndVersions.includes(`${node.packageKey}_${version}`)) {
-                    throw new Error("Circular dependency detected!");
-                }
-                iteratedNodeAndVersions.push(`${node.packageKey}_${version}`);
-                for (const dependency of dependencies) {
-                    const manifestNodeOfDependency = manifestNodes.find(manifestNode => manifestNode.packageKey === dependency.key);
-                    yield this.checkNodeForCircularDependency(manifestNodeOfDependency, dependency.version, manifestNodes, iteratedNodeAndVersions);
-                }
-            });
-        }
-        importPackage(packageToImport, manifestNodes, sourceToTargetVersionsByNodeKey, spaceMappings, dmTargetIdsBySourceIds, importedVersionsByNodeKey, draftIdsByPackageKeyAndVersion, importedFilePath, excludeActionFlows) {
-            var _a;
-            return __awaiter(this, void 0, void 0, function* () {
-                const importedPackageVersion = (_a = importedVersionsByNodeKey.get(packageToImport.packageKey)) !== null && _a !== void 0 ? _a : [];
-                const versionsOfPackage = [...packageToImport.dependenciesByVersion.keys()].sort((k1, k2) => {
-                    const version1 = new semantic_versioning_1.SemanticVersioning(k1);
-                    const version2 = new semantic_versioning_1.SemanticVersioning(k1);
-                    return version1.isGreaterThan(version2) ? 1 : -1;
-                }).filter(version => !importedPackageVersion.includes(version));
-                for (const version of versionsOfPackage) {
-                    try {
-                        yield this.importPackageVersion(packageToImport, manifestNodes, sourceToTargetVersionsByNodeKey, spaceMappings, dmTargetIdsBySourceIds, importedVersionsByNodeKey, draftIdsByPackageKeyAndVersion, importedFilePath, version, excludeActionFlows);
-                    }
-                    catch (e) {
-                        logger_1.logger.error(`Problem import package with key: ${packageToImport.packageKey} ${version} ${e}`);
-                    }
-                }
-            });
-        }
-        importPackageVersion(packageToImport, manifestNodes, sourceToTargetVersionsByNodeKey, spaceMappings, dmTargetIdsBySourceIds, importedVersionsByNodeKey, draftIdsByPackageKeyAndVersion, importedFilePath, versionOfPackageBeingImported, excludeActionFlows) {
-            var _a, _b;
-            return __awaiter(this, void 0, void 0, function* () {
-                if (packageToImport.dependenciesByVersion.get(versionOfPackageBeingImported).length) {
-                    const dependenciesOfPackageVersion = packageToImport.dependenciesByVersion.get(versionOfPackageBeingImported);
-                    yield this.importDependencyPackages(dependenciesOfPackageVersion, manifestNodes, sourceToTargetVersionsByNodeKey, spaceMappings, dmTargetIdsBySourceIds, importedVersionsByNodeKey, draftIdsByPackageKeyAndVersion, importedFilePath, excludeActionFlows);
-                }
-                if (this.checkIfPackageVersionHasBeenImported(packageToImport.packageKey, versionOfPackageBeingImported, importedVersionsByNodeKey)) {
-                    return;
-                }
-                const targetSpace = yield this.getTargetSpaceForExportedPackage(packageToImport, spaceMappings);
-                let nodeInTargetTeam = yield this.nodeApi.findOneByKeyAndRootNodeKey(packageToImport.packageKey, packageToImport.packageKey);
-                const pathToZipFile = path.resolve(importedFilePath, packageToImport.packageKey + "_" + versionOfPackageBeingImported + ".zip");
-                const packageZip = this.createBodyForImport(pathToZipFile);
-                yield this.packageApi.importPackage(packageZip, targetSpace.id, !!nodeInTargetTeam, excludeActionFlows);
-                if (nodeInTargetTeam) {
-                    yield this.packageApi.movePackageToSpace(nodeInTargetTeam.id, targetSpace.id);
-                }
-                nodeInTargetTeam = yield this.nodeApi.findOneByKeyAndRootNodeKey(packageToImport.packageKey, packageToImport.packageKey);
-                if (this.isLatestVersion(versionOfPackageBeingImported, [...packageToImport.dependenciesByVersion.keys()])) {
-                    if (dmTargetIdsBySourceIds.size > 0) {
-                        const variableAssignments = packageToImport.variables
-                            .filter(variable => variable.type === package_manager_interfaces_1.PackageManagerVariableType.DATA_MODEL).map(variable => {
-                            var _a;
-                            variable.value = dmTargetIdsBySourceIds.get((_a = variable.value) === null || _a === void 0 ? void 0 : _a.toString());
-                            return variable;
-                        });
-                        yield this.variableService.assignVariableValues(nodeInTargetTeam.key, variableAssignments);
-                    }
-                    else {
-                        yield this.variableService.assignVariableValues(nodeInTargetTeam.key, packageToImport.variables);
-                    }
-                }
-                draftIdsByPackageKeyAndVersion.set(`${nodeInTargetTeam.key}_${versionOfPackageBeingImported}`, nodeInTargetTeam.workingDraftId);
-                yield this.updateDependencyVersions(packageToImport, versionOfPackageBeingImported, sourceToTargetVersionsByNodeKey, draftIdsByPackageKeyAndVersion);
-                yield this.publishPackage(packageToImport);
-                const packageVersionInTargetTeam = yield this.packageApi.findActiveVersionById(nodeInTargetTeam.id);
-                const mappedVersions = (_a = sourceToTargetVersionsByNodeKey.get(packageToImport.packageKey)) !== null && _a !== void 0 ? _a : new Map();
-                mappedVersions.set(versionOfPackageBeingImported, packageVersionInTargetTeam.version);
-                sourceToTargetVersionsByNodeKey.set(packageToImport.packageKey, mappedVersions);
-                const importedVersionsOfPackage = (_b = importedVersionsByNodeKey.get(packageToImport.packageKey)) !== null && _b !== void 0 ? _b : [];
-                importedVersionsOfPackage.push(versionOfPackageBeingImported);
-                importedVersionsByNodeKey.set(packageToImport.packageKey, importedVersionsOfPackage);
-                const mappedVersion = sourceToTargetVersionsByNodeKey.get(packageToImport.packageKey).get(versionOfPackageBeingImported);
-                logger_1.logger.info(`Imported package with key: ${packageToImport.packageKey} ${versionOfPackageBeingImported} successfully. New version: ${mappedVersion}`);
-            });
-        }
-        isLatestVersion(packageVersion, allPackageVersions) {
-            let isLatestVersion = true;
-            for (const version of allPackageVersions) {
-                const version1 = new semantic_versioning_1.SemanticVersioning(packageVersion);
-                const version2 = new semantic_versioning_1.SemanticVersioning(version);
-                if (version2.isGreaterThan(version1)) {
-                    isLatestVersion = false;
-                    break;
-                }
-            }
-            return isLatestVersion;
-        }
-        importDependencyPackages(dependenciesToImport, manifestNodes, sourceToTargetVersionsByNodeKey, spaceMappings, dmTargetIdsBySourceIds, importedVersionsByNodeKey, draftIdsByPackageKeyAndVersion, importedFilePath, excludeActionFlows) {
-            return __awaiter(this, void 0, void 0, function* () {
-                for (const dependency of dependenciesToImport) {
-                    if (this.checkIfPackageVersionHasBeenImported(dependency.key, dependency.version, importedVersionsByNodeKey)) {
-                        continue;
-                    }
-                    const dependentPackage = manifestNodes.find(node => node.packageKey === dependency.key);
-                    yield this.importPackage(dependentPackage, manifestNodes, sourceToTargetVersionsByNodeKey, spaceMappings, dmTargetIdsBySourceIds, importedVersionsByNodeKey, draftIdsByPackageKeyAndVersion, importedFilePath, excludeActionFlows);
-                }
-            });
-        }
-        checkIfPackageVersionHasBeenImported(packageKey, version, importedVersions) {
-            var _a;
-            const importedPackages = (_a = importedVersions.get(packageKey)) !== null && _a !== void 0 ? _a : [];
-            return importedPackages.includes(version);
-        }
-        createBodyForImport(filename) {
-            const formData = new FormData();
-            formData.append("package", fs.createReadStream(filename, { encoding: null }));
-            return formData;
-        }
-        getTargetSpaceForExportedPackage(packageToImport, spaceMappings) {
-            return __awaiter(this, void 0, void 0, function* () {
-                let targetSpace;
-                const allSpaces = yield this.spaceService.refreshAndGetAllSpaces();
-                if (spaceMappings.has(packageToImport.packageKey)) {
-                    const customSpaceId = spaceMappings.get(packageToImport.packageKey);
-                    const customSpace = allSpaces.find(space => space.id === customSpaceId);
-                    if (!customSpace) {
-                        throw Error("Provided space id does not exist");
-                    }
-                    targetSpace = customSpace;
-                }
-                else {
-                    targetSpace = allSpaces.find(space => space.name === packageToImport.space.spaceName);
-                    if (!targetSpace) {
-                        targetSpace = yield this.spaceService.createSpace(packageToImport.space.spaceName, packageToImport.space.spaceIcon);
-                    }
-                }
-                return targetSpace;
-            });
-        }
-        updateDependencyVersions(node, versionOfPackage, sourceToTargetVersionsByNodeKey, draftIdsByPackageKeyAndVersion) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const createdNode = yield this.nodeApi.findOneByKeyAndRootNodeKey(node.packageKey, node.packageKey);
-                const newDependencies = [];
-                for (const dependency of [...node.dependenciesByVersion.get(versionOfPackage)]) {
-                    const nodeInTargetTeam = yield this.nodeApi.findOneByKeyAndRootNodeKey(dependency.key, dependency.key);
-                    const draftIdOfVersionedDependency = draftIdsByPackageKeyAndVersion.get(`${dependency.key}_${dependency.version}`);
-                    dependency.version = sourceToTargetVersionsByNodeKey.get(dependency.key).get(dependency.version);
-                    dependency.updateAvailable = dependency.updateAvailable;
-                    dependency.id = nodeInTargetTeam.rootNodeId;
-                    dependency.rootNodeId = createdNode.rootNodeId;
-                    dependency.draftId = draftIdOfVersionedDependency;
-                    newDependencies.push(dependency);
-                    yield this.packageDependenciesApi.deleteDependency(createdNode.id, dependency.key);
-                }
-                if (newDependencies.length) {
-                    yield this.packageDependenciesApi.createDependencies(createdNode.id, newDependencies);
-                }
-            });
-        }
-        publishPackage(packageToImport) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const nodeInTargetTeam = yield this.nodeApi.findOneByKeyAndRootNodeKey(packageToImport.packageKey, packageToImport.packageKey);
-                const nextVersion = yield this.packageApi.findNextVersion(nodeInTargetTeam.id);
-                yield this.packageApi.publishPackage({
-                    packageKey: packageToImport.packageKey,
-                    version: nextVersion.version,
-                    publishMessage: "Published package after import",
-                    nodeIdsToExclude: []
-                });
-            });
-        }
-        batchExportPackages(packageKeys, includeDependencies, excludeActionFlows) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const allPackages = yield this.packageApi.findAllPackages();
-                let nodesListToExport = allPackages.filter(node => packageKeys.includes(node.key));
-                const versionsByNodeKey = new Map();
-                const allPackageKeys = allPackages.map(p => p.key);
-                for (const packageKey of packageKeys) {
-                    if (!allPackageKeys.includes(packageKey)) {
-                        throw new Error(`Package ${packageKey} does not exist.`);
-                    }
-                }
-                nodesListToExport = yield this.getNodesWithActiveVersion(nodesListToExport);
-                if (includeDependencies) {
-                    const dependencyPackages = yield this.getDependencyPackages(nodesListToExport, [], allPackages, [], versionsByNodeKey);
-                    nodesListToExport.push(...dependencyPackages);
-                }
-                const packagesWithVariableAssignments = yield this.variableService.getVariableAssignmentsForNodes();
-                nodesListToExport.forEach(node => {
-                    var _a;
-                    node.variables = (_a = packagesWithVariableAssignments.find(nodeWithVariablesAssignment => nodeWithVariablesAssignment.key === node.key)) === null || _a === void 0 ? void 0 : _a.variableAssignments;
-                });
-                const packagesWithDataModelVariables = packagesWithVariableAssignments.map(packageWithVariablesAssignments => {
-                    packageWithVariablesAssignments.variableAssignments = packageWithVariablesAssignments.variableAssignments.filter(variable => variable.value && variable.type === package_manager_interfaces_1.PackageManagerVariableType.DATA_MODEL);
-                    return packageWithVariablesAssignments;
-                });
-                const dataModelDetailsByNode = yield this.dataModelService.getDataModelDetailsForPackages(packagesWithDataModelVariables);
-                nodesListToExport.forEach(node => {
-                    node.datamodels = dataModelDetailsByNode.get(node.key);
-                });
-                nodesListToExport = yield this.spaceService.getParentSpaces(nodesListToExport);
-                yield this.exportToZip(nodesListToExport, versionsByNodeKey, excludeActionFlows);
-            });
-        }
         getNodesWithActiveVersion(nodes) {
             return __awaiter(this, void 0, void 0, function* () {
                 const activeVersionsOfPackage = yield this.packageApi.findActiveVersionByIds(nodes.map(node => node.id));
@@ -340,114 +87,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 return yield this.packageDependenciesApi.findPackageDependenciesByIds(draftIdByNodeId);
             });
         }
-        getDependencyPackages(nodesToResolve, dependencyPackages, allPackages, resolvedDependencies, versionsByNodeKey) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const draftIdByNodeId = new Map();
-                nodesToResolve.forEach(node => draftIdByNodeId.set(node.activatedDraftId, node.id));
-                const dependenciesByPackageDraftIds = yield this.getPackagesWithDependencies(draftIdByNodeId);
-                const nodesWithDependencies = nodesToResolve.map(nodeToExport => {
-                    var _a;
-                    nodeToExport.dependencies = (_a = dependenciesByPackageDraftIds[nodeToExport.activatedDraftId]) !== null && _a !== void 0 ? _a : [];
-                    return nodeToExport;
-                });
-                for (const node of nodesWithDependencies) {
-                    node.dependencies = node.dependencies.filter(dependency => !(dependency.external || dependency.deleted));
-                    node.dependencies.forEach(dependency => {
-                        var _a;
-                        const dependencyVersions = (_a = versionsByNodeKey.get(dependency.key)) !== null && _a !== void 0 ? _a : [];
-                        if (!dependencyVersions.includes(dependency.version)) {
-                            dependencyVersions.push(dependency.version);
-                            versionsByNodeKey.set(dependency.key, dependencyVersions);
-                        }
-                    });
-                    const nodesToGetKeys = node.dependencies.filter(dependency => {
-                        return !this.nodeHasBeenResolvedBefore(resolvedDependencies, dependency.key, dependency.version);
-                    }).map(iteratedNode => iteratedNode.key);
-                    if (nodesToGetKeys.length > 0) {
-                        const dependencyPackagesOfNode = allPackages.filter(packageNode => nodesToGetKeys.includes(packageNode.key)).map(dependency => {
-                            const versionedDep = node.dependencies.find(dep => dependency.key === dep.key);
-                            return Object.assign(Object.assign({}, dependency), { version: {
-                                    version: versionedDep.version
-                                }, activatedDraftId: versionedDep.draftId });
-                        });
-                        dependencyPackages.push(...dependencyPackagesOfNode);
-                        yield this.getDependencyPackages(dependencyPackagesOfNode, dependencyPackages, allPackages, resolvedDependencies, versionsByNodeKey);
-                    }
-                }
-                return dependencyPackages;
-            });
-        }
-        nodeHasBeenResolvedBefore(nodePath, nodeKey, version) {
-            return nodePath.includes(nodeKey + ":" + version);
-        }
         exportListOfPackages(nodes, fieldsToInclude) {
             const filename = (0, uuid_1.v4)() + ".json";
             file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(nodes, fieldsToInclude), filename);
             logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + filename);
         }
-        exportPackagesAndAssets(nodes, excludeActionFlows) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const zips = [];
-                for (const rootPackage of nodes) {
-                    const exportedPackage = yield this.packageApi.exportPackage(rootPackage.key, rootPackage.version.version, excludeActionFlows);
-                    zips.push({
-                        data: exportedPackage,
-                        packageKey: rootPackage.key,
-                        version: rootPackage.version.version
-                    });
-                }
-                return zips;
-            });
-        }
-        exportToZip(nodes, versionsByNodeKey, excludeActionFlows) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const manifestNodes = this.exportManifestOfPackages(nodes, versionsByNodeKey);
-                const packageZips = yield this.exportPackagesAndAssets(nodes, excludeActionFlows);
-                const zip = new AdmZip();
-                zip.addFile("manifest.yml", Buffer.from((0, yaml_2.stringify)(manifestNodes), "utf8"));
-                for (const packageZip of packageZips) {
-                    zip.addFile(`${packageZip.packageKey}_${packageZip.version}.zip`, packageZip.data);
-                }
-                const fileName = "export_" + (0, uuid_1.v4)() + ".zip";
-                zip.writeZip(fileName);
-                logger_1.logger.info(this.fileDownloadedMessage + fileName);
-            });
-        }
-        exportManifestOfPackages(nodes, dependencyVersionsByNodeKey) {
-            const manifestNodesByPackageKey = new Map();
-            nodes.forEach(node => {
-                var _a, _b, _c, _d;
-                const manifestNode = (_a = manifestNodesByPackageKey.get(node.key)) !== null && _a !== void 0 ? _a : {};
-                manifestNode.packageKey = node.key;
-                manifestNode.packageId = node.id;
-                manifestNode.space = {
-                    spaceName: node.space.name,
-                    spaceIcon: node.space.iconReference
-                };
-                manifestNode.variables = (_b = node.variables) === null || _b === void 0 ? void 0 : _b.map(variable => {
-                    var _a;
-                    if (variable.type === package_manager_interfaces_1.PackageManagerVariableType.DATA_MODEL) {
-                        // @ts-ignore
-                        const dataModel = (_a = node.datamodels) === null || _a === void 0 ? void 0 : _a.find(dataModel => dataModel.dataModelId === variable.value);
-                        return {
-                            key: variable.key,
-                            type: variable.type,
-                            value: variable.value,
-                            dataModelName: dataModel === null || dataModel === void 0 ? void 0 : dataModel.name,
-                        };
-                    }
-                    return variable;
-                });
-                manifestNode.dependenciesByVersion = (_c = manifestNode.dependenciesByVersion) !== null && _c !== void 0 ? _c : new Map();
-                manifestNode.dependenciesByVersion.set(node.version.version, (_d = node.dependencies) !== null && _d !== void 0 ? _d : []);
-                manifestNodesByPackageKey.set(node.key, manifestNode);
-            });
-            return [...manifestNodesByPackageKey.values()];
-        }
-        readManifestFile(importedFileName) {
-            const manifest = (0, yaml_1.parse)(fs.readFileSync(path.resolve(importedFileName + "/manifest.yml"), { encoding: "utf-8" }));
-            return Promise.all(manifest);
-        }
     }
     exports.PackageService = PackageService;
 });

package/core/profile/profile.service.js

@@ -30,8 +30,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     const homedir = os.homedir();
     // use 5 seconds buffer to avoid rare cases when accessToken is just about to expire before the command is sent
     const expiryBuffer = 5000;
-    const deviceCodeScopes = ["studio", "package-manager", "integration.data-pools", "action-engine.projects"];
-    const clientCredentialsScopes = ["studio", "integration.data-pools", "action-engine.projects", "package-manager"];
+    /** All OAuth scopes; used for both device code and client credentials. */
+    const OAUTH_SCOPES = ["studio", "package-manager", "integration.data-pools", "action-engine.projects"];
+    /** Device code fallback: try without action-engine.projects if all 4 scopes fail. */
+    const DEVICE_CODE_SCOPES_WITHOUT_ACTION_ENGINE = ["studio", "package-manager", "integration.data-pools"];
     class ProfileService {
         constructor() {
             this.profileContainerPath = path.resolve(homedir, ".celonis-content-cli-profiles");
@@ -40,18 +42,23 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         findProfile(profileName) {
             return __awaiter(this, void 0, void 0, function* () {
                 return new Promise((resolve, reject) => {
-                    this.mapCelonisEnvProfile();
-                    this.checkIfMissingProfile(profileName, reject);
                     try {
-                        if (process.env.TEAM_URL && process.env.API_TOKEN) {
-                            resolve(this.buildProfileFromEnvVariables());
-                        }
-                        else {
+                        if (!this.checkIfMissingProfile(profileName)) {
                             const file = fs.readFileSync(path.resolve(this.profileContainerPath, this.constructProfileFileName(profileName)), { encoding: "utf-8" });
                             const profile = JSON.parse(file);
                             this.refreshProfile(profile)
                                 .then(() => resolve(profile));
                         }
+                        else if (process.env.TEAM_URL && process.env.API_TOKEN) {
+                            resolve(this.buildProfileFromEnvVariables());
+                        }
+                        else if (process.env.CELONIS_URL && process.env.CELONIS_API_TOKEN) {
+                            this.mapCelonisEnvProfile();
+                            resolve(this.buildProfileFromEnvVariables());
+                        }
+                        else {
+                            reject(`The profile ${profileName} couldn't be resolved due to missing environment variables.`);
+                        }
                     }
                     catch (e) {
                         reject(`The profile ${profileName} couldn't be resolved.`);
@@ -160,65 +167,56 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                         }
                         break;
                     case profile_interface_1.ProfileType.DEVICE_CODE:
-                        try {
-                            const deviceCodeIssuer = yield openid_client_1.Issuer.discover(profile.team);
-                            const deviceCodeOAuthClient = new deviceCodeIssuer.Client({
-                                client_id: "content-cli",
-                                token_endpoint_auth_method: "none",
-                            });
-                            const deviceCodeHandle = yield deviceCodeOAuthClient.deviceAuthorization({
-                                scope: deviceCodeScopes.join(" ")
-                            });
-                            logger_1.logger.info(`Continue authorization here: ${deviceCodeHandle.verification_uri_complete}`);
-                            const deviceCodeTokenSet = yield deviceCodeHandle.poll();
-                            profile.apiToken = deviceCodeTokenSet.access_token;
-                            profile.refreshToken = deviceCodeTokenSet.refresh_token;
-                            profile.expiresAt = deviceCodeTokenSet.expires_at;
+                        const deviceCodeIssuer = yield openid_client_1.Issuer.discover(profile.team);
+                        const deviceCodeOAuthClient = new deviceCodeIssuer.Client({
+                            client_id: "content-cli",
+                            token_endpoint_auth_method: "none",
+                        });
+                        const deviceCodeScopeAttempts = [OAUTH_SCOPES, DEVICE_CODE_SCOPES_WITHOUT_ACTION_ENGINE];
+                        let deviceCodeSuccess = false;
+                        for (const scopeList of deviceCodeScopeAttempts) {
+                            try {
+                                const deviceCodeHandle = yield deviceCodeOAuthClient.deviceAuthorization({
+                                    scope: scopeList.join(" "),
+                                });
+                                logger_1.logger.info(`Continue authorization here: ${deviceCodeHandle.verification_uri_complete}`);
+                                const deviceCodeTokenSet = yield deviceCodeHandle.poll();
+                                profile.apiToken = deviceCodeTokenSet.access_token;
+                                profile.refreshToken = deviceCodeTokenSet.refresh_token;
+                                profile.expiresAt = deviceCodeTokenSet.expires_at;
+                                deviceCodeSuccess = true;
+                                break;
+                            }
+                            catch (err) {
+                                // This scope set failed; try next or fail below
+                            }
                         }
-                        catch (err) {
-                            logger_1.logger.error(new logger_1.FatalError("The provided team is wrong."));
-                            logger_1.logger.error(err);
+                        if (!deviceCodeSuccess) {
+                            throw new logger_1.FatalError("Device code authorization failed. The provided team or requested scopes may be invalid.");
                         }
                         break;
                     case profile_interface_1.ProfileType.CLIENT_CREDENTIALS:
                         const clientCredentialsIssuer = yield openid_client_1.Issuer.discover(profile.team);
-                        try {
-                            // try with client secret basic
-                            const clientCredentialsOAuthClient = new clientCredentialsIssuer.Client({
-                                client_id: profile.clientId,
-                                client_secret: profile.clientSecret,
-                                token_endpoint_auth_method: profile_interface_1.ClientAuthenticationMethod.CLIENT_SECRET_BASIC,
-                            });
-                            const clientCredentialsTokenSet = yield clientCredentialsOAuthClient.grant({
-                                grant_type: "client_credentials",
-                                scope: clientCredentialsScopes.join(" ")
-                            });
+                        const basicResult = yield this.tryClientCredentialsGrant(clientCredentialsIssuer, profile, profile_interface_1.ClientAuthenticationMethod.CLIENT_SECRET_BASIC);
+                        if (basicResult) {
                             profile.clientAuthenticationMethod = profile_interface_1.ClientAuthenticationMethod.CLIENT_SECRET_BASIC;
-                            profile.apiToken = clientCredentialsTokenSet.access_token;
-                            profile.expiresAt = clientCredentialsTokenSet.expires_at;
+                            profile.apiToken = basicResult.tokenSet.access_token;
+                            profile.expiresAt = basicResult.tokenSet.expires_at;
+                            profile.scopes = basicResult.scopes;
                         }
-                        catch (e) {
-                            try {
-                                // try with client secret post
-                                const clientCredentialsOAuthClient = new clientCredentialsIssuer.Client({
-                                    client_id: profile.clientId,
-                                    client_secret: profile.clientSecret,
-                                    token_endpoint_auth_method: profile_interface_1.ClientAuthenticationMethod.CLIENT_SECRET_POST,
-                                });
-                                const clientCredentialsTokenSet = yield clientCredentialsOAuthClient.grant({
-                                    grant_type: "client_credentials",
-                                    scope: clientCredentialsScopes.join(" ")
-                                });
+                        else {
+                            const postResult = yield this.tryClientCredentialsGrant(clientCredentialsIssuer, profile, profile_interface_1.ClientAuthenticationMethod.CLIENT_SECRET_POST);
+                            if (postResult) {
                                 profile.clientAuthenticationMethod = profile_interface_1.ClientAuthenticationMethod.CLIENT_SECRET_POST;
-                                profile.apiToken = clientCredentialsTokenSet.access_token;
-                                profile.expiresAt = clientCredentialsTokenSet.expires_at;
+                                profile.apiToken = postResult.tokenSet.access_token;
+                                profile.expiresAt = postResult.tokenSet.expires_at;
+                                profile.scopes = postResult.scopes;
                             }
-                            catch (err) {
-                                logger_1.logger.error(new logger_1.FatalError("The OAuth client configuration is incorrect. " +
-                                    "Check the id, secret and scopes for correctness."));
+                            else {
+                                throw new logger_1.FatalError("The OAuth client configuration is incorrect. " +
+                                    "Check the id, secret and allowed scopes for this client.");
                             }
                         }
-                        profile.scopes = [...clientCredentialsScopes];
                         break;
                     default:
                         logger_1.logger.error(new logger_1.FatalError("Unsupported profile type"));
@@ -307,16 +305,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 });
             });
         }
-        checkIfMissingProfile(profileName, reject) {
-            if (!profileName && (!process.env.TEAM_URL || !process.env.API_TOKEN)) {
-                reject("Profile not found");
+        checkIfMissingProfile(profileName) {
+            if (!profileName) {
+                return true;
             }
         }
         mapCelonisEnvProfile() {
-            if (!process.env.CELONIS_URL) {
-                return;
+            let celonisUrl = process.env.CELONIS_URL;
+            if (!celonisUrl.startsWith("http://") && !celonisUrl.startsWith("https://")) {
+                celonisUrl = `https://${celonisUrl}`;
             }
-            process.env.TEAM_URL = process.env.CELONIS_URL;
+            process.env.TEAM_URL = celonisUrl;
             if (process.env.CELONIS_API_TOKEN) {
                 process.env.API_TOKEN = process.env.CELONIS_API_TOKEN;
             }
@@ -324,6 +323,75 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 delete process.env.API_TOKEN;
             }
         }
+        /**
+         * Returns all non-empty combinations of scopes, ordered by size descending (4, then 3, 2, 1).
+         * Order within a combination does not matter; each set is tried once.
+         */
+        getScopeCombinationsOrderedBySize(scopes) {
+            function combinations(arr, k) {
+                if (k === 0)
+                    return [[]];
+                if (k > arr.length)
+                    return [];
+                const result = [];
+                for (let i = 0; i <= arr.length - k; i++) {
+                    const rest = combinations(arr.slice(i + 1), k - 1);
+                    rest.forEach(r => result.push([arr[i], ...r]));
+                }
+                return result;
+            }
+            return [
+                ...combinations(scopes, 4),
+                ...combinations(scopes, 3),
+                ...combinations(scopes, 2),
+                ...combinations(scopes, 1),
+            ];
+        }
+        /**
+         * Tries to obtain a client_credentials token. First tries with all scopes (including
+         * action-engine.projects); if no token is returned, tries again without action-engine.projects.
+         * Returns { tokenSet, scopes } or null if no grant succeeded.
+         */
+        tryClientCredentialsGrant(issuer, profile, tokenEndpointAuthMethod) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const Client = issuer.Client;
+                const client = new Client({
+                    client_id: profile.clientId,
+                    client_secret: profile.clientSecret,
+                    token_endpoint_auth_method: tokenEndpointAuthMethod,
+                });
+                const scopeAttempts = this.getScopeCombinationsOrderedBySize(OAUTH_SCOPES);
+                for (const scopeList of scopeAttempts) {
+                    try {
+                        const tokenSet = yield client.grant({
+                            grant_type: "client_credentials",
+                            scope: scopeList.join(" "),
+                        });
+                        if (tokenSet && tokenSet.access_token) {
+                            const scopes = this.extractScopesFromTokenSet(tokenSet, scopeList);
+                            return { tokenSet, scopes };
+                        }
+                    }
+                    catch (_e) {
+                        // This scope set failed (e.g. invalid_scope); try next
+                    }
+                }
+                return null;
+            });
+        }
+        /**
+         * Extracts granted scopes from the token response (OAuth 2.0 scope parameter).
+         * Used at profile creation so we store the scopes the server actually granted for this client.
+         */
+        extractScopesFromTokenSet(tokenSet, fallbackScopes) {
+            if (tokenSet.scope && typeof tokenSet.scope === "string") {
+                const scopes = tokenSet.scope.trim().split(/\s+/).filter(Boolean);
+                if (scopes.length > 0) {
+                    return scopes;
+                }
+            }
+            return [...fallbackScopes];
+        }
     }
     exports.ProfileService = ProfileService;
     exports.profileService = new ProfileService();

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

@@ -8,6 +8,7 @@ export declare class BatchImportExportApi {
     findAllActivePackages(flavors: string[], withDependencies?: boolean): Promise<PackageExportTransport[]>;
     findActivePackagesByVariableValue(flavors: string[], variableValue: string, variableType: string): Promise<PackageExportTransport[]>;
     findActivePackagesByKeys(packageKeys: string[], withDependencies?: boolean): Promise<PackageExportTransport[]>;
+    findPackagesByKeysAndVersion(packageKeysWithVersion: string[], withDependencies?: boolean): Promise<PackageExportTransport[]>;
     exportPackages(packageKeys: string[], withDependencies: boolean): Promise<Buffer>;
     exportPackagesByVersions(packageKeysWithVersion: string[], withDependencies: boolean): Promise<Buffer>;
     batchExportPackagesMetadata(packageKeys: string[]): Promise<PackageMetadataExportTransport[]>;

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

@@ -6,7 +6,8 @@ export declare class BatchImportExportService {
     private gitService;
     constructor(context: Context);
     listActivePackages(flavors: string[]): Promise<void>;
-    findAndExportListOfActivePackages(flavors: string[], packageKeys: string[], withDependencies: boolean): Promise<void>;
+    findAndExportListOfPackages(flavors: string[], packageKeys: string[], keysByVersion: string[], withDependencies: boolean): Promise<void>;
+    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>;

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

@@ -4,7 +4,7 @@ export declare class ConfigCommandService {
     private variableService;
     private diffService;
     constructor(context: Context);
-    listActivePackages(jsonResponse: boolean, flavors: string[], withDependencies: boolean, packageKeys: string[], variableValue: string, variableType: string): Promise<void>;
+    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>;
     batchExportPackages(packageKeys: string[], packageKeysByVersion: string[], withDependencies: boolean, gitBranch: string, unzip: boolean): Promise<void>;
     batchExportPackagesMetadata(packageKeys: string[], jsonResponse: boolean): Promise<void>;

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

@@ -5,7 +5,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 listActivePackages;
+    private listPackages;
     private batchExportPackages;
     private batchExportPackagesMetadata;
     private getPackageVersion;

package/lib/commands/studio/command-service/package-command.service.d.ts

@@ -8,6 +8,4 @@ export declare class PackageCommandService {
     pushPackage(spaceKey: string, fileName: string, newKey: string, overwrite: boolean): Promise<void>;
     pushPackages(spaceKey: string): Promise<void>;
     listPackages(jsonResponse: boolean, includeDependencies: boolean, packageKeys: string[]): Promise<void>;
-    batchExportPackages(packageKeys: string[], includeDependencies: boolean, excludeActionFlows?: boolean): Promise<void>;
-    batchImportPackages(spaceMappings: string[], dataModelMappingsFilePath: string, exportedPackagesFile: string, overwrite: boolean, excludeActionFlows?: boolean): Promise<void>;
 }

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

@@ -5,8 +5,6 @@ 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 batchExportPackages;
-    private batchImportPackages;
     private listPackages;
     private listSpaces;
     private listAssets;

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

@@ -1,37 +1,16 @@
 import { Context } from "../../../core/command/cli-context";
 import { PackageDependencyTransport } from "../interfaces/package-manager.interfaces";
 import { BatchExportNodeTransport } from "../interfaces/batch-export-node.interfaces";
-import { ManifestNodeTransport } from "../interfaces/manifest.interface";
 export declare class PackageService {
     protected readonly fileDownloadedMessage = "File downloaded successfully. New filename: ";
     private packageApi;
-    private nodeApi;
     private packageDependenciesApi;
     private dataModelService;
     private variableService;
-    private spaceService;
     constructor(context: Context);
     listPackages(): Promise<void>;
     findAndExportListOfAllPackages(includeDependencies: boolean, packageKeys: string[]): Promise<void>;
-    batchImportPackages(spaceMappings: string[], dataModelMappingsFilePath: string, exportedPackagesFile: string, overwrite: boolean, excludeActionFlows: boolean): Promise<void>;
-    private checkNodeForCircularDependency;
-    private importPackage;
-    private importPackageVersion;
-    private isLatestVersion;
-    private importDependencyPackages;
-    private checkIfPackageVersionHasBeenImported;
-    private createBodyForImport;
-    private getTargetSpaceForExportedPackage;
-    private updateDependencyVersions;
-    publishPackage(packageToImport: ManifestNodeTransport): Promise<void>;
-    batchExportPackages(packageKeys: string[], includeDependencies: boolean, excludeActionFlows?: boolean): Promise<void>;
     getNodesWithActiveVersion(nodes: BatchExportNodeTransport[]): Promise<BatchExportNodeTransport[]>;
     getPackagesWithDependencies(draftIdByNodeId: Map<string, string>): Promise<Map<string, PackageDependencyTransport[]>>;
-    private getDependencyPackages;
-    private nodeHasBeenResolvedBefore;
     private exportListOfPackages;
-    private exportPackagesAndAssets;
-    private exportToZip;
-    private exportManifestOfPackages;
-    private readManifestFile;
 }

package/lib/core/profile/profile.service.d.ts

@@ -23,5 +23,21 @@ export declare class ProfileService {
     private tryKeyAuthentication;
     private checkIfMissingProfile;
     private mapCelonisEnvProfile;
+    /**
+     * Returns all non-empty combinations of scopes, ordered by size descending (4, then 3, 2, 1).
+     * Order within a combination does not matter; each set is tried once.
+     */
+    private getScopeCombinationsOrderedBySize;
+    /**
+     * Tries to obtain a client_credentials token. First tries with all scopes (including
+     * action-engine.projects); if no token is returned, tries again without action-engine.projects.
+     * Returns { tokenSet, scopes } or null if no grant succeeded.
+     */
+    private tryClientCredentialsGrant;
+    /**
+     * Extracts granted scopes from the token response (OAuth 2.0 scope parameter).
+     * Used at profile creation so we store the scopes the server actually granted for this client.
+     */
+    private extractScopesFromTokenSet;
 }
 export declare const profileService: ProfileService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celonis/content-cli",
-  "version": "1.4.1",
+  "version": "1.6.0",
   "description": "CLI Tool to help manage content in Celonis Platform",
   "main": "content-cli.js",
   "bin": {
@@ -18,9 +18,9 @@
     "node": ">=18.20.5"
   },
   "dependencies": {
-    "@datadog/datadog-ci": "2.48.0",
     "adm-zip": "0.5.14",
-    "axios": "1.8.4",
+    "uuid": "9.0.1",
+    "axios": "1.13.5",
     "commander": "13.1.0",
     "form-data": "4.0.4",
     "openid-client": "5.6.1",