@commercetools-frontend/application-cli 0.0.0-FEC-212-react19-20250122084835

package/cli/dist/commercetools-frontend-application-cli-cli.esm.js

@@ -0,0 +1,1354 @@
+import { cac } from 'cac';
+import _Object$keys from '@babel/runtime-corejs3/core-js-stable/object/keys';
+import _Object$getOwnPropertySymbols from '@babel/runtime-corejs3/core-js-stable/object/get-own-property-symbols';
+import _filterInstanceProperty from '@babel/runtime-corejs3/core-js-stable/instance/filter';
+import _Object$getOwnPropertyDescriptor from '@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptor';
+import _forEachInstanceProperty from '@babel/runtime-corejs3/core-js-stable/instance/for-each';
+import _Object$getOwnPropertyDescriptors from '@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptors';
+import _Object$defineProperties from '@babel/runtime-corejs3/core-js-stable/object/define-properties';
+import _Object$defineProperty from '@babel/runtime-corejs3/core-js-stable/object/define-property';
+import _slicedToArray from '@babel/runtime-corejs3/helpers/esm/slicedToArray';
+import _defineProperty from '@babel/runtime-corejs3/helpers/esm/defineProperty';
+import _mapInstanceProperty from '@babel/runtime-corejs3/core-js-stable/instance/map';
+import _Object$entries from '@babel/runtime-corejs3/core-js-stable/object/entries';
+import _Set from '@babel/runtime-corejs3/core-js-stable/set';
+import _flatMapInstanceProperty from '@babel/runtime-corejs3/core-js-stable/instance/flat-map';
+import { s as storageProviders, l as loadStorageBucketsConfig, c as clusterContexts, a as loadConfig } from '../../dist/storage-buckets-config-fa564d15.esm.js';
+import fs from 'node:fs';
+import path$1 from 'node:path';
+import { Listr } from 'listr2';
+import execa, { command as command$5 } from 'execa';
+import { findRootSync } from '@manypkg/find-root';
+import path from 'path';
+import _possibleConstructorReturn from '@babel/runtime-corejs3/helpers/esm/possibleConstructorReturn';
+import _get from '@babel/runtime-corejs3/helpers/esm/get';
+import _getPrototypeOf from '@babel/runtime-corejs3/helpers/esm/getPrototypeOf';
+import _inherits from '@babel/runtime-corejs3/helpers/esm/inherits';
+import _classCallCheck from '@babel/runtime-corejs3/helpers/esm/classCallCheck';
+import _createClass from '@babel/runtime-corejs3/helpers/esm/createClass';
+import _classPrivateFieldLooseBase from '@babel/runtime-corejs3/helpers/esm/classPrivateFieldLooseBase';
+import _classPrivateFieldLooseKey from '@babel/runtime-corejs3/helpers/esm/classPrivateFieldLooseKey';
+import _Reflect$construct from '@babel/runtime-corejs3/core-js-stable/reflect/construct';
+import dotenv from 'dotenv';
+import fs$1 from 'fs';
+import _findInstanceProperty from '@babel/runtime-corejs3/core-js-stable/instance/find';
+import _JSON$stringify from '@babel/runtime-corejs3/core-js-stable/json/stringify';
+import { processConfig } from '@commercetools-frontend/application-config';
+import { getSupportedLocales } from '@commercetools-frontend/l10n';
+import _sliceInstanceProperty from '@babel/runtime-corejs3/core-js-stable/instance/slice';
+import _startsWithInstanceProperty from '@babel/runtime-corejs3/core-js-stable/instance/starts-with';
+import _trimInstanceProperty from '@babel/runtime-corejs3/core-js-stable/instance/trim';
+import _someInstanceProperty from '@babel/runtime-corejs3/core-js-stable/instance/some';
+import _everyInstanceProperty from '@babel/runtime-corejs3/core-js-stable/instance/every';
+import _includesInstanceProperty from '@babel/runtime-corejs3/core-js-stable/instance/includes';
+import micromatch from 'micromatch';
+import snakeCase from 'lodash/snakeCase';
+import { Validator } from 'jsonschema';
+import 'cosmiconfig';
+import 'ts-deepmerge';
+import 'lodash';
+
+function getApplicationDirectory(cwd) {
+  return fs.realpathSync(cwd);
+}
+
+function resolveInApplication(relativePath, cwd) {
+  return path.resolve(getApplicationDirectory(cwd), relativePath);
+}
+
+function isCI() {
+  // @ts-expect-error The env is sometimes overwritten by code to a boolean
+  return process.env.CI === true || process.env.CI === 'true';
+}
+
+function ownKeys$4(e, r) { var t = _Object$keys(e); if (_Object$getOwnPropertySymbols) { var o = _Object$getOwnPropertySymbols(e); r && (o = _filterInstanceProperty(o).call(o, function (r) { return _Object$getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread$4(e) { for (var r = 1; r < arguments.length; r++) { var _context3, _context4; var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? _forEachInstanceProperty(_context3 = ownKeys$4(Object(t), !0)).call(_context3, function (r) { _defineProperty(e, r, t[r]); }) : _Object$getOwnPropertyDescriptors ? _Object$defineProperties(e, _Object$getOwnPropertyDescriptors(t)) : _forEachInstanceProperty(_context4 = ownKeys$4(Object(t))).call(_context4, function (r) { _Object$defineProperty(e, r, _Object$getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? _Reflect$construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(_Reflect$construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function () { return !!t; })(); }
+var _bucketRegion$1 = /*#__PURE__*/_classPrivateFieldLooseKey("bucketRegion");
+var _bucketEnvironment$1 = /*#__PURE__*/_classPrivateFieldLooseKey("bucketEnvironment");
+let StorageProvider = /*#__PURE__*/function () {
+  function StorageProvider(config) {
+    _classCallCheck(this, StorageProvider);
+    _Object$defineProperty(this, _bucketRegion$1, {
+      writable: true,
+      value: void 0
+    });
+    _Object$defineProperty(this, _bucketEnvironment$1, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldLooseBase(this, _bucketRegion$1)[_bucketRegion$1] = config.bucketRegion;
+    _classPrivateFieldLooseBase(this, _bucketEnvironment$1)[_bucketEnvironment$1] = config.bucketEnvironment;
+  }
+  /**
+   *  Construct the storage bucket URL for the specific application and cloud environment.
+   *
+   *  1. Static assets are uploaded to `:bucketRegion/:prNumber?/:applicationName`
+   *  2. The application index is uploaded to `:bucketRegion/:prNumber?/:applicationName/:cloudEnvironment`
+   *
+   *  This allows all cloud environments sharing the same static assets while each application's index
+   *  is uploaded with different headers (e.g. CSP rules).
+   */
+  return _createClass(StorageProvider, [{
+    key: "getBucketNamespace",
+    value: function getBucketNamespace(prNumber) {
+      if (!prNumber) return;
+      if (prNumber === 'merchant-center-preview') return prNumber;
+      return `mc-${prNumber}`;
+    }
+
+    /**
+     *  Construct the storage bucket URL for the specific application and cloud environment.
+     */
+  }, {
+    key: "getAssetsBucketUrl",
+    value: function getAssetsBucketUrl(_ref) {
+      var _context;
+      let applicationName = _ref.applicationName,
+        bucketProtocol = _ref.bucketProtocol,
+        bucketNamespace = _ref.bucketNamespace,
+        tag = _ref.tag;
+      if (!_classPrivateFieldLooseBase(this, _bucketRegion$1)[_bucketRegion$1]) {
+        throw new Error("'bucketRegion' is not defined. Required to determine 'assetsBucketUrl'.");
+      }
+      const storageProvider = storageProviders[tag];
+      const assetBuketUrl = storageProvider.urls.bucket?.[_classPrivateFieldLooseBase(this, _bucketRegion$1)[_bucketRegion$1]] ?? _classPrivateFieldLooseBase(this, _bucketRegion$1)[_bucketRegion$1];
+      const assetsBucketUrl = _filterInstanceProperty(_context = [assetBuketUrl, bucketNamespace, applicationName]).call(_context, Boolean).join('/');
+      return `${bucketProtocol}${assetsBucketUrl}`;
+    }
+  }, {
+    key: "getApplicationIndexBucketUrl",
+    value: function getApplicationIndexBucketUrl(_ref2) {
+      let tag = _ref2.tag,
+        prNumber = _ref2.prNumber,
+        applicationName = _ref2.applicationName,
+        bucketProtocol = _ref2.bucketProtocol,
+        bucketNamespace = _ref2.bucketNamespace;
+      const applicationAssetsBucketUrl = this.getAssetsBucketUrl({
+        tag,
+        applicationName,
+        prNumber,
+        bucketProtocol,
+        bucketNamespace
+      });
+      const applicationIndexBucketUrl = `${applicationAssetsBucketUrl}/${_classPrivateFieldLooseBase(this, _bucketEnvironment$1)[_bucketEnvironment$1]}`;
+      return applicationIndexBucketUrl;
+    }
+  }, {
+    key: "getCdnUrl",
+    value: function getCdnUrl(_ref3) {
+      var _context2;
+      let applicationName = _ref3.applicationName,
+        prNumber = _ref3.prNumber,
+        publicBaseUrl = _ref3.publicBaseUrl,
+        excludeBucketRegion = _ref3.excludeBucketRegion;
+      return _filterInstanceProperty(_context2 = [publicBaseUrl, excludeBucketRegion ? null : _classPrivateFieldLooseBase(this, _bucketRegion$1)[_bucketRegion$1], this.getBucketNamespace(prNumber), applicationName]).call(_context2, Boolean).join('/');
+    }
+  }, {
+    key: "getPublicBaseUrl",
+    value: function getPublicBaseUrl(tag) {
+      if (!_classPrivateFieldLooseBase(this, _bucketEnvironment$1)[_bucketEnvironment$1]) {
+        throw new Error("'bucketEnvironment' is not defined. Required to determine 'publicBaseUrl'.");
+      }
+      const storageProvider = storageProviders[tag];
+      const publicBaseUrl = storageProvider.urls.public[_classPrivateFieldLooseBase(this, _bucketEnvironment$1)[_bucketEnvironment$1]] ?? storageProvider.urls.public.default;
+      if (!publicBaseUrl) {
+        throw new Error(`'publicBaseUrl' is not defined for '${tag}' storage provider for ${_classPrivateFieldLooseBase(this, _bucketEnvironment$1)[_bucketEnvironment$1]} or as default.`);
+      }
+      return publicBaseUrl;
+    }
+  }]);
+}();
+var _bucketRegion2$1 = /*#__PURE__*/_classPrivateFieldLooseKey("bucketRegion");
+var _bucketEnvironment2$1 = /*#__PURE__*/_classPrivateFieldLooseKey("bucketEnvironment");
+let GoogleStorageProvider = /*#__PURE__*/function (_StorageProvider2) {
+  function GoogleStorageProvider(config) {
+    var _this;
+    _classCallCheck(this, GoogleStorageProvider);
+    _this = _callSuper(this, GoogleStorageProvider, [config]);
+    _Object$defineProperty(_this, _bucketRegion2$1, {
+      writable: true,
+      value: void 0
+    });
+    _Object$defineProperty(_this, _bucketEnvironment2$1, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldLooseBase(_this, _bucketRegion2$1)[_bucketRegion2$1] = config.bucketRegion;
+    _classPrivateFieldLooseBase(_this, _bucketEnvironment2$1)[_bucketEnvironment2$1] = config.bucketEnvironment;
+    return _this;
+  }
+  _inherits(GoogleStorageProvider, _StorageProvider2);
+  return _createClass(GoogleStorageProvider, [{
+    key: "getTag",
+    value: function getTag() {
+      return 'gs';
+    }
+  }, {
+    key: "getBucketRegion",
+    value: function getBucketRegion() {
+      return _classPrivateFieldLooseBase(this, _bucketRegion2$1)[_bucketRegion2$1];
+    }
+  }, {
+    key: "getBucketEnvironment",
+    value: function getBucketEnvironment() {
+      return _classPrivateFieldLooseBase(this, _bucketEnvironment2$1)[_bucketEnvironment2$1];
+    }
+  }, {
+    key: "getProtocol",
+    value: function getProtocol() {
+      return 'gs://';
+    }
+  }, {
+    key: "getPublicBaseUrl",
+    value: function getPublicBaseUrl() {
+      return _get(_getPrototypeOf(GoogleStorageProvider.prototype), "getPublicBaseUrl", this).call(this, this.getTag());
+    }
+  }, {
+    key: "getCdnUrl",
+    value: function getCdnUrl(config) {
+      return _get(_getPrototypeOf(GoogleStorageProvider.prototype), "getCdnUrl", this).call(this, _objectSpread$4({
+        publicBaseUrl: this.getPublicBaseUrl()
+      }, config));
+    }
+  }, {
+    key: "getAssetsBucketUrl",
+    value: function getAssetsBucketUrl(config) {
+      return _get(_getPrototypeOf(GoogleStorageProvider.prototype), "getAssetsBucketUrl", this).call(this, _objectSpread$4({
+        tag: this.getTag(),
+        bucketProtocol: this.getProtocol(),
+        bucketNamespace: _get(_getPrototypeOf(GoogleStorageProvider.prototype), "getBucketNamespace", this).call(this, config.prNumber)
+      }, config));
+    }
+  }, {
+    key: "getApplicationIndexBucketUrl",
+    value: function getApplicationIndexBucketUrl(config) {
+      return _get(_getPrototypeOf(GoogleStorageProvider.prototype), "getApplicationIndexBucketUrl", this).call(this, _objectSpread$4({
+        tag: this.getTag(),
+        bucketProtocol: this.getProtocol(),
+        bucketNamespace: _get(_getPrototypeOf(GoogleStorageProvider.prototype), "getBucketNamespace", this).call(this, config.prNumber)
+      }, config));
+    }
+  }]);
+}(StorageProvider);
+var _bucketRegion3 = /*#__PURE__*/_classPrivateFieldLooseKey("bucketRegion");
+var _bucketEnvironment3 = /*#__PURE__*/_classPrivateFieldLooseKey("bucketEnvironment");
+let AwsStorageProvider = /*#__PURE__*/function (_StorageProvider3) {
+  function AwsStorageProvider(config) {
+    var _this2;
+    _classCallCheck(this, AwsStorageProvider);
+    _this2 = _callSuper(this, AwsStorageProvider, [config]);
+    _Object$defineProperty(_this2, _bucketRegion3, {
+      writable: true,
+      value: void 0
+    });
+    _Object$defineProperty(_this2, _bucketEnvironment3, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldLooseBase(_this2, _bucketRegion3)[_bucketRegion3] = config.bucketRegion;
+    _classPrivateFieldLooseBase(_this2, _bucketEnvironment3)[_bucketEnvironment3] = config.bucketEnvironment;
+    return _this2;
+  }
+  _inherits(AwsStorageProvider, _StorageProvider3);
+  return _createClass(AwsStorageProvider, [{
+    key: "getTag",
+    value: function getTag() {
+      return 's3';
+    }
+  }, {
+    key: "getBucketRegion",
+    value: function getBucketRegion() {
+      return _classPrivateFieldLooseBase(this, _bucketRegion3)[_bucketRegion3];
+    }
+  }, {
+    key: "getBucketEnvironment",
+    value: function getBucketEnvironment() {
+      return _classPrivateFieldLooseBase(this, _bucketEnvironment3)[_bucketEnvironment3];
+    }
+  }, {
+    key: "getProtocol",
+    value: function getProtocol() {
+      return 's3://';
+    }
+  }, {
+    key: "getPublicBaseUrl",
+    value: function getPublicBaseUrl() {
+      return _get(_getPrototypeOf(AwsStorageProvider.prototype), "getPublicBaseUrl", this).call(this, this.getTag());
+    }
+  }, {
+    key: "getCdnUrl",
+    value: function getCdnUrl(config) {
+      return _get(_getPrototypeOf(AwsStorageProvider.prototype), "getCdnUrl", this).call(this, _objectSpread$4({
+        publicBaseUrl: this.getPublicBaseUrl(),
+        excludeBucketRegion: true
+      }, config));
+    }
+  }, {
+    key: "getAssetsBucketUrl",
+    value: function getAssetsBucketUrl(config) {
+      return _get(_getPrototypeOf(AwsStorageProvider.prototype), "getAssetsBucketUrl", this).call(this, _objectSpread$4({
+        tag: this.getTag(),
+        bucketProtocol: this.getProtocol(),
+        bucketNamespace: _get(_getPrototypeOf(AwsStorageProvider.prototype), "getBucketNamespace", this).call(this, config.prNumber)
+      }, config));
+    }
+  }, {
+    key: "getApplicationIndexBucketUrl",
+    value: function getApplicationIndexBucketUrl(config) {
+      return _get(_getPrototypeOf(AwsStorageProvider.prototype), "getApplicationIndexBucketUrl", this).call(this, _objectSpread$4({
+        tag: this.getTag(),
+        bucketProtocol: this.getProtocol(),
+        bucketNamespace: _get(_getPrototypeOf(AwsStorageProvider.prototype), "getBucketNamespace", this).call(this, config.prNumber)
+      }, config));
+    }
+  }]);
+}(StorageProvider);
+function getStorageProvider(storageProvider, config) {
+  switch (storageProvider) {
+    case 'gs':
+      return new GoogleStorageProvider(config);
+    case 's3':
+      return new AwsStorageProvider(config);
+    default:
+      throw new Error(`Storage provider ${storageProvider} not supported`);
+  }
+}
+
+var _bucketEnvironment = /*#__PURE__*/_classPrivateFieldLooseKey("bucketEnvironment");
+var _bucketRegion = /*#__PURE__*/_classPrivateFieldLooseKey("bucketRegion");
+let GoogleStorageUploadScriptsGenerator = /*#__PURE__*/function () {
+  function GoogleStorageUploadScriptsGenerator(config) {
+    _classCallCheck(this, GoogleStorageUploadScriptsGenerator);
+    _Object$defineProperty(this, _bucketEnvironment, {
+      writable: true,
+      value: void 0
+    });
+    _Object$defineProperty(this, _bucketRegion, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldLooseBase(this, _bucketRegion)[_bucketRegion] = config.bucketRegion;
+    _classPrivateFieldLooseBase(this, _bucketEnvironment)[_bucketEnvironment] = config.bucketEnvironment;
+  }
+  return _createClass(GoogleStorageUploadScriptsGenerator, [{
+    key: "getApplicationIndexUploadScript",
+    value: function getApplicationIndexUploadScript(_ref) {
+      let packageManagerName = _ref.packageManagerName,
+        bucketUrl = _ref.bucketUrl,
+        cdnUrl = _ref.cdnUrl,
+        buildRevision = _ref.buildRevision,
+        buildNumber = _ref.buildNumber,
+        applicationIndexOutFile = _ref.applicationIndexOutFile;
+      if (!_classPrivateFieldLooseBase(this, _bucketEnvironment)[_bucketEnvironment]) {
+        throw new Error("Missing 'bucketEnvironment' when generating application index.");
+      }
+      return `
+#!/usr/bin/env bash
+
+set -e
+
+echo "Uploading compiled ${applicationIndexOutFile} to Google Storage bucket ${bucketUrl}"
+
+gcloud storage cp \\
+  "$(dirname "$0")/${applicationIndexOutFile}" \\
+  "${bucketUrl}/" \\
+  -z html \\
+  --content-type="text/html" \\
+  --cache-control="public,max-age=0,no-transform"
+
+echo "Creating version.json and uploading it to bucket ${bucketUrl}"
+
+NODE_ENV=production ${packageManagerName} application-cli create-version \\
+  --version-url=${cdnUrl}/${_classPrivateFieldLooseBase(this, _bucketEnvironment)[_bucketEnvironment]}/version.json \\
+  --build-revision=${buildRevision} \\
+  --build-number=${buildNumber} \\
+  --out-file=$(dirname "$0")/version.json
+
+gcloud storage cp \\
+  "$(dirname "$0")/version.json" \\
+  "${bucketUrl}/" \\
+  -z json \\
+  --content-type="application/json" \\
+  --cache-control="public,max-age=0,no-transform"
+`;
+    }
+  }, {
+    key: "getProductionBundlesUploadScript",
+    value: function getProductionBundlesUploadScript(_ref2) {
+      let bucketUrl = _ref2.bucketUrl,
+        assetsPath = _ref2.assetsPath,
+        skipMenu = _ref2.skipMenu;
+      return `
+#!/usr/bin/env bash
+
+set -e
+
+# NOTES:
+# https://cloud.google.com/sdk/gcloud/reference/storage/cp
+#     1. The '-z' option triggers compressing the assets before
+#        uploading them and sets the 'Content-Encoding' to 'gzip'.
+#     2. The 'Accept-encoding: gzip' is set automatically by the 'gcloud storage'.
+#     3. The 'max-age' is set to 1 year which is considered the maximum
+#        "valid" lifetime of an asset to be cached.
+#     4. The '-n' will skip uploading existing files and prevents them to
+#        be overwritten
+echo "Uploading static assets to Google Storage bucket ${bucketUrl}"
+
+gcloud storage cp \\
+  ${assetsPath}/public/{*.css,*.js,*.js.map,*.html} \\
+  "${bucketUrl}" \\
+  -n \\
+  -z js,css \\
+  --cache-control="public,max-age=31536000,no-transform"
+
+# We need to upload the PNG and HTML files separately because we want them
+# to be able to overwrite the existing files (if any). For instance, the
+# file or the favicons.
+# This is controlled with the '-n' option (which is used for the JS and CSS
+# as we don't want to overwrite them)
+gcloud storage cp \\
+  ${assetsPath}/public/{*.png,robots.txt} \\
+  "${bucketUrl}" \\
+  -z txt \\
+  --cache-control="public,max-age=31536000,no-transform"
+
+if ${skipMenu}; then
+  echo "Skipping menu.json upload"
+else
+  echo "Uploading menu.json to bucket ${bucketUrl}"
+  # NOTE: somehow the 'cache-control:private' doesn't work.
+  # I mean, the file is uploaded with the correct metadata but when I fetch
+  # the file the response contains the header
+  # 'cache-control: public,max-age=31536000,no-transform', even though the
+  # documentation clearly states that by marking the header as 'private' will
+  # disable the cache (for publicly readable objects).
+  # https://cloud.google.com/storage/docs/gsutil/addlhelp/WorkingWithObjectMetadata#cache-control
+  # However, I found out that, by requesting the file with any RANDOM
+  # query parameter, will instruct the storage to return a 'fresh' object
+  # (without any cache control).
+  # Unofficial source: https://stackoverflow.com/a/49052895
+  # This seems to be the 'easiest' option to 'disable' the cache for public
+  # objects. Other alternative approaces are:
+  #   * make the object private with some simple ACL (private objects are not cached)
+  #   * suffix the file name with e.g. the git SHA, so we have different files
+  #   for each upload ('index.html.template-\${CIRCLE_SHA1}'). The server knows
+  #   the git SHA on runtime and can get the correct file when it starts.
+  #   * find out why the 'private' cache control does not work
+  gcloud storage cp \\
+    ${assetsPath}/menu.json \\
+    ${bucketUrl} \\
+    -z json \\
+    --content-type="application/json" \\
+    --cache-control="public,max-age=0,no-transform"
+fi
+`;
+    }
+  }]);
+}();
+var _bucketEnvironment2 = /*#__PURE__*/_classPrivateFieldLooseKey("bucketEnvironment");
+var _bucketRegion2 = /*#__PURE__*/_classPrivateFieldLooseKey("bucketRegion");
+let AwsStorageUploadScriptsGenerator = /*#__PURE__*/function () {
+  function AwsStorageUploadScriptsGenerator(config) {
+    _classCallCheck(this, AwsStorageUploadScriptsGenerator);
+    _Object$defineProperty(this, _bucketEnvironment2, {
+      writable: true,
+      value: void 0
+    });
+    _Object$defineProperty(this, _bucketRegion2, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldLooseBase(this, _bucketRegion2)[_bucketRegion2] = config.bucketRegion;
+    _classPrivateFieldLooseBase(this, _bucketEnvironment2)[_bucketEnvironment2] = config.bucketEnvironment;
+  }
+  return _createClass(AwsStorageUploadScriptsGenerator, [{
+    key: "getApplicationIndexUploadScript",
+    value: function getApplicationIndexUploadScript(_ref3) {
+      let packageManagerName = _ref3.packageManagerName,
+        bucketUrl = _ref3.bucketUrl,
+        cdnUrl = _ref3.cdnUrl,
+        buildRevision = _ref3.buildRevision,
+        buildNumber = _ref3.buildNumber,
+        applicationIndexOutFile = _ref3.applicationIndexOutFile;
+      return `
+    #!/usr/bin/env bash
+
+    echo "Uploading static assets to Amazon S3 bucket ${bucketUrl}"
+
+    set -e
+
+    aws s3 cp "$(dirname "$0")/${applicationIndexOutFile}" \\
+      "${bucketUrl}/" \\
+      --content-type="text/html" \\
+      --cache-control="public,max-age=0,no-transform" \\
+      --profile ${_classPrivateFieldLooseBase(this, _bucketRegion2)[_bucketRegion2]}
+
+    echo "Creating version.json and uploading it to bucket ${bucketUrl}"
+
+    NODE_ENV=production ${packageManagerName} application-cli create-version \\
+      --version-url=${cdnUrl}/${_classPrivateFieldLooseBase(this, _bucketEnvironment2)[_bucketEnvironment2]}/version.json \\
+      --build-revision=${buildRevision} \\
+      --build-number=${buildNumber} \\
+      --out-file=$(dirname "$0")/version.json
+
+    aws s3 cp "$(dirname "$0")/version.json" \\
+      "${bucketUrl}/" \\
+      --content-type="application/json" \\
+      --cache-control="public,max-age=0,no-transform" \\
+      --profile ${_classPrivateFieldLooseBase(this, _bucketRegion2)[_bucketRegion2]}
+`;
+    }
+  }, {
+    key: "getProductionBundlesUploadScript",
+    value: function getProductionBundlesUploadScript(_ref4) {
+      let bucketUrl = _ref4.bucketUrl,
+        assetsPath = _ref4.assetsPath,
+        skipMenu = _ref4.skipMenu;
+      return `
+#!/usr/bin/env bash
+
+echo "Uploading static assets to Amazon S3 bucket ${bucketUrl}"
+
+set -e
+
+# NOTE:
+#   The sync command on the AWS CLI is different to the -n option on the gcloud CLI.
+#   Sync will only upload files that are not already in the bucket, but it will skip existing ones
+#   that have been changed locally.
+#   The -n option on the gcloud CLI will skip uploading existing files and prevents them to be overwritten.
+#   https://docs.aws.amazon.com/cli/latest/reference/s3/sync.html
+#   https://cloud.google.com/sdk/gcloud/reference/storage/cp
+#
+#   Compression (gzip) is enabled on CloudFront by default. Hence compression does happing while uploading.
+#   https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/ServingCompressedFiles.html#compressed-content-cloudfront-configuring
+aws s3 sync ${assetsPath}/public \\
+  "${bucketUrl}" \\
+  --exclude "*" \\
+  --include "*.css" \\
+  --include "*.js" \\
+  --include "*.js.map" \\
+  --include "*.html" \\
+  --cache-control="public,max-age=31536000,no-transform" \\
+  --profile ${_classPrivateFieldLooseBase(this, _bucketRegion2)[_bucketRegion2]}
+
+# We need to upload the PNG and HTML files separately because we want them
+# to be able to overwrite the existing files (if any). For instance, the
+# file or the favicons.
+aws s3 cp ${assetsPath}/public \\
+  "${bucketUrl}" \\
+  --recursive \\
+  --exclude "*" \\
+  --include "*.png" \\
+  --include "robots.txt" \\
+  --cache-control="public,max-age=31536000,no-transform" \\
+  --profile ${_classPrivateFieldLooseBase(this, _bucketRegion2)[_bucketRegion2]}
+
+if ${skipMenu}; then
+  echo "Skipping menu.json upload"
+else
+  echo "Uploading menu.json to bucket ${bucketUrl}"
+
+  aws s3 cp ${assetsPath}/menu.json \\
+    "${bucketUrl}/" \\
+    --content-type="application/json" \\
+    --cache-control="public,max-age=0,no-transform" \\
+    --profile ${_classPrivateFieldLooseBase(this, _bucketRegion2)[_bucketRegion2]}
+fi
+`;
+    }
+  }]);
+}();
+function getUploadScriptsGenerator(storageProvider, config) {
+  switch (storageProvider) {
+    case 'gs':
+      return new GoogleStorageUploadScriptsGenerator(config);
+    case 's3':
+      return new AwsStorageUploadScriptsGenerator(config);
+    default:
+      throw new Error(`Storage provider ${storageProvider} not supported`);
+  }
+}
+
+function doesFileExist(filePath) {
+  try {
+    fs$1.accessSync(filePath);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+function ownKeys$3(e, r) { var t = _Object$keys(e); if (_Object$getOwnPropertySymbols) { var o = _Object$getOwnPropertySymbols(e); r && (o = _filterInstanceProperty(o).call(o, function (r) { return _Object$getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread$3(e) { for (var r = 1; r < arguments.length; r++) { var _context, _context2; var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? _forEachInstanceProperty(_context = ownKeys$3(Object(t), !0)).call(_context, function (r) { _defineProperty(e, r, t[r]); }) : _Object$getOwnPropertyDescriptors ? _Object$defineProperties(e, _Object$getOwnPropertyDescriptors(t)) : _forEachInstanceProperty(_context2 = ownKeys$3(Object(t))).call(_context2, function (r) { _Object$defineProperty(e, r, _Object$getOwnPropertyDescriptor(t, r)); }); } return e; }
+function loadDotenvFiles(_ref) {
+  let dotenvPath = _ref.dotenvPath,
+    cloudEnvironment = _ref.cloudEnvironment;
+  // No path requested, skip.
+  if (!dotenvPath) {
+    return {};
+  }
+
+  // Check if the given path exists.
+  if (!doesFileExist(dotenvPath)) {
+    throw new Error(`The dotenv folder path does not exist: "${dotenvPath}".`);
+  }
+
+  // Load the environment values
+  const sharedDotenvFile = '.env.production';
+  const cloudDotenvFile = `.env.${cloudEnvironment}`;
+
+  // The shared dotenv file across environments is optional
+  const sharedProductionEnvironment = dotenv.config({
+    encoding: 'utf8',
+    path: path.join(dotenvPath, sharedDotenvFile)
+  });
+  const cloudSpecificProductionEnvironment = dotenv.config({
+    encoding: 'utf8',
+    path: path.join(dotenvPath, cloudDotenvFile)
+  });
+  if (cloudSpecificProductionEnvironment.error) {
+    throw new Error(`Failed loading '${cloudDotenvFile}' in '${dotenvPath}'. Make sure it exists.`);
+  }
+  if (sharedProductionEnvironment.error) {
+    throw new Error(`Failed loading '${sharedDotenvFile}' in '${dotenvPath}'. Make sure it exists.`);
+  }
+  return _objectSpread$3(_objectSpread$3({}, sharedProductionEnvironment.parsed), cloudSpecificProductionEnvironment.parsed);
+}
+
+function ownKeys$2(e, r) { var t = _Object$keys(e); if (_Object$getOwnPropertySymbols) { var o = _Object$getOwnPropertySymbols(e); r && (o = _filterInstanceProperty(o).call(o, function (r) { return _Object$getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread$2(e) { for (var r = 1; r < arguments.length; r++) { var _context3, _context4; var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? _forEachInstanceProperty(_context3 = ownKeys$2(Object(t), !0)).call(_context3, function (r) { _defineProperty(e, r, t[r]); }) : _Object$getOwnPropertyDescriptors ? _Object$defineProperties(e, _Object$getOwnPropertyDescriptors(t)) : _forEachInstanceProperty(_context4 = ownKeys$2(Object(t))).call(_context4, function (r) { _Object$defineProperty(e, r, _Object$getOwnPropertyDescriptor(t, r)); }); } return e; }
+function writeUploadScriptFile(_ref) {
+  let fileName = _ref.fileName,
+    fileContent = _ref.fileContent,
+    filePath = _ref.filePath;
+  fs.writeFileSync(path$1.join(filePath, fileName), fileContent, {
+    // Make the script executable
+    mode: 0o755,
+    encoding: 'utf8'
+  });
+}
+async function compileApplicationAssets(_ref2) {
+  let cliFlags = _ref2.cliFlags,
+    storageProvider = _ref2.storageProvider,
+    uploadScriptsGenerator = _ref2.uploadScriptsGenerator,
+    paths = _ref2.paths;
+  const applicationAssetsUploadScriptContent = uploadScriptsGenerator.getProductionBundlesUploadScript({
+    storageProvider,
+    bucketUrl: storageProvider.getAssetsBucketUrl({
+      prNumber: cliFlags.prNumber,
+      applicationName: cliFlags.applicationName
+    }),
+    assetsPath: paths.assetsPath,
+    skipMenu: cliFlags.skipMenu
+  });
+  const parsedApplicationAssetsUploadScriptFile = path$1.parse(cliFlags.applicationAssetsUploadScriptOutFile);
+  const applicationAssetsUploadScriptFileName = `${parsedApplicationAssetsUploadScriptFile.name}-${storageProvider.getBucketRegion()}${parsedApplicationAssetsUploadScriptFile.ext}`;
+  writeUploadScriptFile({
+    fileName: applicationAssetsUploadScriptFileName,
+    fileContent: applicationAssetsUploadScriptContent,
+    filePath: path$1.join(paths.deploymentsPath, storageProvider.getTag())
+  });
+}
+async function compileEnvironmentApplicationIndexes(_ref3) {
+  let cliFlags = _ref3.cliFlags,
+    storageProvider = _ref3.storageProvider,
+    uploadScriptsGenerator = _ref3.uploadScriptsGenerator,
+    paths = _ref3.paths,
+    cloudEnvironment = _ref3.cloudEnvironment;
+  const cloudEnvironmentDeploymentPath = path$1.join(paths.deploymentsPath, storageProvider.getTag(), cloudEnvironment);
+  // Ensure the folder exists
+  const createDeploymentsFolderResult = await execa('mkdir', ['-p', cloudEnvironmentDeploymentPath], {
+    encoding: 'utf8'
+  });
+  if (createDeploymentsFolderResult.failed) {
+    throw new Error(createDeploymentsFolderResult.stderr);
+  }
+
+  // Construct the proper CDN URL for the specific application
+  const cdnUrl = storageProvider.getCdnUrl({
+    prNumber: cliFlags.prNumber,
+    applicationName: cliFlags.applicationName
+  });
+  const environmentVariablesForCompilation = _objectSpread$2(_objectSpread$2(_objectSpread$2(_objectSpread$2({}, loadDotenvFiles({
+    dotenvPath: paths.dotenvPath,
+    cloudEnvironment
+  })), {}, {
+    // The trailing slash is important to indicate to the CSP directive that all the resources
+    // under that path should be allowed.
+    MC_CDN_URL: `${cdnUrl}/`
+  }, cliFlags.mcUrl ? {
+    MC_URL: cliFlags.mcUrl
+  } : {}), cliFlags.mcApiUrl ? {
+    MC_API_URL: cliFlags.mcApiUrl
+  } : {}), {}, {
+    // Will be used by the Application Kit for Sentry and exposed on `window.app.revision`.
+    REVISION: cliFlags.buildRevision
+  });
+
+  /// Sentry and GTM is disabled on branch deployments
+  if (cliFlags.prNumber) {
+    // @ts-expect-error The env is sometimes overwritten by code to a boolean
+    process.env.TRACKING_SENTRY = null;
+    // @ts-expect-error The env is sometimes overwritten by code to a boolean
+    process.env.TRACKING_GTM = null;
+    // @ts-expect-error
+    environmentVariablesForCompilation.TRACKING_SENTRY = null;
+    // @ts-expect-error
+    environmentVariablesForCompilation.TRACKING_GTM = null;
+  }
+
+  // Compile the application using the loaded environment values
+  const compileResult = await execa('mc-scripts', ['compile-html'], {
+    encoding: 'utf8',
+    preferLocal: true,
+    extendEnv: true,
+    env: environmentVariablesForCompilation
+  });
+  if (compileResult.failed) {
+    throw new Error(compileResult.stderr);
+  }
+  const applicationIndexUploadScriptContent = uploadScriptsGenerator.getApplicationIndexUploadScript({
+    storageProvider,
+    packageManagerName: cliFlags.packageManagerName,
+    bucketUrl: storageProvider.getApplicationIndexBucketUrl({
+      prNumber: cliFlags.prNumber,
+      applicationName: cliFlags.applicationName
+    }),
+    cdnUrl,
+    buildRevision: cliFlags.buildRevision,
+    buildNumber: cliFlags.buildNumber,
+    applicationIndexOutFile: cliFlags.applicationIndexOutFile
+  });
+  writeUploadScriptFile({
+    fileName: cliFlags.applicationIndexUploadScriptOutFile,
+    fileContent: applicationIndexUploadScriptContent,
+    filePath: cloudEnvironmentDeploymentPath
+  });
+
+  // Move the compiled `index.html` to the deployments folder of the related cloud environment.
+  const moveResult = await execa('mv', [path$1.join(paths.publicAssetsPath, 'index.html'), path$1.join(cloudEnvironmentDeploymentPath, cliFlags.applicationIndexOutFile)]);
+  if (moveResult.failed) {
+    throw new Error(moveResult.stderr);
+  }
+}
+async function command$4(cliFlags, cwd) {
+  var _context;
+  const storageBucketConfig = await loadStorageBucketsConfig();
+  const applicationDirectory = getApplicationDirectory(cwd);
+  let assetsPath;
+  if (cliFlags.ciAssetsRootPath && isCI()) {
+    assetsPath = applicationDirectory.replace('/home/circleci/', cliFlags.ciAssetsRootPath);
+  } else {
+    assetsPath = applicationDirectory;
+  }
+  const monorepoRoot = findRootSync(cwd);
+  const paths = {
+    publicAssetsPath: resolveInApplication('public', cwd),
+    deploymentsPath: resolveInApplication('deployments', cwd),
+    dotenvPath: cliFlags.dotenvFolder && path$1.join(monorepoRoot.rootDir, cliFlags.dotenvFolder),
+    assetsPath
+  };
+  const defaultStorageProviders = [storageProviders.gs.tag];
+  const taskList = new Listr(_mapInstanceProperty(_context = _Object$entries(storageBucketConfig)).call(_context, _ref4 => {
+    let _ref5 = _slicedToArray(_ref4, 2),
+      bucketRegion = _ref5[0],
+      bucketEnvironmentConfigs = _ref5[1];
+    return {
+      title: `Compiling for bucket region ${bucketRegion}`,
+      task: (_bucketRegionCtx, bucketRegionTask) => {
+        // NOTE: Application assets need to be compiled
+        // for all storage providers once per region.
+        const allStorageProvidersForBucketRegion = [...new _Set(_flatMapInstanceProperty(bucketEnvironmentConfigs).call(bucketEnvironmentConfigs, bucketEnvironmentConfig => bucketEnvironmentConfig.storageProviders || defaultStorageProviders))];
+        const allApplicationAssetTasks = _mapInstanceProperty(allStorageProvidersForBucketRegion).call(allStorageProvidersForBucketRegion, storageProviderTag => {
+          const uploadScriptsGeneratorConfig = {
+            bucketRegion: bucketRegion
+          };
+          const storageProviderConfig = {
+            bucketRegion: bucketRegion
+          };
+          const storageProvider = getStorageProvider(storageProviderTag, storageProviderConfig);
+          const uploadScriptsGenerator = getUploadScriptsGenerator(storageProviderTag, uploadScriptsGeneratorConfig);
+          return {
+            title: `Compiling application assets for '${storageProviderTag}'`,
+            task: () => compileApplicationAssets({
+              cliFlags,
+              storageProvider,
+              uploadScriptsGenerator,
+              paths
+            })
+          };
+        });
+        const allApplicationIndexTasks = _mapInstanceProperty(bucketEnvironmentConfigs).call(bucketEnvironmentConfigs, bucketEnvironmentConfig => {
+          const cloudEnvironment = bucketEnvironmentConfig.cloudEnvironment,
+            bucketEnvironment = bucketEnvironmentConfig.bucketEnvironment,
+            storageProviders = bucketEnvironmentConfig.storageProviders;
+          const storageProviderConfig = {
+            bucketRegion: bucketRegion,
+            bucketEnvironment
+          };
+          return {
+            title: `Compiling for cloud environment '${cloudEnvironment}'`,
+            task: (_storageProviderCtx, storageProviderTask) => {
+              var _context2;
+              const applicationIndexTasksForStorageProviders = _mapInstanceProperty(_context2 = storageProviders || defaultStorageProviders).call(_context2, storageProviderTag => {
+                const storageProvider = getStorageProvider(storageProviderTag, storageProviderConfig);
+                const uploadScriptsGenerator = getUploadScriptsGenerator(storageProviderTag, storageProviderConfig);
+                return {
+                  title: `Compiling application index for storage provider '${storageProviderTag}'`,
+                  task: () => {
+                    return compileEnvironmentApplicationIndexes({
+                      cliFlags,
+                      storageProvider,
+                      uploadScriptsGenerator,
+                      paths,
+                      cloudEnvironment
+                    });
+                  }
+                };
+              });
+              return storageProviderTask.newListr(applicationIndexTasksForStorageProviders);
+            }
+          };
+        });
+        return bucketRegionTask.newListr([...allApplicationIndexTasks, ...allApplicationAssetTasks]);
+      }
+    };
+  }), {
+    // @ts-ignore
+    renderer: isCI() ? 'verbose' : 'default'
+  });
+  await taskList.run();
+}
+
+function ownKeys$1(e, r) { var t = _Object$keys(e); if (_Object$getOwnPropertySymbols) { var o = _Object$getOwnPropertySymbols(e); r && (o = _filterInstanceProperty(o).call(o, function (r) { return _Object$getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread$1(e) { for (var r = 1; r < arguments.length; r++) { var _context3, _context4; var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? _forEachInstanceProperty(_context3 = ownKeys$1(Object(t), !0)).call(_context3, function (r) { _defineProperty(e, r, t[r]); }) : _Object$getOwnPropertyDescriptors ? _Object$defineProperties(e, _Object$getOwnPropertyDescriptors(t)) : _forEachInstanceProperty(_context4 = ownKeys$1(Object(t))).call(_context4, function (r) { _Object$defineProperty(e, r, _Object$getOwnPropertyDescriptor(t, r)); }); } return e; }
+
+// The menu links are only parsed from the config in development mode.
+process.env.NODE_ENV = 'development';
+const mapLabelAllLocalesWithDefaults = (labelAllLocales, defaultLabel) => {
+  let mappedLabelAllLocales = labelAllLocales;
+  if (defaultLabel) {
+    var _context;
+    // Map all supported locales with the given localized labels.
+    // If a locale is not defined in the config, we use the `default` label as the value.
+    // This is only needed for development as we're trying to map two different schemas.
+    mappedLabelAllLocales = _mapInstanceProperty(_context = getSupportedLocales()).call(_context, supportedLocale => {
+      const existingField = _findInstanceProperty(labelAllLocales).call(labelAllLocales, field => field.locale === supportedLocale);
+      if (existingField) return existingField;
+      return {
+        locale: supportedLocale,
+        value: defaultLabel
+      };
+    });
+  }
+  return mappedLabelAllLocales;
+};
+
+/**
+ * Transform menu links defined in the `custom-application-config.json` to the format
+ * used by the HTTP Proxy GraphQL API.
+ */
+
+const mapApplicationMenuConfigToGraqhQLMenuJson = config => {
+  var _context2;
+  const entryPointUriPath = config.env.entryPointUriPath;
+
+  // @ts-expect-error: the `accountLinks` is not explicitly typed as it's only used by the account app.
+  const accountLinks = config.env.__DEVELOPMENT__?.accountLinks ?? [];
+  if (accountLinks.length > 0) {
+    return _mapInstanceProperty(accountLinks).call(accountLinks, menuLink => ({
+      key: menuLink.uriPath,
+      uriPath: menuLink.uriPath,
+      labelAllLocales: mapLabelAllLocalesWithDefaults(menuLink.labelAllLocales, menuLink.defaultLabel),
+      permissions: menuLink.permissions ?? [],
+      // @ts-ignore: not defined in schema, as it's only used internally.
+      featureToggle: menuLink.featureToggle ?? null
+    }));
+  }
+  const menuLinks = config.env.__DEVELOPMENT__?.menuLinks;
+  return {
+    key: entryPointUriPath,
+    uriPath: entryPointUriPath,
+    icon: menuLinks.icon,
+    labelAllLocales: mapLabelAllLocalesWithDefaults(menuLinks?.labelAllLocales, menuLinks?.defaultLabel),
+    permissions: menuLinks.permissions,
+    // @ts-ignore: not defined in schema, as it's only used internally.
+    featureToggle: menuLinks.featureToggle ?? null,
+    // @ts-ignore: not defined in schema, as it's only used internally.
+    menuVisibility: menuLinks.menuVisibility ?? null,
+    // @ts-ignore: not defined in schema, as it's only used internally.
+    actionRights: menuLinks.actionRights ?? null,
+    // @ts-ignore: not defined in schema, as it's only used internally.
+    dataFences: menuLinks.dataFences ?? null,
+    submenu: _mapInstanceProperty(_context2 = menuLinks.submenuLinks).call(_context2, submenuLink => ({
+      key: submenuLink.uriPath.replace('/', '-'),
+      uriPath: submenuLink.uriPath,
+      labelAllLocales: mapLabelAllLocalesWithDefaults(submenuLink.labelAllLocales, submenuLink.defaultLabel),
+      permissions: submenuLink.permissions,
+      // @ts-ignore: not defined in schema, as it's only used internally.
+      featureToggle: submenuLink.featureToggle ?? null,
+      // @ts-ignore: not defined in schema, as it's only used internally.
+      menuVisibility: submenuLink.menuVisibility ?? null,
+      // @ts-ignore: not defined in schema, as it's only used internally.
+      actionRights: submenuLink.actionRights ?? null,
+      // @ts-ignore: not defined in schema, as it's only used internally.
+      dataFences: submenuLink.dataFences ?? null
+    })),
+    // @ts-ignore: not defined in schema, as it's only used internally.
+    shouldRenderDivider: menuLinks.shouldRenderDivider ?? false
+  };
+};
+async function command$3(cliFlags, cwd) {
+  const applicationDirectory = getApplicationDirectory(cwd);
+  const monorepoRoot = findRootSync(cwd);
+  const dotenvPath = cliFlags.dotenvFolder && path.join(monorepoRoot.rootDir, cliFlags.dotenvFolder);
+
+  // The env itself is not important for the menu. However, the application config
+  // uses environment placeholders and therefore we need to provide the variables for it.
+  const cloudEnvironment = clusterContexts['ctp_staging_gcp_europe-west1_v1'];
+  const processEnv = _objectSpread$1(_objectSpread$1({}, loadDotenvFiles({
+    dotenvPath,
+    cloudEnvironment
+  })), {}, {
+    // Again, make sure that the environment is "development", otherwise
+    // the menu config won't be available.
+    NODE_ENV: 'development',
+    MC_APP_ENV: 'development',
+    // Something random, just to have environment variable defined.
+    REVISION: '123'
+  });
+  const applicationRuntimeConfig = await processConfig({
+    disableCache: true,
+    applicationPath: applicationDirectory,
+    processEnv
+  });
+  const applicationMenu = mapApplicationMenuConfigToGraqhQLMenuJson(applicationRuntimeConfig);
+  const formattedJson = _JSON$stringify(applicationMenu, null, 2);
+  fs$1.writeFileSync(path.join(applicationDirectory, 'menu.json'), formattedJson, {
+    encoding: 'utf8'
+  });
+}
+
+async function command$2(cliFlags) {
+  const numberOfRollbacks = cliFlags.rollbacks - 1;
+  let nextRollbacks;
+  try {
+    var _context, _context2;
+    // The last build's JSON becomes the first rollback
+    // while all previous rollbacks remain but are sliced.
+    const lastVersionResponse = await fetch(cliFlags.versionUrl);
+    const lastVersionJson = await lastVersionResponse.json();
+    const previousBuild = lastVersionJson && {
+      buildNumber: lastVersionJson.buildNumber,
+      revision: lastVersionJson.revision,
+      deployedAt: lastVersionJson.deployedAt
+    };
+    nextRollbacks = _sliceInstanceProperty(_context = _filterInstanceProperty(_context2 = [previousBuild, ...lastVersionJson.rollbacks]).call(_context2, Boolean)).call(_context, 0, numberOfRollbacks);
+  } catch (error) {
+    nextRollbacks = [];
+  }
+  const nextBuild = {
+    buildNumber: cliFlags.buildNumber,
+    revision: cliFlags.buildRevision,
+    deployedAt: new Date().toISOString(),
+    rollbacks: nextRollbacks
+  };
+  const formattedJson = _JSON$stringify(nextBuild, null, 2);
+  // Logging to stdout which is from where it will be picked
+  // up by the caller (a bash script).
+  if (cliFlags.outFile) {
+    fs$1.writeFileSync(cliFlags.outFile, formattedJson, {
+      encoding: 'utf8'
+    });
+  } else {
+    console.log(formattedJson);
+  }
+}
+
+/**
+ * This is heavily inspired by https://circleci.com/developer/orbs/orb/circleci/path-filtering.
+ *
+ * It detects changed files between `HEAD` and a base revision.
+ * To match them against configured RegEx tr
+ * All matched triggers will be written as a dotenv file.
+ * The dotenv file is read in a CircleCI step and be evaluated.
+ */
+const git = {
+  // https://git-scm.com/docs/git-merge-base
+  base: (baseBranch, headRevision) => `git merge-base ${baseBranch} ${headRevision}`,
+  // https://git-scm.com/docs/git-diff
+  changedFiles: (mergeRevision, headRevision) => `git diff --name-only ${mergeRevision} ${headRevision}`,
+  commitMessage: headRevision => `git log --format=oneline -n 1 ${headRevision}`
+};
+const helpers = {
+  async writeOutDotEnvFile(cliFlags, cwd, matchingTriggers) {
+    var _context;
+    // If desired read the env file and write out the matching triggers.
+    if (!cliFlags.outEnvFile) {
+      return;
+    }
+    const filePath = path$1.join(fs.realpathSync(cwd), cliFlags.outEnvFile);
+    const fileContents = _mapInstanceProperty(_context = _Object$entries(matchingTriggers)).call(_context, _ref => {
+      let _ref2 = _slicedToArray(_ref, 2),
+        triggerName = _ref2[0],
+        triggerValue = _ref2[1];
+      const triggerNameForEnvFile = `${snakeCase(triggerName).toUpperCase()}`;
+
+      // General pipeline optimization hints are not transformed
+      if (_startsWithInstanceProperty(triggerName).call(triggerName, 'allowPipelineOptimizations')) {
+        return `${triggerNameForEnvFile}=${triggerValue}`;
+      }
+      return `DID_${triggerNameForEnvFile}_CHANGE=${triggerValue}`;
+    }).join('\n');
+    await fs.promises.writeFile(filePath, fileContents);
+    if (!cliFlags.silent) {
+      console.log(`📝 Wrote out file to '${filePath}' with contents:`);
+      console.log(fileContents);
+    }
+  },
+  async getChangedFiles(cliFlags) {
+    var _context2, _context3;
+    const baseCmdResult = await command$5(git.base(cliFlags.baseBranch, cliFlags.headRevision));
+    const mergeRevision = baseCmdResult.stdout;
+    const changedFilesCmdResult = await command$5(git.changedFiles(mergeRevision, cliFlags.headRevision));
+    const changedFiles = _filterInstanceProperty(_context2 = _mapInstanceProperty(_context3 = changedFilesCmdResult.stdout.split('\n')).call(_context3, filePath => _trimInstanceProperty(filePath).call(filePath))).call(_context2, filePath => filePath.length > 0);
+    return changedFiles;
+  },
+  async matchTriggersAgainstChangedFiles(cliFlags, config, changedFiles) {
+    const matchedTriggers = {};
+
+    // Evaluate each trigger against each file.
+    _forEachInstanceProperty(config).call(config, async trigger => {
+      const hasTriggerBeenInitialized = typeof matchedTriggers[trigger.name] === 'number';
+
+      // Given the trigger with this name was never evaluated it has to be defaulted to 0.
+      // As without any matches we should indicate nothing changed.
+      if (!hasTriggerBeenInitialized) {
+        matchedTriggers[trigger.name] = 0;
+      }
+      // Given the trigger was already evaluated to be positive we can skip this evaluation.
+      if (matchedTriggers[trigger.name] === 1) {
+        return matchedTriggers;
+      }
+
+      // In any other case we evaluate this trigger.
+      const anyFileChangedForTrigger = _someInstanceProperty(micromatch).call(micromatch, changedFiles, trigger.include, {
+        ignore: trigger.ignore
+      });
+      if (!cliFlags.silent && anyFileChangedForTrigger) {
+        console.log(`ℹ️ Files for trigger ${trigger.name} changed.`);
+      }
+      let onlyExcludedFilesChangedForTrigger = false;
+      if (trigger.exclude?.length > 0) {
+        // NOTE: `micromatch.every` evaluates if every file matches
+        // every pattern.
+        // We need to evaluate if every file matches some pattern.
+        onlyExcludedFilesChangedForTrigger = _everyInstanceProperty(changedFiles).call(changedFiles, changedFile => {
+          return micromatch.isMatch(changedFile, trigger.exclude, {
+            ignore: trigger.ignore
+          });
+        });
+      }
+      if (!cliFlags.silent && onlyExcludedFilesChangedForTrigger) {
+        console.log(`ℹ️ Only excluded files for trigger ${trigger.name} changed.`);
+      }
+      if (onlyExcludedFilesChangedForTrigger) {
+        matchedTriggers[trigger.name] = 0;
+      } else {
+        matchedTriggers[trigger.name] = Number(anyFileChangedForTrigger);
+      }
+      return matchedTriggers;
+    });
+    return matchedTriggers;
+  }
+};
+async function command$1(cliFlags, config, cwd) {
+  const enablePipelineOptimizations = process.env.ENABLE_PIPELINE_OPTIMIZATIONS === '1';
+  const isDevelopmentBranch = cliFlags.branch !== cliFlags.baseBranch;
+  const triggersContainingSharedFiles = _filterInstanceProperty(config).call(config, trigger => trigger.containsSharedFiles);
+  if (!cliFlags.silent) {
+    console.log(`ℹ️ Pipeline optimizations are ${enablePipelineOptimizations ? 'enabled' : 'disabled'}.`);
+    console.log(`ℹ️ Changes have been commited to the ${isDevelopmentBranch ? 'a development' : 'the main'} branch.`);
+    console.log(`🚧 Comparing '${cliFlags.baseBranch}' against '${cliFlags.headRevision}' to determine changed files.`);
+  }
+
+  // Collect and parse changed files from git comparing base and head revision.
+  const changedFiles = await helpers.getChangedFiles(cliFlags);
+  if (!cliFlags.silent) {
+    if (changedFiles.length === 0) {
+      console.log(`ℹ️ No changes found.`);
+    } else {
+      console.log(`ℹ️ ${changedFiles.length} changes found.`);
+    }
+  }
+
+  // Read the trigger file to match the changed files against.
+  const matchedTriggers = await helpers.matchTriggersAgainstChangedFiles(cliFlags, config, changedFiles);
+  const commitMessageCmdResult = await command$5(git.commitMessage(cliFlags.headRevision));
+  const commitMessage = commitMessageCmdResult.stdout;
+  const hasCommitMessageTrigger = commitMessage && _includesInstanceProperty(commitMessage).call(commitMessage, '[ci all]');
+  const doesSharedTriggerMatch = _someInstanceProperty(triggersContainingSharedFiles).call(triggersContainingSharedFiles, triggerContainingSharedFiles => matchedTriggers[triggerContainingSharedFiles.name] === 1);
+  if (!cliFlags.silent) {
+    console.log(`ℹ️ The git commit message ${hasCommitMessageTrigger ? 'does' : 'does not'} contain a [ci all] trigger.`);
+  }
+  const doesPackageFolderTriggerMatch = matchedTriggers[cliFlags.triggerName] === 1;
+  if (enablePipelineOptimizations && isDevelopmentBranch && !hasCommitMessageTrigger && !doesSharedTriggerMatch && !doesPackageFolderTriggerMatch) {
+    if (!cliFlags.silent) {
+      console.log(`ℹ️ No relevant changes found for ${cliFlags.triggerName}.`);
+    }
+    matchedTriggers['allowPipelineOptimizationsForTrigger'] = 1;
+  } else {
+    if (!cliFlags.silent) {
+      console.log(`ℹ️ Relevant changes found for ${cliFlags.triggerName}.`);
+    }
+    matchedTriggers['allowPipelineOptimizationsForTrigger'] = 0;
+  }
+  await helpers.writeOutDotEnvFile(cliFlags, cwd, matchedTriggers);
+  return matchedTriggers;
+}
+
+function ownKeys(e, r) { var t = _Object$keys(e); if (_Object$getOwnPropertySymbols) { var o = _Object$getOwnPropertySymbols(e); r && (o = _filterInstanceProperty(o).call(o, function (r) { return _Object$getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var _context, _context2; var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? _forEachInstanceProperty(_context = ownKeys(Object(t), !0)).call(_context, function (r) { _defineProperty(e, r, t[r]); }) : _Object$getOwnPropertyDescriptors ? _Object$defineProperties(e, _Object$getOwnPropertyDescriptors(t)) : _forEachInstanceProperty(_context2 = ownKeys(Object(t))).call(_context2, function (r) { _Object$defineProperty(e, r, _Object$getOwnPropertyDescriptor(t, r)); }); } return e; }
+const baseMenuProperties = {
+  key: {
+    type: 'string'
+  },
+  uriPath: {
+    type: 'string'
+  },
+  icon: {
+    type: 'string'
+  },
+  featureToggle: {
+    type: ['string', 'null']
+  },
+  labelAllLocales: {
+    type: 'array',
+    items: [{
+      type: 'object',
+      properties: {
+        locale: {
+          type: 'string'
+        },
+        value: {
+          type: 'string'
+        }
+      },
+      required: ['locale', 'value']
+    }]
+  },
+  menuVisibility: {
+    type: ['string', 'null']
+  },
+  permissions: {
+    type: 'array',
+    items: {
+      type: 'string'
+    }
+  },
+  dataFences: {
+    type: ['array', 'null'],
+    items: [{
+      type: ['object'],
+      properties: {
+        group: {
+          type: 'string'
+        },
+        name: {
+          type: 'string'
+        },
+        type: {
+          type: 'string'
+        }
+      }
+    }]
+  },
+  actionRights: {
+    type: ['array', 'null'],
+    items: [{
+      type: ['object'],
+      properties: {
+        group: {
+          type: 'string'
+        },
+        name: {
+          type: 'string'
+        }
+      }
+    }]
+  }
+};
+const navbarMenuSchema = {
+  $schema: 'https://json-schema.org/draft/2020-12/schema',
+  // "$id":""
+  title: 'NavbarMenu',
+  type: 'object',
+  properties: _objectSpread(_objectSpread({}, baseMenuProperties), {}, {
+    submenu: {
+      type: 'array',
+      items: [{
+        type: 'object',
+        properties: baseMenuProperties
+      }]
+    }
+  }),
+  required: ['icon', 'key', 'labelAllLocales', 'permissions', 'submenu', 'uriPath']
+};
+const appbarMenuSchema = {
+  $schema: 'https://json-schema.org/draft/2020-12/schema',
+  // "$id":""
+  title: 'AppbarMenu',
+  type: 'array',
+  items: [{
+    type: 'object',
+    properties: baseMenuProperties,
+    required: ['key', 'labelAllLocales', 'permissions', 'uriPath']
+  }]
+};
+
+function validateMenu(menuJson) {
+  let schema = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : navbarMenuSchema;
+  const validator = new Validator();
+  const result = validator.validate(menuJson, schema);
+  if (result.valid) {
+    return menuJson;
+  } else {
+    throw new Error('menu.json validation failed\n' + result.errors);
+  }
+}
+async function command(cliFlags) {
+  const menuJsonPath = cliFlags.inputFile;
+  const isAppbarMenu = cliFlags.navigation === 'top';
+  if (!menuJsonPath) throw new Error(`--input-file cannot be empty. please provide the path of compiled menu.json`);
+  if (!doesFileExist(menuJsonPath)) throw new Error(`The menu.json file doesn't exist: ${menuJsonPath}`);
+  const menuJson = fs$1.readFileSync(menuJsonPath, 'utf-8');
+  return validateMenu(JSON.parse(menuJson), isAppbarMenu ? appbarMenuSchema : navbarMenuSchema);
+}
+
+var pkgJson = {
+	name: "@commercetools-frontend/application-cli",
+	version: "5.0.2",
+	description: "Internal CLI to manage Merchant Center application deployments across various environments.",
+	keywords: [
+		"commercetools",
+		"cli",
+		"custom-application"
+	],
+	license: "MIT",
+	main: "dist/commercetools-frontend-application-cli.cjs.js",
+	module: "dist/commercetools-frontend-application-cli.esm.js",
+	bin: "bin/cli.js",
+	files: [
+		"bin",
+		"cli",
+		"dist",
+		"package.json",
+		"LICENSE",
+		"README.md"
+	],
+	scripts: {
+		typecheck: "tsc --noEmit"
+	},
+	dependencies: {
+		"@babel/core": "^7.22.11",
+		"@babel/runtime-corejs3": "^7.21.0",
+		"@commercetools-frontend/application-config": "22.37.0",
+		"@commercetools-frontend/constants": "22.37.0",
+		"@commercetools-frontend/l10n": "22.37.0",
+		"@manypkg/find-root": "2.2.3",
+		cac: "^6.7.14",
+		cosmiconfig: "9.0.0",
+		dotenv: "16.4.5",
+		execa: "5.1.1",
+		jsonschema: "^1.4.1",
+		listr2: "8.2.5",
+		lodash: "4.17.21",
+		micromatch: "4.0.8",
+		"node-fetch": "2.7.0",
+		"ts-deepmerge": "7.0.1"
+	},
+	devDependencies: {
+		"@tsconfig/node20": "20.1.4",
+		"@types/lodash": "^4.14.198",
+		"@types/micromatch": "4.0.9",
+		"@types/node": "20.17.13",
+		typescript: "5.2.2"
+	},
+	engines: {
+		node: ">=21",
+		npm: ">=6"
+	},
+	publishConfig: {
+		access: "public"
+	},
+	preconstruct: {
+		entrypoints: [
+			"./cli.ts",
+			"./index.ts"
+		]
+	}
+};
+
+const cli = cac('application-cli');
+const cwd = process.cwd();
+const run = async () => {
+  cli.option('--build-revision [git-sha]', '(optional) The git commit SHA which is being built.', {
+    default: process.env.CIRCLE_SHA1
+  }).option('--build-number [string]', '(optional) A number of the build on the Continuous Integration system.', {
+    default: process.env.CIRCLE_BUILD_NUM
+  }).option('--package-manager-name [string]', '(optional) Name of the binary of the used package manager (e.g. pnpm).', {
+    default: 'yarn'
+  });
+
+  // Default command
+  cli.command('').usage('\n\n  Compile deployments and menus and create versions for MC applications').action(cli.outputHelp);
+  const usageCompileDeployment = 'Compile the deployments for an application for all environments.';
+  cli.command('compile-deployments', usageCompileDeployment).usage(`compile-deployments \n\n  ${usageCompileDeployment}`).option('--application-name <string>', '(required) The name of the application being compiled for example application-products.').option('--dotenv-folder [string]', '(optional) The path to a folder containing a dotenv file ".env.production" and a cloud-environment specific dotenv file (for example ".env.gcp-production-eu"). Those values are parsed and merged together to be used by the `mc-scripts compile-html` command.').option('--pr-number [string]', '(optional) A pull request number determining a scoped storage bucket for the deployment. Please use it carefully.').option('--mc-url [string]', '(optional) The MC URL of the deployment. This is usually inferred from the env file and overwrites the value. Please use it carefully.').option('--mc-api-url [string]', '(optional) The MC API URL of the deployment. This is usually inferred from the env file and overwrites the value. Please use it carefully.').option('--application-index-out-file [path]', '(optional) The name of the application index file.', {
+    default: 'application.html'
+  }).option('--application-index-upload-script-out-file [path]', '(optional) The name of the the application index upload script file.', {
+    default: 'upload-index.sh'
+  }).option('--application-assets-upload-script-out-file [path]', '(optional) The name of the the assets upload script file.', {
+    default: 'upload-assets.sh'
+  }).option('--ci-assets-root-path [path]', '(optional) A replacement value for the scripts root path only used on CI (e.g. "--ci-assets-root-path=/root/") used in generated scripts.').option('--skip-menu', '(optional) If provided, it will skip uploading the `menu.json`.', {
+    default: false
+  }).action(async options => {
+    await command$4(options, cwd);
+  });
+  const usageCompileMenu = 'Compile the menu links of an application into a `menu.json`. This is only required for internal applications';
+  cli.command('compile-menu', usageCompileMenu).usage(`compile-menu \n\n  ${usageCompileMenu}`).option('--dotenv-folder [string]', '(optional) The path to a folder containing a dotenv file `.env.production` and a cloud-environment specific dotenv file (for example `.env.gcp-production-eu`). Those values are parsed and merged together to be used by the application config.').action(async options => {
+    await command$3(options, cwd);
+  });
+  const usageValidateMenu = 'Validate compiled `menu.json` file';
+  cli.command('validate-menu', usageValidateMenu).usage(`validate-menu \n\n  ${usageValidateMenu}`).option('--input-file <path>', '(required) The path to the `menu.json` file to be validated.').option('--navigation [string]', '(optional) Location of the menu navigation. Possible values are `top`.').action(async options => {
+    await command(options);
+  });
+  const usageCreateVersion = 'Output a JSON string about the information in the `version.json` for a deployment, including the updated list of rollbacks.';
+  cli.command('create-version', usageCreateVersion).usage(`create-version \n\n  ${usageCreateVersion}`).option('--version-url <url>', "(required) The path of an application's current `version.json` within the storage bucket.").option('--rollbacks [int]', '(optional) The number of max rollbacks to keep', {
+    default: 15
+  }).option('--out-file [path]', '(optional) The path to the file where to write the JSON. If not specified, the JSON is printed to stdout.').action(async options => {
+    await command$2(options);
+  });
+
+  // Command: Evaluate change triggers
+  const usageEvaluateChangeTriggers = 'Evaluates changed files against a base and evaluates them against defined triggers.';
+  cli.command('evaluate-change-triggers', usageEvaluateChangeTriggers).usage(`evaluate-change-triggers \n\n  ${usageEvaluateChangeTriggers}`).option('--branch <string>', 'The branch of the pull request', {
+    default: process.env.CIRCLE_BRANCH
+  }).option('--base-branch <string>', 'The base revision of the git commit compare against (e.g. "main")').option('--head-revision <string>', 'The revision of the git head to compare with', {
+    default: process.env.CIRCLE_SHA1
+  }).option('--trigger-name <string>', 'The trigger to evaluate for.').option('--silent', '(optional) Disable logging', {
+    default: false
+  }).option('--out-env-file [string]', '(optional) A file path where the matched triggers are written as a dotenv file.').action(async options => {
+    const config = await loadConfig('circleci-change-triggers', []);
+    await command$1(options, config, cwd);
+  });
+  cli.help();
+  cli.version(pkgJson.version);
+  cli.parse(process.argv, {
+    run: false
+  });
+  await cli.runMatchedCommand();
+};
+
+export { run };