@celonis/content-cli 1.14.0 → 1.15.0

package/core/profile/profile.service.js

@@ -72,15 +72,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                                     .catch(() => reject(`The profile ${profileName} couldn't be resolved.`));
                             }
                         }
-                        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.`);
+                            const envProfileSource = this.selectEnvProfileSource();
+                            if (envProfileSource) {
+                                if (envProfileSource.requiresCelonisMapping) {
+                                    this.mapCelonisEnvProfile();
+                                }
+                                resolve(this.buildProfileFromEnvVariables());
+                            }
+                            else {
+                                reject(`The profile ${profileName} couldn't be resolved due to missing environment variables.`);
+                            }
                         }
                     }
                     catch (e) {
@@ -136,6 +138,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 });
             });
         }
+        selectEnvProfileSource() {
+            var _a, _b;
+            const sources = [
+                { teamUrl: process.env.TEAM_URL, apiToken: process.env.API_TOKEN, requiresCelonisMapping: false },
+                { teamUrl: process.env.CELONIS_URL, apiToken: process.env.CELONIS_API_TOKEN, requiresCelonisMapping: true },
+            ].filter(source => !!source.teamUrl);
+            return (_b = (_a = sources.find(source => !!source.apiToken)) !== null && _a !== void 0 ? _a : sources[0]) !== null && _b !== void 0 ? _b : null;
+        }
         buildProfileFromEnvVariables() {
             return __awaiter(this, void 0, void 0, function* () {
                 const profileVariables = this.getProfileEnvVariables();
@@ -146,7 +156,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                     authenticationType: profile_interface_1.AuthenticationType.BEARER,
                     type: profile_interface_1.ProfileType.KEY
                 };
-                profile.authenticationType = yield profile_validator_1.ProfileValidator.validateProfile(profile);
+                profile_validator_1.ProfileValidator.validateEnvironmentProfile(profile);
+                if (!profile.apiToken) {
+                    logger_1.logger.warn(`No API token provided. Requests to ${profile.team} will be sent without an authorization header.`);
+                }
                 return profile;
             });
         }
@@ -266,9 +279,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 if (!this.isProfileExpired(profile, expiryBuffer)) {
                     return;
                 }
-                const issuer = yield openid_client_1.Issuer.discover(profile.team);
-                if (profile.type === profile_interface_1.ProfileType.DEVICE_CODE) {
-                    try {
+                try {
+                    const issuer = yield openid_client_1.Issuer.discover(profile.team);
+                    if (profile.type === profile_interface_1.ProfileType.DEVICE_CODE) {
                         const oauthClient = new issuer.Client({
                             client_id: "content-cli",
                             token_endpoint_auth_method: "none",
@@ -278,12 +291,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                         profile.expiresAt = tokenSet.expires_at;
                         profile.refreshToken = tokenSet.refresh_token;
                     }
-                    catch (err) {
-                        logger_1.logger.error(new logger_1.FatalError("The profile cannot be refreshed. Please retry or recreate profile."));
-                    }
-                }
-                else {
-                    try {
+                    else {
                         const oauthClient = new issuer.Client({
                             client_id: profile.clientId,
                             client_secret: profile.clientSecret,
@@ -296,13 +304,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                         profile.apiToken = tokenSet.access_token;
                         profile.expiresAt = tokenSet.expires_at;
                     }
-                    catch (err) {
-                        logger_1.logger.error(new logger_1.FatalError("The profile cannot be refreshed. Please retry or recreate profile."));
-                    }
+                }
+                catch (err) {
+                    throw this.unrefreshableProfile(profile.name, err);
                 }
                 yield this.storeProfile(profile);
             });
         }
+        unrefreshableProfile(profileName, err) {
+            const cause = err instanceof Error ? err.message : "an unrecognised error";
+            logger_1.logger.debug(`Refreshing the profile ${profileName} failed: ${cause}`);
+            logger_1.logger.warn(`The profile ${profileName} cannot be refreshed. Retry, or recreate it.`);
+            return new Error(`The profile ${profileName} cannot be refreshed.`);
+        }
         getProfileEnvVariables() {
             return {
                 teamUrl: this.getBaseTeamUrl(process.env.TEAM_URL),

package/core/profile/profile.validator.js

@@ -25,23 +25,33 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     class ProfileValidator {
         static validateProfile(profile) {
             return __awaiter(this, void 0, void 0, function* () {
-                if (profile.name == null) {
-                    logger_1.logger.error(new logger_1.FatalError("The name can not be empty"));
-                }
-                if (profile.team == null) {
-                    logger_1.logger.error(new logger_1.FatalError("The team can not be empty"));
-                }
+                this.validateIdentity(profile);
                 if (profile.type === profile_interface_1.ProfileType.KEY && profile.apiToken == null) {
                     logger_1.logger.error(new logger_1.FatalError("The api token can not be empty for this profile type"));
                 }
                 if (profile.type === profile_interface_1.ProfileType.CLIENT_CREDENTIALS && (profile.clientId == null || profile.clientSecret == null)) {
                     logger_1.logger.error(new logger_1.FatalError("The client id and secret can not be empty for this profile type"));
                 }
-                if (!validUrl.isUri(profile.team)) {
-                    logger_1.logger.error(new logger_1.FatalError("The provided url is not a valid url."));
-                }
+                this.validateTeamUrl(profile);
             });
         }
+        static validateEnvironmentProfile(profile) {
+            this.validateIdentity(profile);
+            this.validateTeamUrl(profile);
+        }
+        static validateIdentity(profile) {
+            if (profile.name == null) {
+                logger_1.logger.error(new logger_1.FatalError("The name can not be empty"));
+            }
+            if (profile.team == null) {
+                logger_1.logger.error(new logger_1.FatalError("The team can not be empty"));
+            }
+        }
+        static validateTeamUrl(profile) {
+            if (!validUrl.isUri(profile.team)) {
+                logger_1.logger.error(new logger_1.FatalError("The provided url is not a valid url."));
+            }
+        }
     }
     exports.ProfileValidator = ProfileValidator;
 });

package/core/utils/cui-api.js

@@ -0,0 +1,52 @@
+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", "./logger"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.CuiApi = exports.CuiMarking = exports.CUI_MARKING_FAILED_MESSAGE = void 0;
+    const logger_1 = require("./logger");
+    exports.CUI_MARKING_FAILED_MESSAGE = "Could not resolve CUI marking. No file was written";
+    var CuiMarking;
+    (function (CuiMarking) {
+        CuiMarking["DISABLED"] = "DISABLED";
+        CuiMarking["CLASSIFIED"] = "CLASSIFIED";
+    })(CuiMarking || (exports.CuiMarking = CuiMarking = {}));
+    class CuiApi {
+        constructor(context) {
+            this.httpClient = () => context.httpClient;
+        }
+        getCuiMarking() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const { status, data } = yield this.httpClient().getStatusAndData(CuiApi.CUI_PDF_COVER_SHEET_URL);
+                if (status === CuiApi.STATUS_FORBIDDEN) {
+                    logger_1.logger.debug("CUI marking does not apply, the feature flag is disabled");
+                    return { marking: CuiMarking.DISABLED };
+                }
+                if (status === CuiApi.STATUS_OK && data) {
+                    return { marking: CuiMarking.CLASSIFIED, cover: data };
+                }
+                logger_1.logger.debug(`The CUI cover call answered with status ${status}`);
+                throw new logger_1.FatalError(exports.CUI_MARKING_FAILED_MESSAGE);
+            });
+        }
+    }
+    exports.CuiApi = CuiApi;
+    CuiApi.CUI_PDF_COVER_SHEET_URL = "/api/team/cui-settings/cui-pdf-cover";
+    CuiApi.STATUS_OK = 200;
+    CuiApi.STATUS_FORBIDDEN = 403;
+});

package/core/utils/cui-file-service.js

@@ -0,0 +1,106 @@
+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", "node:path", "adm-zip", "./cui-api", "./file-service", "./file.constants", "./logger"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.CuiFileService = void 0;
+    const path = require("node:path");
+    const AdmZip = require("adm-zip");
+    const cui_api_1 = require("./cui-api");
+    const file_service_1 = require("./file-service");
+    const file_constants_1 = require("./file.constants");
+    const logger_1 = require("./logger");
+    class CuiFileService {
+        constructor(context) {
+            this.cuiApi = new cui_api_1.CuiApi(context);
+        }
+        writeToFileWithGivenName(data, filename) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return this.writeWithCoverHandling(name => file_service_1.fileService.writeToFileWithGivenName(data, name), filename, cover => this.writeClassifiedArchive(filename, data, cover));
+            });
+        }
+        writeZipToFileWithGivenName(zipData, filename) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return this.writeWithCoverHandling(name => file_service_1.fileService.writeBufferToFileWithGivenName(zipData, name), filename, cover => {
+                    const zip = new AdmZip(zipData);
+                    this.addCoverPage(zip, cover);
+                    return this.writeArchive(zip, filename);
+                });
+            });
+        }
+        writeDirectoryWithGivenName(write, directoryName) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return this.writeWithCoverHandling(write, directoryName, cover => {
+                    const coverSheet = this.decodeCoverPage(cover);
+                    const classifiedName = this.prefixFileName(directoryName, CuiFileService.CLASSIFIED_PREFIX);
+                    write(classifiedName);
+                    file_service_1.fileService.writeBufferToFileWithGivenName(coverSheet, path.join(classifiedName, CuiFileService.COVER_SHEET_FILE_NAME));
+                    return classifiedName;
+                });
+            });
+        }
+        writeWithCoverHandling(write, filename, onClassified) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const decision = yield this.cuiApi.getCuiMarking();
+                if (decision.marking === cui_api_1.CuiMarking.DISABLED) {
+                    write(filename);
+                    return filename;
+                }
+                return onClassified(decision.cover);
+            });
+        }
+        writeClassifiedArchive(filename, data, cover) {
+            const zip = new AdmZip();
+            zip.addFile(path.basename(filename), Buffer.from(data, "utf-8"), "", file_constants_1.FileConstants.DEFAULT_FILE_PERMISSIONS);
+            this.addCoverPage(zip, cover);
+            return this.writeArchive(zip, filename);
+        }
+        addCoverPage(zip, cover) {
+            zip.addFile(CuiFileService.COVER_SHEET_FILE_NAME, this.decodeCoverPage(cover), "", file_constants_1.FileConstants.DEFAULT_FILE_PERMISSIONS);
+        }
+        writeArchive(zip, filename) {
+            const archiveName = this.buildClassifiedArchiveName(filename);
+            file_service_1.fileService.writeBufferToFileWithGivenName(zip.toBuffer(), archiveName);
+            return archiveName;
+        }
+        decodeCoverPage(cover) {
+            const coverPage = cover.coverPage;
+            if (!(coverPage === null || coverPage === void 0 ? void 0 : coverPage.pdfContent)) {
+                logger_1.logger.debug("CUI marking applies but the response contained no cover page");
+                throw new logger_1.FatalError(cui_api_1.CUI_MARKING_FAILED_MESSAGE);
+            }
+            if (coverPage.encoding !== CuiFileService.BASE64_ENCODING) {
+                logger_1.logger.debug(`Unsupported CUI cover page encoding: ${coverPage.encoding}`);
+                throw new logger_1.FatalError(cui_api_1.CUI_MARKING_FAILED_MESSAGE);
+            }
+            return Buffer.from(coverPage.pdfContent, CuiFileService.BASE64_ENCODING);
+        }
+        buildClassifiedArchiveName(filename) {
+            const baseName = path.basename(filename);
+            const nameWithoutExtension = baseName.slice(0, baseName.length - path.extname(baseName).length);
+            return path.join(path.dirname(filename), `${CuiFileService.CLASSIFIED_PREFIX}${nameWithoutExtension}.zip`);
+        }
+        prefixFileName(filename, prefix) {
+            return path.join(path.dirname(filename), `${prefix}${path.basename(filename)}`);
+        }
+    }
+    exports.CuiFileService = CuiFileService;
+    CuiFileService.COVER_SHEET_FILE_NAME = "CUI_Cover_Sheet.pdf";
+    CuiFileService.CLASSIFIED_PREFIX = "CUI - ";
+    CuiFileService.BASE64_ENCODING = "base64";
+});

package/core/utils/file-service.js

@@ -57,11 +57,12 @@
             return this.extractExportedZipWithNestedZipsToDir(zipFile, tempDir);
         }
         extractExportedZipWithNestedZipsToDir(zipFile, targetDir) {
-            this.mkdirRecursive(targetDir);
-            zipFile.extractAllTo(targetDir, true, true);
-            const files = fs.readdirSync(targetDir);
+            const targetPath = path.resolve(process.cwd(), targetDir);
+            this.mkdirRecursive(targetPath);
+            zipFile.extractAllTo(targetPath, true, true);
+            const files = fs.readdirSync(targetPath);
             for (const file of files) {
-                const innerZipPath = path.join(targetDir, file);
+                const innerZipPath = path.join(targetPath, file);
                 if (file.endsWith(".zip")) {
                     const nestedZip = new AdmZip(innerZipPath);
                     const nestedDir = innerZipPath.replace(/\.zip$/, "");
@@ -70,8 +71,8 @@
                     fs.rmSync(innerZipPath); // Optionally remove the inner zip
                 }
             }
-            this.restrictFilePermissions(targetDir);
-            return targetDir;
+            this.restrictFilePermissions(targetPath);
+            return targetPath;
         }
         isDirectory(sourcePath) {
             var _a;

package/lib/commands/action-flows/action-flow/action-flow.service.d.ts

@@ -2,6 +2,7 @@ import { Context } from "../../../core/command/cli-context";
 export declare class ActionFlowService {
     static readonly METADATA_FILE_NAME = "metadata.json";
     private actionFlowApi;
+    private readonly cuiFileService;
     constructor(context: Context);
     exportActionFlows(packageId: string, metadataFilePath: string): Promise<void>;
     analyzeActionFlows(packageId: string, outputToJsonFile: boolean): Promise<void>;

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

@@ -8,6 +8,5 @@ export declare class AssetRegistryApi {
     getType(assetType: string): Promise<AssetRegistryDescriptor>;
     getSchema(assetType: string): Promise<any>;
     getExamples(assetType: string): Promise<any>;
-    validate(assetType: string, body: any): Promise<any>;
     private static endpointUrl;
 }

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

@@ -28,11 +28,3 @@ export interface AssetContributions {
     dataPipelineEntityTypes: string[];
     actionTypes: string[];
 }
-export interface ValidateOptions {
-    assetType: string;
-    packageKey?: string;
-    nodeKey?: string;
-    configuration?: string;
-    file?: string;
-    json: boolean;
-}

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

@@ -1,16 +1,12 @@
-import { ValidateOptions } from "./asset-registry.interfaces";
 import { Context } from "../../core/command/cli-context";
 export declare class AssetRegistryService {
     private readonly api;
+    private readonly cuiFileService;
     constructor(context: Context);
     listTypes(jsonResponse: boolean): Promise<void>;
     getType(assetType: string, jsonResponse: boolean): Promise<void>;
     getSchema(assetType: string, jsonResponse: boolean): Promise<void>;
     getExamples(assetType: string, jsonResponse: boolean): Promise<void>;
-    validate(opts: ValidateOptions): Promise<void>;
-    private static readonly INLINE_VALIDATION_NODE_KEY;
-    private buildValidatePayload;
-    private parseJson;
     private outputResponse;
     private logDescriptorSummary;
     private logDescriptorDetail;

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

@@ -5,7 +5,6 @@ declare class Module extends IModule {
     private listTypes;
     private getType;
     private getSchema;
-    private validate;
     private getExamples;
 }
 export = Module;

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

@@ -1,6 +1,7 @@
 import { Context } from "../../core/command/cli-context";
 export declare class BookmarksCommandService {
     private readonly bookmarksApi;
+    private readonly cuiFileService;
     constructor(context: Context);
     exportBookmarks(packageKey: string, file?: string): Promise<void>;
     importBookmarks(packageKey: string, file: string): Promise<void>;

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

@@ -8,5 +8,6 @@ export declare class NodeApi {
     createStagingNode(packageKey: string, transport: SaveNodeTransport, validateOnly: boolean): Promise<NodeTransport | void>;
     updateStagingNode(packageKey: string, nodeKey: string, transport: UpdateNodeTransport, validateOnly: boolean): Promise<NodeTransport | void>;
     archiveStagingNode(packageKey: string, nodeKey: string, force: boolean): Promise<void>;
+    findStagingNodesByPackage(packageKey: string, withConfiguration: boolean, limit: number, offset: number): Promise<NodeTransport[]>;
     findVersionedNodesByPackage(packageKey: string, version: string, withConfiguration: boolean, limit: number, offset: number): Promise<NodeTransport[]>;
 }

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

@@ -16,6 +16,7 @@ export declare class BranchExportImportCommandService {
     private readonly singlePackageImportApi;
     private readonly branchApi;
     private readonly gitService;
+    private readonly cuiFileService;
     constructor(context: Context);
     exportBranch(packageKey: string, branchKey: string, options?: BranchExportOptions): Promise<void>;
     exportAll(packageKey: string, jsonResponse?: boolean): Promise<void>;
@@ -32,5 +33,5 @@ export declare class BranchExportImportCommandService {
     private escapeRegExp;
     private removeDir;
     private static isExportableBranch;
-    private static writeJson;
+    private writeJson;
 }

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

@@ -2,6 +2,7 @@ import { Context } from "../../../core/command/cli-context";
 import { BranchTransport, BranchingSettingsTransport, MergeApplyOptions, MergePreviewTransport, PackageVersionCreatedTransport } from "./interfaces/branch.interfaces";
 export declare class BranchCommandService {
     private readonly branchApi;
+    private readonly cuiFileService;
     constructor(context: Context);
     setBranchingEnabled(packageKey: string, enabled: boolean, jsonResponse: boolean): Promise<BranchingSettingsTransport>;
     createBranch(packageKey: string, branchKey: string, sourceVersion: string, validate: boolean, jsonResponse: boolean): Promise<BranchTransport | void>;
@@ -10,7 +11,7 @@ export declare class BranchCommandService {
     mergePreview(targetPackageKey: string, sourceKey: string, sourceVersion: string, jsonResponse: boolean): Promise<MergePreviewTransport>;
     mergeApply(targetPackageKey: string, options: MergeApplyOptions): Promise<PackageVersionCreatedTransport>;
     private static buildVersionCreate;
-    private static writeJson;
+    private writeJson;
     private static printBranch;
     private static printPreviewSummary;
     private static countConflictPaths;

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

@@ -1,5 +1,5 @@
 export interface PackageValidationRequest {
-    layers: string[];
+    layers?: string[];
     nodeKeys?: string[];
 }
 export interface SchemaValidationResponse {

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

@@ -1,6 +1,7 @@
 import { Context } from "../../core/command/cli-context";
 export declare class MetadataService {
     private metadataApi;
+    private readonly cuiFileService;
     constructor(context: Context);
     exportPackagesMetadata(packageKeys: string[], jsonResponse: boolean): Promise<void>;
     private exportListOfPackagesMetadata;

package/lib/commands/configuration-management/node-dependency.service.d.ts

@@ -1,6 +1,7 @@
 import { Context } from "../../core/command/cli-context";
 export declare class NodeDependencyService {
     private readonly nodeDependencyApi;
+    private readonly cuiFileService;
     constructor(context: Context);
     listNodeDependencies(packageKey: string, nodeKey: string, version: string, jsonResponse: boolean): Promise<void>;
 }

package/lib/commands/configuration-management/node-diff.service.d.ts

@@ -1,6 +1,7 @@
 import { Context } from "../../core/command/cli-context";
 export declare class NodeDiffService {
     private nodeDiffApi;
+    private readonly cuiFileService;
     constructor(context: Context);
     diff(packageKey: string, nodeKey: string, baseVersion: string, compareVersion: string, jsonResponse: boolean): Promise<void>;
     diffWithFile(packageKey: string, nodeKey: string, baseVersion: string, file: string, jsonResponse: boolean): Promise<void>;

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

@@ -1,9 +1,10 @@
 import { Context } from "../../core/command/cli-context";
 export declare class NodeService {
     private nodeApi;
+    private readonly cuiFileService;
     constructor(context: Context);
     findNode(packageKey: string, nodeKey: string, withConfiguration: boolean, packageVersion: string | null, jsonResponse: boolean): Promise<void>;
-    listNodes(packageKey: string, packageVersion: string, limit: number, offset: number, withConfiguration: boolean, jsonResponse: boolean): Promise<void>;
+    listNodes(packageKey: string, packageVersion: string | null, limit: number, offset: number, withConfiguration: boolean, jsonResponse: boolean): Promise<void>;
     createNode(packageKey: string, body: string | undefined, file: string | undefined, validateOnly: boolean, jsonResponse: boolean): Promise<void>;
     updateNode(packageKey: string, nodeKey: string, body: string | undefined, file: string | undefined, validateOnly: boolean, jsonResponse: boolean): Promise<void>;
     archiveNode(packageKey: string, nodeKey: string, force: boolean): Promise<void>;

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

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

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

@@ -1,6 +1,7 @@
 import { Context } from "../../core/command/cli-context";
 export declare class PackageVersionService {
     private packageVersionApi;
+    private readonly cuiFileService;
     constructor(context: Context);
     findPackageVersion(packageKey: string, version: string, jsonResponse: boolean): Promise<void>;
     createPackageVersion(packageKey: string, version: string | undefined, versionBumpOption: string, summaryOfChanges: string | undefined, nodeFilterKeys: string[] | undefined, jsonResponse: boolean): Promise<void>;

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

@@ -2,6 +2,7 @@ import { Context } from "../../core/command/cli-context";
 export declare class SinglePackageExportService {
     private readonly singlePackageExportApi;
     private readonly gitService;
+    private readonly cuiFileService;
     constructor(context: Context);
     exportPackage(packageKey: string, zip: boolean, gitBranch: string): Promise<void>;
     private exportToGitBranch;

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

@@ -5,6 +5,7 @@ export declare class SinglePackageImportService {
     private static readonly MAX_UNCOMPRESSED_ZIP_SIZE;
     private readonly singlePackageImportApi;
     private readonly gitService;
+    private readonly cuiFileService;
     constructor(context: Context);
     importPackage(file: string, directory: string, overwrite: boolean, jsonResponse: boolean, gitBranch: string): Promise<void>;
     private resolveSource;

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

@@ -1,6 +1,7 @@
 import { Context } from "../../core/command/cli-context";
 export declare class StagingPackageService {
     private stagingPackageApi;
+    private readonly cuiFileService;
     constructor(context: Context);
     listStagingPackages(flavors: string[], includeBranches: boolean, jsonResponse: boolean): Promise<void>;
     private exportListOfPackages;

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

@@ -3,6 +3,7 @@ export declare class VariableService {
     private variableApi;
     private variableAssignmentCandidatesApi;
     private readonly stagingPackageVariablesApi;
+    private readonly cuiFileService;
     constructor(context: Context);
     listVariables(keysByVersion: string[], keysByVersionFile: string): Promise<void>;
     listCandidateAssignments(type: string, params: string): Promise<void>;

package/lib/commands/data-pipeline/data-pool/data-pool-service.d.ts

@@ -1,6 +1,7 @@
 import { Context } from "../../../core/command/cli-context";
 export declare class DataPoolService {
     private dataPoolApi;
+    private readonly cuiFileService;
     constructor(context: Context);
     batchImportDataPools(requestFilePath: string, outputToJsonFile: boolean): Promise<void>;
     exportDataPool(poolId: string, outputToJsonFile: boolean): Promise<void>;

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

@@ -1,6 +1,7 @@
 import { Context } from "../../core/command/cli-context";
 export declare class DeploymentService {
     private deploymentApi;
+    private readonly cuiFileService;
     constructor(context: Context);
     createDeployment(packageKey: string, packageVersion: string, deployableType: string, targetId: string, jsonResponse: boolean): Promise<void>;
     getDeployments(jsonResponse: boolean, packageKey?: string, targetId?: string, deployableType?: string, status?: string, createdBy?: string, limit?: string, offset?: string): Promise<void>;

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

@@ -2,6 +2,7 @@ import { Context } from "../../../core/command/cli-context";
 export declare class AssetService {
     protected readonly fileDownloadedMessage = "File downloaded successfully. New filename: ";
     private assetApi;
+    private readonly cuiFileService;
     constructor(context: Context);
     listAssets(assetType: string): Promise<void>;
     findAndExportAllAssets(assetType: string): Promise<void>;

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

@@ -7,6 +7,7 @@ export declare class PackageService {
     private packageDependenciesApi;
     private dataModelService;
     private variableService;
+    private readonly cuiFileService;
     constructor(context: Context);
     listPackages(): Promise<void>;
     findAndExportListOfAllPackages(includeDependencies: boolean, packageKeys: string[]): Promise<void>;

package/lib/commands/t2tc/diff.service.d.ts

@@ -1,6 +1,7 @@
 import { Context } from "../../core/command/cli-context";
 export declare class DiffService {
     private diffApi;
+    private readonly cuiFileService;
     constructor(context: Context);
     diffPackages(file: string, hasChanges: boolean, baseVersion: string, jsonResponse: boolean): Promise<void>;
     private hasChanges;

package/lib/commands/t2tc/t2tc-package.service.d.ts

@@ -5,6 +5,7 @@ export declare class T2tcPackageService {
     private studioPackageApi;
     private studioService;
     private gitService;
+    private readonly cuiFileService;
     constructor(context: Context);
     listActivePackages(flavors: string[], includeBranches: boolean): Promise<void>;
     findAndExportListOfPackages(flavors: string[], packageKeys: string[], keysByVersion: string[], withDependencies: boolean, includeBranches: boolean): Promise<void>;

package/lib/content-cli.d.ts

@@ -14,3 +14,4 @@ export interface CreateProgramOptions {
  * Build a fully-configured Commander program without parsing argv
  */
 export declare function createProgram(context: Context, opts?: CreateProgramOptions): Command;
+export declare function loadProfileOnDemand(program: Command, context: Context): void;

package/lib/core/command/module-handler.d.ts

@@ -20,6 +20,7 @@ export declare class ModuleHandler {
     discoverAndRegisterModules(rootPath: string, devMode?: boolean): void;
 }
 type CommandHandler = (context: Context, command: Command, options: OptionValues) => Promise<void>;
+export declare function shouldLoadProfile(command: Command): boolean;
 /**
  * Allows the creation of root level commands.
  */
@@ -53,6 +54,7 @@ export declare class CommandConfig {
     requiredOption(flags: string, description?: string, defaultValue?: string | boolean | string[]): CommandConfig;
     deprecationNotice(deprecationMessage: string): CommandConfig;
     beta(): CommandConfig;
+    skipProfileLoading(): this;
     action(handler: CommandHandler): void;
     private printDeprecationNoticeIfDeprecated;
     private printBetaNoticeIfBetaCommand;

package/lib/core/http/http-client.d.ts

@@ -9,6 +9,10 @@ export declare class HttpClient {
     private axios;
     constructor(context: Context);
     get(url: string): Promise<any>;
+    getStatusAndData(url: string): Promise<{
+        status: number;
+        data: any;
+    }>;
     getFile(url: string): Promise<any>;
     postFile(url: string, formData: FormData, parameters?: {}): Promise<any>;
     post(url: string, body: any): Promise<any>;