@celonis/content-cli 1.0.8 → 1.1.0

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

@@ -57,7 +57,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 });
             });
         }
-        exportPackages(packageKeys, withDependencies = false) {
+        exportPackages(packageKeys, withDependencies) {
             return __awaiter(this, void 0, void 0, function* () {
                 const queryParams = new URLSearchParams();
                 packageKeys.forEach(packageKey => queryParams.append("packageKeys", packageKey));
@@ -67,7 +67,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 });
             });
         }
-        exportPackagesByVersions(packageKeysWithVersion, withDependencies = false) {
+        exportPackagesByVersions(packageKeysWithVersion, withDependencies) {
             return __awaiter(this, void 0, void 0, function* () {
                 const queryParams = new URLSearchParams();
                 packageKeysWithVersion.forEach(packageKeyByVersion => queryParams.append("packageKeysWithVersion", packageKeyByVersion));

package/commands/configuration-management/batch-import-export.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", "form-data", "stream", "adm-zip", "./interfaces/batch-export-import.constants", "../../core/utils/file-service", "../../core/utils/logger", "../../core/utils/json", "../studio/api/package-api", "./api/batch-import-export-api", "./studio.service"], factory);
+        define(["require", "exports", "uuid", "form-data", "stream", "adm-zip", "./interfaces/batch-export-import.constants", "../../core/utils/file-service", "../../core/utils/logger", "../../core/utils/json", "../studio/api/package-api", "./api/batch-import-export-api", "./studio.service", "../../core/git-profile/git/git.service", "node:fs"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -30,11 +30,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     const package_api_1 = require("../studio/api/package-api");
     const batch_import_export_api_1 = require("./api/batch-import-export-api");
     const studio_service_1 = require("./studio.service");
+    const git_service_1 = require("../../core/git-profile/git/git.service");
+    const fs = require("node:fs");
     class BatchImportExportService {
         constructor(context) {
             this.batchImportExportApi = new batch_import_export_api_1.BatchImportExportApi(context);
             this.studioPackageApi = new package_api_1.PackageApi(context);
             this.studioService = new studio_service_1.StudioService(context);
+            this.gitService = new git_service_1.GitService(context);
         }
         listActivePackages(flavors) {
             return __awaiter(this, void 0, void 0, function* () {
@@ -57,7 +60,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 this.exportListOfPackages(packagesToExport);
             });
         }
-        batchExportPackages(packageKeys, packageKeysByVersion, withDependencies = false) {
+        batchExportPackages(packageKeys, packageKeysByVersion, withDependencies, gitBranch) {
             return __awaiter(this, void 0, void 0, function* () {
                 let exportedPackagesData;
                 if (packageKeys) {
@@ -86,10 +89,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                         }
                     }
                 });
-                const fileDownloadedMessage = "File downloaded successfully. New filename: ";
-                const filename = `export_${(0, uuid_1.v4)()}.zip`;
-                exportedPackagesZip.writeZip(filename);
-                logger_1.logger.info(fileDownloadedMessage + filename);
+                if (gitBranch) {
+                    const extractedDirectory = file_service_1.fileService.extractExportedZipWithNestedZips(exportedPackagesZip);
+                    yield this.gitService.pushToBranch(extractedDirectory, gitBranch);
+                    logger_1.logger.info("Successfully exported packages to branch: " + gitBranch);
+                }
+                else {
+                    const fileDownloadedMessage = "File downloaded successfully. New filename: ";
+                    const filename = `export_${(0, uuid_1.v4)()}.zip`;
+                    exportedPackagesZip.writeZip(filename);
+                    logger_1.logger.info(fileDownloadedMessage + filename);
+                }
             });
         }
         batchExportPackagesMetadata(packageKeys, jsonResponse) {
@@ -105,9 +115,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 }
             });
         }
-        batchImportPackages(file, overwrite) {
+        batchImportPackages(file, overwrite, gitBranch) {
             return __awaiter(this, void 0, void 0, function* () {
-                let configs = new AdmZip(file);
+                let fileToBeImported;
+                if (gitBranch) {
+                    fileToBeImported = yield this.gitService.pullFromBranch(gitBranch);
+                    fileToBeImported = file_service_1.fileService.zipDirectoryInBatchExportFormat(fileToBeImported);
+                }
+                else {
+                    fileToBeImported = file;
+                }
+                let configs = new AdmZip(fileToBeImported);
                 const studioManifests = this.parseEntryData(configs, batch_export_import_constants_1.BatchExportImportConstants.STUDIO_FILE_NAME);
                 const variablesManifests = this.parseEntryData(configs, batch_export_import_constants_1.BatchExportImportConstants.VARIABLES_FILE_NAME);
                 configs = yield this.studioService.mapSpaces(configs, studioManifests);
@@ -115,6 +133,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 const formData = this.buildBodyForImport(configs, variablesManifests);
                 const postPackageImportData = yield this.batchImportExportApi.importPackages(formData, overwrite);
                 yield this.studioService.processImportedPackages(configs, existingStudioPackages, studioManifests);
+                if (gitBranch) {
+                    fs.rmSync(fileToBeImported);
+                }
                 const reportFileName = "config_import_report_" + (0, uuid_1.v4)() + ".json";
                 file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(postPackageImportData), reportFileName);
                 logger_1.logger.info("Config import report file: " + reportFileName);

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

@@ -52,14 +52,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 }
             });
         }
-        batchExportPackages(packageKeys, packageKeysByVersion, withDependencies = false) {
-            return this.batchImportExportService.batchExportPackages(packageKeys, packageKeysByVersion, withDependencies);
+        batchExportPackages(packageKeys, packageKeysByVersion, withDependencies, gitBranch) {
+            return this.batchImportExportService.batchExportPackages(packageKeys, packageKeysByVersion, withDependencies, gitBranch);
         }
         batchExportPackagesMetadata(packageKeys, jsonResponse) {
             return this.batchImportExportService.batchExportPackagesMetadata(packageKeys, jsonResponse);
         }
-        batchImportPackages(file, overwrite) {
-            return this.batchImportExportService.batchImportPackages(file, overwrite);
+        batchImportPackages(file, overwrite, gitBranch) {
+            if (file && gitBranch) {
+                throw new Error("You cannot use both file and gitBranch options at the same time. Only one import source can be defined.");
+            }
+            if (!file && !gitBranch) {
+                throw new Error("You must provide either a file or a gitBranch option to import packages.");
+            }
+            return this.batchImportExportService.batchImportPackages(file, overwrite, gitBranch);
         }
         diffPackages(file, hasChanges, jsonResponse) {
             return this.diffService.diffPackages(file, hasChanges, jsonResponse);

package/commands/configuration-management/module.js

@@ -40,6 +40,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 .option("--packageKeys <packageKeys...>", "Keys of packages to export. Exports the latest deployed version only")
                 .option("--keysByVersion <keysByVersion...>", "Keys of packages to export by version")
                 .option("--withDependencies", "Include variables and dependencies", "")
+                .betaOption("--gitProfile <gitProfile>", "Git profile which you want to use for the Git operations")
+                .betaOption("--gitBranch <gitBranch>", "Git branch in which you want to push the exported file")
                 .action(this.batchExportPackages);
             const metadataCommand = configCommand.command("metadata")
                 .description("Commands related to package metadata");
@@ -52,7 +54,9 @@ 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")
-                .requiredOption("-f, --file <file>", "Exported packages file (relative path)")
+                .betaOption("--gitProfile <gitProfile>", "Git profile which you want to use for the Git operations")
+                .betaOption("--gitBranch <gitBranch>", "Git branch from which you want to pull the exported file and import")
+                .option("-f, --file <file>", "Exported packages file (relative path)")
                 .action(this.batchImportPackages);
             configCommand.command("diff")
                 .description("Command to diff configs of packages")
@@ -82,11 +86,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             });
         }
         batchExportPackages(context, command, options) {
+            var _a;
             return __awaiter(this, void 0, void 0, function* () {
                 if ((options.packageKeys && options.keysByVersion) || (!options.packageKeys && !options.keysByVersion)) {
                     throw new Error("Please provide either --packageKeys or --keysByVersion, but not both.");
                 }
-                yield new config_command_service_1.ConfigCommandService(context).batchExportPackages(options.packageKeys, options.keysByVersion, options.withDependencies);
+                options.withDependencies = (_a = options.withDependencies) !== null && _a !== void 0 ? _a : false;
+                yield new config_command_service_1.ConfigCommandService(context).batchExportPackages(options.packageKeys, options.keysByVersion, options.withDependencies, options.gitBranch);
             });
         }
         batchExportPackagesMetadata(context, command, options) {
@@ -96,7 +102,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         }
         batchImportPackages(context, command, options) {
             return __awaiter(this, void 0, void 0, function* () {
-                yield new config_command_service_1.ConfigCommandService(context).batchImportPackages(options.file, options.overwrite);
+                yield new config_command_service_1.ConfigCommandService(context).batchImportPackages(options.file, options.overwrite, options.gitBranch);
             });
         }
         diffPackages(context, command, options) {

package/commands/git-profile/git-profile-command.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", "../../core/utils/question.service", "../../core/utils/logger", "../../core/git-profile/git-profile.service", "../../core/git-profile/git-profile.interface"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.GitProfileCommandService = void 0;
+    const question_service_1 = require("../../core/utils/question.service");
+    const logger_1 = require("../../core/utils/logger");
+    const git_profile_service_1 = require("../../core/git-profile/git-profile.service");
+    const git_profile_interface_1 = require("../../core/git-profile/git-profile.interface");
+    class GitProfileCommandService {
+        constructor() {
+            this.gitProfileService = new git_profile_service_1.GitProfileService();
+        }
+        createProfile(setAsDefault) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const profile = {};
+                const questions = new question_service_1.QuestionService();
+                try {
+                    profile.name = yield questions.ask("Name of the Git profile to create: ");
+                    profile.username = yield questions.ask("Your Git username: ");
+                    profile.repository = yield questions.ask("Your repository (format: repoOwner/repoName): ");
+                    const type = yield questions.ask("Authentication type: PAT (1), SSH token (2): ");
+                    switch (type) {
+                        case "1":
+                            profile.authenticationType = git_profile_interface_1.AuthenticationType.PAT;
+                            profile.token = yield questions.ask("Your Personal Access Token (PAT): ");
+                            break;
+                        case "2":
+                            profile.authenticationType = git_profile_interface_1.AuthenticationType.SSH;
+                            break;
+                        default:
+                            logger_1.logger.error(new logger_1.FatalError("Invalid type"));
+                            break;
+                    }
+                    // possibly check if the user has sent a valid token that has access in the repository
+                    this.gitProfileService.storeProfile(profile);
+                    if (setAsDefault) {
+                        yield this.makeDefaultProfile(profile.name);
+                    }
+                }
+                finally {
+                    yield questions.close();
+                }
+                logger_1.logger.info("Git Profile created successfully!");
+            });
+        }
+        listProfiles() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const profiles = this.gitProfileService.readAllProfiles();
+                const defaultProfile = this.gitProfileService.getDefaultProfile();
+                if (profiles) {
+                    profiles.forEach(profile => {
+                        if (defaultProfile && defaultProfile === profile) {
+                            logger_1.logger.info(profile + " (default)");
+                        }
+                        else {
+                            logger_1.logger.info(profile);
+                        }
+                    });
+                }
+            });
+        }
+        makeDefaultProfile(profile) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield this.gitProfileService.makeDefaultProfile(profile);
+                logger_1.logger.info("Default Git profile: " + profile);
+            });
+        }
+    }
+    exports.GitProfileCommandService = GitProfileCommandService;
+});

package/commands/git-profile/module.js

@@ -0,0 +1,65 @@
+/**
+ * Commands to create and list access profiles.
+ */
+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", "./git-profile-command.service"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    const module_handler_1 = require("../../core/command/module-handler");
+    const git_profile_command_service_1 = require("./git-profile-command.service");
+    class Module extends module_handler_1.IModule {
+        register(context, configurator) {
+            const gitCommand = configurator.command("git")
+                .beta()
+                .description("Commands related to Git settings");
+            const gitProfileCommand = gitCommand.command("profile")
+                .beta()
+                .description("Manage Git profiles required to use git-related operations.");
+            gitProfileCommand.command("list")
+                .description("Command to list all stored Git profiles")
+                .beta()
+                .action(this.listProfiles);
+            gitProfileCommand.command("create")
+                .description("Command to create a new Git profile")
+                .option("--setAsDefault", "Set this Git profile as default")
+                .beta()
+                .action(this.createProfile);
+            gitProfileCommand.command("default <profile>")
+                .description("Command to set a Git profile as default")
+                .beta()
+                .action(this.defaultProfile);
+        }
+        defaultProfile(context, command) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const profile = command.args[0];
+                yield new git_profile_command_service_1.GitProfileCommandService().makeDefaultProfile(profile);
+            });
+        }
+        createProfile(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new git_profile_command_service_1.GitProfileCommandService().createProfile(options.setAsDefault);
+            });
+        }
+        listProfiles(context, command) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new git_profile_command_service_1.GitProfileCommandService().listProfiles();
+            });
+        }
+    }
+    return Module;
+});

package/core/command/cli-context.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", "../http/http-client", "../profile/profile.service", "../utils/logger"], factory);
+        define(["require", "exports", "../http/http-client", "../profile/profile.service", "../utils/logger", "../git-profile/git-profile.service"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -22,6 +22,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     const http_client_1 = require("../http/http-client");
     const profile_service_1 = require("../profile/profile.service");
     const logger_1 = require("../utils/logger");
+    const git_profile_service_1 = require("../git-profile/git-profile.service");
     /**
      * The execution context object is passed to the modules to access
      * foundational services such as APIs, profiles, logging etc. It is
@@ -31,7 +32,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         constructor(options) {
             this.log = logger_1.logger;
             this.profileService = new profile_service_1.ProfileService();
+            this.gitProfileService = new git_profile_service_1.GitProfileService();
             this.profileName = options.profile;
+            this.gitProfileName = options.gitProfile;
         }
         get httpClient() {
             if (!this._httpClient) {
@@ -42,6 +45,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         init() {
             return __awaiter(this, void 0, void 0, function* () {
                 yield this.loadProfile(this.profileName);
+                yield this.loadGitProfile(this.gitProfileName);
                 if (this.profile) {
                     // only if a profile is available, it makes sense to provide an initialized
                     // HttpClient API.
@@ -70,6 +74,26 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 }
             });
         }
+        loadGitProfile(gitProfileName) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!gitProfileName) {
+                    this.log.debug("Git Profile name not specified, using default profile");
+                    gitProfileName = this.gitProfileService.getDefaultProfile();
+                    if (!gitProfileName) {
+                        this.log.debug("A default Git profile is not configured.");
+                    }
+                }
+                try {
+                    this.gitProfile = yield this.gitProfileService.findProfile(gitProfileName);
+                    this.gitProfileName = gitProfileName;
+                    this.log.debug(`Using Git profile ${gitProfileName}`);
+                }
+                catch (err) {
+                    this.gitProfile = undefined;
+                    this.gitProfileName = undefined;
+                }
+            });
+        }
     }
     exports.Context = Context;
 });

package/core/git-profile/git/git.service.js

@@ -0,0 +1,125 @@
+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", "simple-git", "../../utils/logger", "fs", "path", "node:os", "uuid"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.GitService = void 0;
+    const simple_git_1 = require("simple-git");
+    const logger_1 = require("../../utils/logger");
+    const fs = require("fs");
+    const path = require("path");
+    const os = require("node:os");
+    const uuid_1 = require("uuid");
+    class GitService {
+        constructor(context) {
+            this.gitProfile = context.gitProfile;
+        }
+        pullFromBranch(branch) {
+            return __awaiter(this, void 0, void 0, function* () {
+                this.validateGitProfileExistence();
+                const repoUrl = this.getRepoUrl();
+                const targetDir = path.join(os.tmpdir(), `content-cli-${(0, uuid_1.v4)()}`);
+                fs.mkdirSync(targetDir, { recursive: true });
+                const git = (0, simple_git_1.default)();
+                try {
+                    yield git.clone(repoUrl, targetDir, ["--branch", branch, "--single-branch"]);
+                }
+                catch (err) {
+                    throw new Error(`Failed to pull from ${branch}: ${err}`);
+                }
+                this.cleanupGitDirectory(targetDir);
+                return targetDir;
+            });
+        }
+        pushToBranch(sourceDir, branch) {
+            var _a, _b;
+            return __awaiter(this, void 0, void 0, function* () {
+                this.validateGitProfileExistence();
+                const workingDir = path.join(os.tmpdir(), `content-cli-${(0, uuid_1.v4)()}`);
+                fs.mkdirSync(workingDir, { recursive: true });
+                const repoUrl = this.getRepoUrl();
+                const git = (0, simple_git_1.default)();
+                try {
+                    yield git.clone(repoUrl, workingDir, ["--branch", "main"]);
+                    const repoGit = (0, simple_git_1.default)({ baseDir: workingDir });
+                    yield repoGit.addConfig("user.name", (_a = this.gitProfile.username) !== null && _a !== void 0 ? _a : "content-cli");
+                    yield repoGit.addConfig("user.email", `${(_b = this.gitProfile.username) !== null && _b !== void 0 ? _b : "cli"}@users.noreply.github.com`);
+                    yield this.cleanupNonGitFiles(workingDir);
+                    yield this.checkoutOrCreateLocalBranch(repoGit, branch);
+                    fs.cpSync(sourceDir, workingDir, { recursive: true });
+                    yield repoGit.add("./*");
+                    const status = yield repoGit.status();
+                    if (status.files.length === 0) {
+                        logger_1.logger.debug("No changes to commit.");
+                        return;
+                    }
+                    const commitMessage = "Update from content-cli";
+                    yield repoGit.commit(commitMessage);
+                    yield repoGit.push(["--set-upstream", "origin", branch]);
+                }
+                catch (err) {
+                    throw new Error(`Failed to push to ${branch}: ${err}`);
+                }
+                finally {
+                    fs.rmSync(workingDir, { recursive: true, force: true });
+                }
+            });
+        }
+        cleanupNonGitFiles(workingDir) {
+            return __awaiter(this, void 0, void 0, function* () {
+                for (const entry of fs.readdirSync(workingDir)) {
+                    if (entry !== ".git") {
+                        fs.rmSync(path.join(workingDir, entry), { recursive: true, force: true });
+                    }
+                }
+            });
+        }
+        checkoutOrCreateLocalBranch(git, branch) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const branches = yield git.branch();
+                if (!branches.all.includes(`remotes/origin/${branch}`)) {
+                    yield git.checkoutLocalBranch(branch);
+                }
+                else {
+                    yield git.checkout(["-b", branch, "--track", `origin/${branch}`]);
+                }
+            });
+        }
+        getRepoUrl() {
+            const { authenticationType, repository, token, username } = this.gitProfile;
+            if (authenticationType === "SSH") {
+                return `git@github.com:${repository}.git`;
+            }
+            const safeUsername = encodeURIComponent(username !== null && username !== void 0 ? username : "git");
+            const safeToken = encodeURIComponent(token);
+            return `https://${safeUsername}:${safeToken}@github.com/${repository}.git`;
+        }
+        cleanupGitDirectory(repoDirectory) {
+            const gitPath = path.join(repoDirectory, ".git");
+            if (fs.existsSync(gitPath)) {
+                fs.rmSync(gitPath, { recursive: true, force: true });
+            }
+        }
+        validateGitProfileExistence() {
+            if (!this.gitProfile) {
+                throw new Error("No configured Git profile.");
+            }
+        }
+    }
+    exports.GitService = GitService;
+});

package/core/git-profile/git-profile.interface.js

@@ -0,0 +1,18 @@
+(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 });
+    exports.AuthenticationType = void 0;
+    // tslint:disable-next-line:variable-name
+    exports.AuthenticationType = {
+        SSH: "SSH",
+        PAT: "Personal Access Token",
+    };
+});

package/core/git-profile/git-profile.service.js

@@ -0,0 +1,133 @@
+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", "path", "fs", "../utils/logger", "os", "./git-profile.interface", "./git-profile.validator"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.GitProfileService = void 0;
+    const path = require("path");
+    const fs = require("fs");
+    const logger_1 = require("../utils/logger");
+    const os = require("os");
+    const git_profile_interface_1 = require("./git-profile.interface");
+    const git_profile_validator_1 = require("./git-profile.validator");
+    class GitProfileService {
+        constructor() {
+            this.homedir = os.homedir();
+            this.gitProfileContainerPath = path.resolve(this.homedir, ".celonis-content-cli-git-profiles");
+            this.configContainer = path.resolve(this.gitProfileContainerPath, "config.json");
+        }
+        findProfile(profileName) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return new Promise((resolve, reject) => {
+                    if (process.env.USERNAME && process.env.GIT_TOKEN && process.env.REPOSITORY) {
+                        resolve(this.buildProfileFromEnvVariables());
+                    }
+                    else {
+                        if (!profileName) {
+                            reject(new Error("No profile was found"));
+                        }
+                        this.createProfileContainerIfNotExists();
+                        const file = fs.readFileSync(path.resolve(this.gitProfileContainerPath, this.constructProfileFileName(profileName)), { encoding: "utf-8" });
+                        const profile = JSON.parse(file);
+                        resolve(profile);
+                    }
+                });
+            });
+        }
+        makeDefaultProfile(profileName) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return new Promise((resolve, reject) => {
+                    this.findProfile(profileName)
+                        .then((profile) => {
+                        this.createProfileContainerIfNotExists();
+                        this.storeConfig({ defaultProfile: profileName });
+                        resolve(profile);
+                    })
+                        .catch(err => {
+                        logger_1.logger.error(new logger_1.FatalError("Git Profile does not exit."));
+                        reject(err);
+                    });
+                });
+            });
+        }
+        getDefaultProfile() {
+            if (fs.existsSync(this.configContainer)) {
+                const config = JSON.parse(fs.readFileSync(this.configContainer, { encoding: "utf-8" }));
+                return config.defaultProfile;
+            }
+            else {
+                return null;
+            }
+        }
+        storeProfile(profile) {
+            this.createProfileContainerIfNotExists();
+            const newProfileFileName = this.constructProfileFileName(profile.name);
+            fs.writeFileSync(path.resolve(this.gitProfileContainerPath, newProfileFileName), JSON.stringify(profile), {
+                encoding: "utf-8",
+            });
+        }
+        buildProfileFromEnvVariables() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const profileVariables = this.getProfileEnvVariables();
+                const profile = {
+                    name: profileVariables.repository,
+                    repository: profileVariables.repository,
+                    token: profileVariables.apiToken,
+                    authenticationType: git_profile_interface_1.AuthenticationType.SSH,
+                };
+                profile.authenticationType = yield git_profile_validator_1.GitProfileValidator.validateProfile(profile);
+                return profile;
+            });
+        }
+        storeConfig(config) {
+            fs.writeFileSync(this.configContainer, JSON.stringify(config), { encoding: "utf-8" });
+        }
+        createProfileContainerIfNotExists() {
+            if (!fs.existsSync(this.gitProfileContainerPath)) {
+                fs.mkdirSync(this.gitProfileContainerPath);
+            }
+        }
+        constructProfileFileName(profileName) {
+            return profileName + ".json";
+        }
+        readAllProfiles() {
+            let fileNames = [];
+            try {
+                if (fs.existsSync(this.gitProfileContainerPath)) {
+                    fileNames = fs
+                        // @ts-ignore
+                        .readdirSync(this.gitProfileContainerPath, { withFileTypes: true })
+                        .filter(dirent => !dirent.isDirectory() && dirent.name.endsWith(".json") && dirent.name !== "config.json")
+                        .map(dirent => dirent.name.replace(".json", ""));
+                }
+            }
+            catch (err) {
+                logger_1.logger.error(new logger_1.FatalError(err));
+            }
+            return fileNames;
+        }
+        getProfileEnvVariables() {
+            return {
+                username: process.env.USERNAME,
+                token: process.env.GIT_TOKEN,
+                repository: process.env.REPOSITORY,
+            };
+        }
+    }
+    exports.GitProfileService = GitProfileService;
+});

package/core/git-profile/git-profile.validator.js

@@ -0,0 +1,46 @@
+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", "../utils/logger", "./git-profile.interface"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.GitProfileValidator = void 0;
+    const logger_1 = require("../utils/logger");
+    const git_profile_interface_1 = require("./git-profile.interface");
+    class GitProfileValidator {
+        static validateProfile(gitProfile) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (gitProfile.name == null) {
+                    logger_1.logger.error(new logger_1.FatalError("The name can not be empty"));
+                }
+                if (gitProfile.username == null) {
+                    logger_1.logger.error(new logger_1.FatalError("The username can not be empty"));
+                }
+                if (gitProfile.repository == null) {
+                    logger_1.logger.error(new logger_1.FatalError("The repository can not be empty"));
+                }
+                if (gitProfile.authenticationType == null) {
+                    logger_1.logger.error(new logger_1.FatalError("The authentication type can not be empty"));
+                }
+                if (gitProfile.authenticationType === git_profile_interface_1.AuthenticationType.PAT && gitProfile.token == null) {
+                    logger_1.logger.error(new logger_1.FatalError("The token can not be empty for authentication with PAT"));
+                }
+            });
+        }
+    }
+    exports.GitProfileValidator = GitProfileValidator;
+});

package/core/utils/file-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", "fs", "path", "./logger"], factory);
+        define(["require", "exports", "fs", "path", "./logger", "adm-zip", "uuid", "node:os"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -22,6 +22,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     const fs = require("fs");
     const path = require("path");
     const logger_1 = require("./logger");
+    const AdmZip = require("adm-zip");
+    const uuid_1 = require("uuid");
+    const os = require("node:os");
     class FileService {
         writeToFileWithGivenName(data, filename) {
             fs.writeFileSync(path.resolve(process.cwd(), filename), this.getSerializedFileContent(data), {
@@ -43,6 +46,45 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             }
             return fs.readFileSync(path.resolve(process.cwd(), filename), { encoding: "utf-8" });
         }
+        extractExportedZipWithNestedZips(zipFile) {
+            const tempDir = path.join(os.tmpdir(), `${(0, uuid_1.v4)()}`);
+            fs.mkdirSync(tempDir, { recursive: true });
+            zipFile.extractAllTo(tempDir, true);
+            const files = fs.readdirSync(tempDir);
+            for (const file of files) {
+                const innerZipPath = path.join(tempDir, file);
+                if (file.endsWith(".zip")) {
+                    const nestedZip = new AdmZip(innerZipPath);
+                    const nestedDir = innerZipPath.replace(/\.zip$/, "");
+                    fs.mkdirSync(nestedDir, { recursive: true });
+                    nestedZip.extractAllTo(nestedDir, true);
+                    fs.rmSync(innerZipPath); // Optionally remove the inner zip
+                }
+            }
+            return tempDir;
+        }
+        zipDirectoryInBatchExportFormat(sourceDir) {
+            const files = fs.readdirSync(sourceDir);
+            const finalZip = new AdmZip();
+            files.forEach(file => {
+                const fullPath = path.join(sourceDir, file);
+                const stat = fs.statSync(fullPath);
+                if (stat.isDirectory()) {
+                    const zip = new AdmZip();
+                    zip.addLocalFolder(fullPath);
+                    const zippedBuffer = zip.toBuffer();
+                    finalZip.addFile(`${file}.zip`, zippedBuffer);
+                }
+                else if (stat.isFile()) {
+                    finalZip.addLocalFile(fullPath);
+                }
+            });
+            const tempDir = path.join(os.tmpdir(), "content-cli-exports");
+            fs.mkdirSync(tempDir, { recursive: true });
+            const zipFilePath = path.join(tempDir, `export_${(0, uuid_1.v4)()}.zip`);
+            finalZip.writeZip(zipFilePath);
+            return zipFilePath;
+        }
         getSerializedFileContent(data) {
             return data;
         }

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

@@ -8,8 +8,8 @@ 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[]>;
-    exportPackages(packageKeys: string[], withDependencies?: boolean): Promise<Buffer>;
-    exportPackagesByVersions(packageKeysWithVersion: string[], withDependencies?: boolean): Promise<Buffer>;
+    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[]>;
     findVariablesWithValuesByPackageKeysAndVersion(packagesByKeyAndVersion: PackageKeyAndVersionPair[]): Promise<VariableManifestTransport[]>;

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

@@ -3,12 +3,13 @@ export declare class BatchImportExportService {
     private batchImportExportApi;
     private studioPackageApi;
     private studioService;
+    private gitService;
     constructor(context: Context);
     listActivePackages(flavors: string[]): Promise<void>;
     findAndExportListOfActivePackages(flavors: string[], packageKeys: string[], withDependencies: boolean): Promise<void>;
-    batchExportPackages(packageKeys: string[], packageKeysByVersion: string[], withDependencies?: boolean): Promise<void>;
+    batchExportPackages(packageKeys: string[], packageKeysByVersion: string[], withDependencies: boolean, gitBranch: string): Promise<void>;
     batchExportPackagesMetadata(packageKeys: string[], jsonResponse: boolean): Promise<void>;
-    batchImportPackages(file: string, overwrite: boolean): Promise<void>;
+    batchImportPackages(file: string, overwrite: boolean, gitBranch: string): 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

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

package/lib/commands/git-profile/git-profile-command.service.d.ts

@@ -0,0 +1,6 @@
+export declare class GitProfileCommandService {
+    private gitProfileService;
+    createProfile(setAsDefault: boolean): Promise<void>;
+    listProfiles(): Promise<void>;
+    makeDefaultProfile(profile: string): Promise<void>;
+}

package/lib/commands/git-profile/module.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Commands to create and list access profiles.
+ */
+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 defaultProfile;
+    private createProfile;
+    private listProfiles;
+}
+export = Module;

package/lib/core/command/cli-context.d.ts

@@ -1,5 +1,6 @@
 import { HttpClient } from "../http/http-client";
 import { Profile } from "../profile/profile.interface";
+import { GitProfile } from "../git-profile/git-profile.interface";
 /**
  * The execution context object is passed to the modules to access
  * foundational services such as APIs, profiles, logging etc. It is
@@ -8,11 +9,15 @@ import { Profile } from "../profile/profile.interface";
 export declare class Context {
     _httpClient: HttpClient;
     profile: Profile;
+    gitProfile: GitProfile;
     private log;
     private profileName;
+    private gitProfileName;
     private profileService;
+    private gitProfileService;
     constructor(options: any);
     get httpClient(): HttpClient;
     init(): Promise<void>;
     private loadProfile;
+    private loadGitProfile;
 }

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

@@ -0,0 +1,12 @@
+import { Context } from "../../command/cli-context";
+export declare class GitService {
+    private readonly gitProfile;
+    constructor(context: Context);
+    pullFromBranch(branch: string): Promise<string>;
+    pushToBranch(sourceDir: string, branch: string): Promise<void>;
+    private cleanupNonGitFiles;
+    private checkoutOrCreateLocalBranch;
+    private getRepoUrl;
+    private cleanupGitDirectory;
+    private validateGitProfileExistence;
+}

package/lib/core/git-profile/git-profile.interface.d.ts

@@ -0,0 +1,11 @@
+export interface GitProfile {
+    name: string;
+    username?: string;
+    repository: string;
+    token?: string;
+    authenticationType: AuthenticationType;
+}
+export type AuthenticationType = "SSH" | "Personal Access Token";
+export declare const AuthenticationType: {
+    [key: string]: AuthenticationType;
+};

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

@@ -0,0 +1,19 @@
+import { GitProfile } from "./git-profile.interface";
+export interface GitConfig {
+    defaultProfile: string;
+}
+export declare class GitProfileService {
+    private readonly homedir;
+    private readonly gitProfileContainerPath;
+    private readonly configContainer;
+    findProfile(profileName: string): Promise<GitProfile>;
+    makeDefaultProfile(profileName: string): Promise<GitProfile>;
+    getDefaultProfile(): string;
+    storeProfile(profile: GitProfile): void;
+    private buildProfileFromEnvVariables;
+    private storeConfig;
+    private createProfileContainerIfNotExists;
+    private constructProfileFileName;
+    readAllProfiles(): string[];
+    private getProfileEnvVariables;
+}

package/lib/core/git-profile/git-profile.validator.d.ts

@@ -0,0 +1,4 @@
+import { GitProfile } from "./git-profile.interface";
+export declare class GitProfileValidator {
+    static validateProfile(gitProfile: GitProfile): Promise<any>;
+}

package/lib/core/utils/file-service.d.ts

@@ -1,9 +1,12 @@
+import AdmZip = require("adm-zip");
 export declare class FileService {
     static readonly fileDownloadedMessage = "File downloaded successfully. New filename: ";
     writeToFileWithGivenName(data: any, filename: string): void;
     createDirectoryWithGivenName(dirName: string): void;
     readFileToJson<T>(fileName: string): Promise<T>;
     readFile(filename: string): string;
+    extractExportedZipWithNestedZips(zipFile: AdmZip): string;
+    zipDirectoryInBatchExportFormat(sourceDir: string): string;
     private getSerializedFileContent;
 }
 export declare const fileService: FileService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celonis/content-cli",
-  "version": "1.0.8",
+  "version": "1.1.0",
   "description": "CLI Tool to help manage content in Celonis Platform",
   "main": "content-cli.js",
   "bin": {
@@ -26,6 +26,7 @@
     "openid-client": "5.6.1",
     "hpagent": "1.2.0",
     "semver": "7.6.3",
+    "simple-git": "3.28.0",
     "valid-url": "1.0.9",
     "winston": "3.17.0",
     "yaml": "2.7.0"