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

package/cli/dist/commercetools-frontend-deployment-cli-cli.cjs.prod.js

@@ -0,0 +1,601 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var cac = require('cac');
+var _findInstanceProperty = require('@babel/runtime-corejs3/core-js-stable/instance/find');
+var _forEachInstanceProperty = require('@babel/runtime-corejs3/core-js-stable/instance/for-each');
+var _mapInstanceProperty = require('@babel/runtime-corejs3/core-js-stable/instance/map');
+var _filterInstanceProperty = require('@babel/runtime-corejs3/core-js-stable/instance/filter');
+var _startsWithInstanceProperty = require('@babel/runtime-corejs3/core-js-stable/instance/starts-with');
+var _concatInstanceProperty = require('@babel/runtime-corejs3/core-js-stable/instance/concat');
+var cosmiconfig = require('cosmiconfig');
+var merge = require('lodash/merge');
+var prompts = require('prompts');
+var pRetry = require('p-retry');
+var _slicedToArray = require('@babel/runtime-corejs3/helpers/slicedToArray');
+var _URLSearchParams = require('@babel/runtime-corejs3/core-js-stable/url-search-params');
+var _Object$entries = require('@babel/runtime-corejs3/core-js-stable/object/entries');
+var _Promise = require('@babel/runtime-corejs3/core-js-stable/promise');
+var _JSON$stringify = require('@babel/runtime-corejs3/core-js-stable/json/stringify');
+var node_process = require('node:process');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var _findInstanceProperty__default = /*#__PURE__*/_interopDefault(_findInstanceProperty);
+var _forEachInstanceProperty__default = /*#__PURE__*/_interopDefault(_forEachInstanceProperty);
+var _mapInstanceProperty__default = /*#__PURE__*/_interopDefault(_mapInstanceProperty);
+var _filterInstanceProperty__default = /*#__PURE__*/_interopDefault(_filterInstanceProperty);
+var _startsWithInstanceProperty__default = /*#__PURE__*/_interopDefault(_startsWithInstanceProperty);
+var _concatInstanceProperty__default = /*#__PURE__*/_interopDefault(_concatInstanceProperty);
+var merge__default = /*#__PURE__*/_interopDefault(merge);
+var prompts__default = /*#__PURE__*/_interopDefault(prompts);
+var pRetry__default = /*#__PURE__*/_interopDefault(pRetry);
+var _URLSearchParams__default = /*#__PURE__*/_interopDefault(_URLSearchParams);
+var _Object$entries__default = /*#__PURE__*/_interopDefault(_Object$entries);
+var _Promise__default = /*#__PURE__*/_interopDefault(_Promise);
+var _JSON$stringify__default = /*#__PURE__*/_interopDefault(_JSON$stringify);
+
+var pkgJson = {
+	name: "@commercetools-frontend/deployment-cli",
+	version: "2.0.2",
+	description: "CLI to manage Custom Applications deployments in Google Storage.",
+	keywords: [
+		"commercetools",
+		"cli",
+		"deployment"
+	],
+	license: "MIT",
+	main: "dist/commercetools-frontend-deployment-cli.cjs.js",
+	module: "dist/commercetools-frontend-deployment-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",
+		cac: "^6.7.14",
+		cosmiconfig: "9.0.0",
+		lodash: "4.17.21",
+		"p-retry": "4.6.2",
+		prompts: "2.4.2"
+	},
+	devDependencies: {
+		"@tsconfig/node20": "20.1.4",
+		"@types/lodash": "^4.14.198",
+		"@types/node": "20.17.13",
+		"@types/prompts": "2.4.9",
+		msw: "1.3.5",
+		typescript: "5.2.2"
+	},
+	engines: {
+		node: ">=21",
+		npm: ">=6"
+	},
+	publishConfig: {
+		access: "public"
+	},
+	preconstruct: {
+		entrypoints: [
+			"./cli.ts",
+			"./index.ts"
+		]
+	}
+};
+
+async function loadConfig() {
+  const deploymentConfigExplorer = cosmiconfig.cosmiconfig('deployment', {
+    searchStrategy: 'project'
+  });
+  const defaultConfig = {
+    CircleCI: {
+      apiBaseUrl: 'https://circleci.com/api/v2',
+      deploymentWorkflowName: 'test_build_and_deploy',
+      pagination: {
+        maxPages: 42,
+        pagesForPipelineSelection: 5
+      }
+    },
+    MerchantCenter: {}
+  };
+  try {
+    const cosmiconfigResult = await deploymentConfigExplorer.search();
+    const mergedConfig = merge__default["default"](defaultConfig, cosmiconfigResult?.config);
+    return mergedConfig;
+  } catch (e) {
+    console.warn(e);
+    throw new Error('Failed loading a deployment configuration. Create a cosmiconfig for `deployment` for example `deployment.config.cjs`.');
+  }
+}
+function throwIfConfigurationLacksRequiredValues(parsedConfiguration) {
+  if (!parsedConfiguration.CircleCI.projectName) {
+    throw new Error(`Missing 'projectName' in 'CircleCI' on configuration. Make sure it exists!`);
+  }
+}
+function throwIfRequiredEnvironmentVariableIsUnset(requiredEnvironmentVariables) {
+  _forEachInstanceProperty__default["default"](requiredEnvironmentVariables).call(requiredEnvironmentVariables, nameOfRequiredEnvironmentVariable => {
+    const valueOfRequiredEnvironmentVariable = process.env[nameOfRequiredEnvironmentVariable];
+    if (!valueOfRequiredEnvironmentVariable) throw new Error(`Missing '${nameOfRequiredEnvironmentVariable}' environment variable`);
+  });
+}
+const promptOptions = {
+  applicationSelect: _ref => {
+    let packages = _ref.packages;
+    return {
+      type: 'select',
+      name: 'applicationName',
+      message: 'Select an application',
+      choices: _mapInstanceProperty__default["default"](packages).call(packages, _ref2 => {
+        let packageJson = _ref2.packageJson;
+        const applicationName = packageJson.name.replace('@commercetools-local/application-', '');
+        return {
+          title: applicationName,
+          value: applicationName
+        };
+      })
+    };
+  },
+  deploymentPipelineSelect: _ref3 => {
+    let deploymentPipelines = _ref3.deploymentPipelines;
+    return {
+      type: 'select',
+      name: 'deploymentPipeline',
+      message: 'Select the revision you would like to deploy',
+      choices: _mapInstanceProperty__default["default"](deploymentPipelines).call(deploymentPipelines, deploymentPipeline => ({
+        title: `${deploymentPipeline.vcs.revision.substring(0, 7)} - ${deploymentPipeline.vcs.commit.subject} <${deploymentPipeline.trigger.actor.login}>`,
+        value: deploymentPipeline
+      }))
+    };
+  },
+  deploymentConfirmation: _ref4 => {
+    let approvalJob = _ref4.approvalJob,
+      revision = _ref4.revision;
+    return {
+      type: 'toggle',
+      name: 'confirmed',
+      message: `Are you sure you want to deploy by approving ${approvalJob} at ${revision}?`,
+      initial: false,
+      active: 'Yes',
+      inactive: 'No'
+    };
+  }
+};
+async function paginateToDeploymentPipeline(_ref5) {
+  let circleCiApis = _ref5.circleCiApis,
+    buildRevision = _ref5.buildRevision,
+    branch = _ref5.branch,
+    debug = _ref5.debug,
+    maxPages = _ref5.maxPages;
+  let deploymentPipeline;
+  let nextPageToken;
+  // eslint-disable-next-line no-plusplus
+  for (let i = 0; i < maxPages; i++) {
+    var _context, _context2;
+    // eslint-disable-next-line no-await-in-loop
+
+    const pipelineRequest = circleCiApis.pipelines({
+      pageToken: nextPageToken,
+      branch
+    });
+    const pipelines = await pipelineRequest.execute({
+      debug
+    });
+    nextPageToken = pipelines.next_page_token;
+    const nonScheduledPipelines = _filterInstanceProperty__default["default"](_context = _filterInstanceProperty__default["default"](_context2 = pipelines.items).call(_context2, isNonScheduledPipeline)).call(_context, isNonErroredPipeline);
+    if (buildRevision) {
+      console.log(`🔄 Trying to find pipeline with revision ${buildRevision}. Attempt ${i + 1} out of ${maxPages}.`);
+      deploymentPipeline = _findInstanceProperty__default["default"](nonScheduledPipelines).call(nonScheduledPipelines, pipeline => {
+        var _context3;
+        return _startsWithInstanceProperty__default["default"](_context3 = pipeline.vcs.revision).call(_context3, buildRevision);
+      });
+    } else {
+      deploymentPipeline = nonScheduledPipelines[0];
+    }
+    if (deploymentPipeline) {
+      console.log(`ℹ️  Using pipeline for deployment with revision ${deploymentPipeline.vcs.revision}.`);
+      break;
+    }
+  }
+  return deploymentPipeline;
+}
+async function collectDeploymentPipelines(_ref6) {
+  let circleCiApis = _ref6.circleCiApis,
+    branch = _ref6.branch,
+    pagesForPipelineSelection = _ref6.pagesForPipelineSelection,
+    debug = _ref6.debug;
+  let deploymentPipelines = [];
+  let nextPageToken;
+  // eslint-disable-next-line no-plusplus
+  for (let i = 0; i < pagesForPipelineSelection; i++) {
+    var _context4, _context5;
+    // eslint-disable-next-line no-await-in-loop
+    const pipelinesRequest = circleCiApis.pipelines({
+      pageToken: nextPageToken,
+      branch
+    });
+    const pipelines = await pipelinesRequest.execute({
+      debug
+    });
+    const nonScheduledPipelines = _filterInstanceProperty__default["default"](_context4 = _filterInstanceProperty__default["default"](_context5 = pipelines.items).call(_context5, isNonScheduledPipeline)).call(_context4, isNonErroredPipeline);
+    deploymentPipelines = _concatInstanceProperty__default["default"](deploymentPipelines).call(deploymentPipelines, nonScheduledPipelines);
+  }
+  return deploymentPipelines;
+}
+async function waitForDeploymentPipelinePrompt(_ref7) {
+  let circleCiApis = _ref7.circleCiApis,
+    branch = _ref7.branch,
+    pagesForPipelineSelection = _ref7.pagesForPipelineSelection,
+    debug = _ref7.debug;
+  const deploymentPipelines = await collectDeploymentPipelines({
+    branch,
+    pagesForPipelineSelection,
+    circleCiApis,
+    debug
+  });
+  const deploymentPipelinePrompt = await prompts__default["default"](
+  // @ts-expect-error prompts is not typed
+  promptOptions.deploymentPipelineSelect({
+    deploymentPipelines
+  }));
+  const revision = deploymentPipelinePrompt.deploymentPipeline.vcs.revision;
+  if (!revision) {
+    console.log('☝️ Please select a revision or specify it as a CLI argument via `--build-revision`.');
+    throw new Error('No revision specified.');
+  }
+  return deploymentPipelinePrompt.deploymentPipeline;
+}
+async function waitForConfirmationPrompt(_ref8) {
+  let approvalJob = _ref8.approvalJob,
+    revision = _ref8.revision;
+  return prompts__default["default"](
+  // @ts-expect-error prompts is not typed
+  promptOptions.deploymentConfirmation({
+    approvalJob,
+    revision
+  }));
+}
+function getJobUrl(_ref9) {
+  let pipelineNumber = _ref9.pipelineNumber,
+    workflowId = _ref9.workflowId,
+    jobNumber = _ref9.jobNumber,
+    projectName = _ref9.projectName;
+  return `https://app.circleci.com/pipelines/github/commercetools/${projectName}/${pipelineNumber}/workflows/${workflowId}/jobs/${jobNumber}`;
+}
+function isNonScheduledPipeline(pipeline) {
+  return pipeline.trigger.type !== 'schedule' && pipeline.trigger.type !== 'scheduled_pipeline';
+}
+function isNonErroredPipeline(pipeline) {
+  return pipeline.state !== 'errored';
+}
+async function waitForDeploymentJobNumber(_ref10, _ref11) {
+  let workflowId = _ref10.workflowId,
+    deploymentJob = _ref10.deploymentJob,
+    circleCiApis = _ref10.circleCiApis;
+  let debug = _ref11.debug;
+  const fetchDeploymentJobNumber = async () => {
+    var _context6;
+    const jobsRequest = circleCiApis.jobs({
+      workflowId
+    });
+    const jobs = await jobsRequest.execute({
+      debug
+    });
+    const applicationDeploymentJob = _findInstanceProperty__default["default"](_context6 = jobs.items).call(_context6, job => job.name === deploymentJob);
+    if (!applicationDeploymentJob || applicationDeploymentJob.status === 'blocked') {
+      throw new Error('Deployment job not yet running. Retrying.');
+    }
+    return applicationDeploymentJob.job_number;
+  };
+  const deploymentJobNumber = await pRetry__default["default"](fetchDeploymentJobNumber, {
+    onFailedAttempt: error => {
+      console.log(`🔄 Trying to find deployment job. Attempt ${error.attemptNumber} with ${error.retriesLeft} retries left.`);
+    },
+    retries: 10
+  });
+  return deploymentJobNumber;
+}
+
+async function approve(cliFlags, config, circleCiApis) {
+  var _context, _context2;
+  let approvalJob;
+  let deploymentJob;
+  if (cliFlags.deployment) {
+    const requestedDeployment = config.deployments?.[cliFlags.deployment];
+    if (!requestedDeployment) {
+      throw new Error(`⚠️ Deployment ${cliFlags.deployment} not found in configuration. Make sure it exists.`);
+    }
+    approvalJob = requestedDeployment.jobs.approval;
+    deploymentJob = requestedDeployment.jobs.deployment;
+    console.log(`ℹ️  Approving requested deployment ${cliFlags.deployment} with approval job ${approvalJob}.`);
+  } else {
+    approvalJob = cliFlags.approvalJob;
+    deploymentJob = cliFlags.deploymentJob;
+    console.log(`ℹ️  Approving with approval job ${approvalJob}.`);
+  }
+  const deploymentPipeline = cliFlags.yes ? await paginateToDeploymentPipeline({
+    circleCiApis,
+    buildRevision: cliFlags.buildRevision,
+    branch: cliFlags.branch,
+    debug: cliFlags.debug,
+    maxPages: config.CircleCI.pagination?.maxPages ?? 1
+  }) : await waitForDeploymentPipelinePrompt({
+    branch: cliFlags.branch,
+    circleCiApis,
+    pagesForPipelineSelection: config.CircleCI.pagination?.pagesForPipelineSelection ?? 1,
+    debug: cliFlags.debug
+  });
+  if (!deploymentPipeline) {
+    throw new Error(`⚠️ No workflow called ${config.CircleCI.deploymentWorkflowName} found in any pipeline for deployment.`);
+  }
+  console.log(`ℹ️  Found pipeline for deployment with revision ${deploymentPipeline.vcs.revision}.`);
+  const workflowsRequest = circleCiApis.workflows({
+    pipelineId: deploymentPipeline.id
+  });
+  const workflows = await workflowsRequest.execute({
+    debug: cliFlags.debug
+  });
+  const buildAndDeployWorkflow = _findInstanceProperty__default["default"](_context = workflows.items).call(_context, workflow => workflow.name === config.CircleCI.deploymentWorkflowName);
+  if (!buildAndDeployWorkflow) {
+    throw new Error(`⚠️ No workflow called ${config.CircleCI.deploymentWorkflowName} found for deployment.`);
+  }
+  const workflowId = buildAndDeployWorkflow.id;
+  console.log(`ℹ️  Found workflow to build and deploy with id ${workflowId}.`);
+  const jobsRequest = circleCiApis.jobs({
+    workflowId
+  });
+  const jobs = await jobsRequest.execute({
+    debug: cliFlags.debug
+  });
+  console.log(`ℹ️  Found jobs for workflow.`);
+  const applicationApprovalJob = _findInstanceProperty__default["default"](_context2 = jobs.items).call(_context2, job => job.name === approvalJob);
+  const applicationApprovalJobId = applicationApprovalJob?.id;
+  if (!applicationApprovalJobId) {
+    throw new Error(`✌️ Could not find deployment approval job named ${approvalJob} at revision ${deploymentPipeline.vcs.revision}. Maybe try again later.`);
+  }
+  console.log(`ℹ️  Found deployment approval job named ${approvalJob} with id ${applicationApprovalJobId}.`);
+  let confirmationPrompt;
+  if (!cliFlags.yes) {
+    confirmationPrompt = await waitForConfirmationPrompt({
+      approvalJob: approvalJob,
+      revision: deploymentPipeline.vcs.revision
+    });
+  }
+  if (cliFlags.yes || confirmationPrompt?.confirmed) {
+    if (cliFlags.dryRun) {
+      console.log(`🙊 Not approving deployment job due to dry run.`);
+    } else {
+      console.log(`ℹ️  Approving deployment job.`);
+    }
+    const approvalRequest = circleCiApis.approve({
+      workflowId,
+      approvalRequestId: applicationApprovalJobId
+    });
+    await approvalRequest.execute({
+      debug: cliFlags.debug,
+      skip: cliFlags.dryRun
+    });
+    if (cliFlags.yes) {
+      console.log(`ℹ️  Skipping determining deployment job approved by ${approvalJob} due to '--yes' flag. Please check CircleCI manually.`);
+    } else if (cliFlags.dryRun) {
+      console.log(`✌️ Dry running hence could not determine deployment job approved by ${approvalJob}.`);
+    } else if (deploymentJob) {
+      const deploymentJobNumber = await waitForDeploymentJobNumber({
+        workflowId,
+        deploymentJob,
+        circleCiApis
+      }, {
+        debug: cliFlags.debug,
+        dryRun: cliFlags.dryRun,
+        yes: cliFlags.yes
+      });
+      console.log(`🙌 The deployment via ${approvalJob} at revision ${deploymentPipeline.vcs.revision} is running at: ${getJobUrl({
+        projectName: config.CircleCI.projectName,
+        pipelineNumber: deploymentPipeline.number,
+        workflowId,
+        jobNumber: deploymentJobNumber
+      })}`);
+    } else {
+      console.log(`ℹ️  Skipping determining deployment job as no '--deployment-job' name to wait for was passed. Please check CircleCI manually.`);
+    }
+  } else {
+    console.log(`ℹ️  Not approving deployment job. Confirm the prompt or use '--yes' option.`);
+  }
+}
+
+async function processCircleCiResponse(response) {
+  if (!response.ok) {
+    /**
+     * NOTE:
+     *   Trying to handle known but undocumented responses of the CircleCI API.
+     *
+     *   1. Message: Already approved job
+     *   Deployment was already triggered manually or by train the day before.
+     */
+
+    // Response data is a stream so text OR json can only be read once, so
+    // we read it as text first and then try to parse it as json to handle
+    // known error responses.
+    const error = await response.text();
+    try {
+      // The CircleCI API always uses content-type text/plain, so we always
+      // try parsing JSON to see if the message property is present.
+      const _JSON$parse = JSON.parse(error),
+        message = _JSON$parse.message;
+      if (message.match(/job already approved/i)) {
+        console.log('ℹ️  Deployment job is already approved.');
+        // TODO: can we return instead of force exiting?
+        node_process.exit(0);
+      }
+    } catch {
+      // Ignore JSON parsing errors
+    }
+    throw new Error(`${response.status}: Network response was not ok.\n
+      Status text is ${response.statusText} and text is ${error}.`);
+  }
+  return response.json();
+}
+function createCircleCiClient(_ref) {
+  let projectName = _ref.projectName,
+    apiBaseUrl = _ref.apiBaseUrl;
+  async function execute(api) {
+    let _ref2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+      skip = _ref2.skip,
+      debug = _ref2.debug;
+    let url = `${apiBaseUrl}${api.url}`;
+    if (api.params && api.method === 'GET') {
+      const urlSearchParams = new _URLSearchParams__default["default"]();
+      for (const _ref3 of _Object$entries__default["default"](api.params)) {
+        var _ref4 = _slicedToArray(_ref3, 2);
+        const key = _ref4[0];
+        const value = _ref4[1];
+        if (value !== null && value !== undefined) {
+          urlSearchParams.append(key, value);
+        }
+      }
+      url += `?${urlSearchParams.toString()}`;
+    }
+    if (skip) {
+      if (debug) {
+        console.log(`🏭 Skipping CircleCI call API at: ${url}.`);
+      }
+
+      // @ts-expect-error
+      return _Promise__default["default"].resolve();
+    }
+    if (debug) {
+      console.log(`🏭 Calling CircleCI API at: ${url}.`);
+    }
+    try {
+      const response = await fetch(url, {
+        headers: api.headers,
+        method: api.method,
+        body: api.method === 'POST' ? _JSON$stringify__default["default"](api.params) : undefined
+      });
+      const processedCircleCiResponse = await processCircleCiResponse(response);
+      return processedCircleCiResponse;
+    } catch (error) {
+      console.log(`⚠️ Calling CircleCI API at: ${url} failed.`);
+      throw error;
+    }
+  }
+  return {
+    pipelines: function () {
+      let _ref5 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+        pageToken = _ref5.pageToken,
+        _ref5$projectSlug = _ref5.projectSlug,
+        projectSlug = _ref5$projectSlug === void 0 ? `gh/commercetools/${projectName}` : _ref5$projectSlug,
+        _ref5$branch = _ref5.branch,
+        branch = _ref5$branch === void 0 ? 'main' : _ref5$branch;
+      return {
+        execute: options => execute({
+          url: `/project/${projectSlug}/pipeline`,
+          headers: {
+            'Content-Type': 'application/json',
+            // The CLI throws if this is not present on environment
+            'Circle-Token': process.env.CIRCLE_TOKEN
+          },
+          method: 'GET',
+          params: {
+            branch,
+            'page-token': pageToken
+          }
+        }, options)
+      };
+    },
+    workflows: _ref6 => {
+      let pipelineId = _ref6.pipelineId;
+      return {
+        execute: options => execute({
+          url: `/pipeline/${pipelineId}/workflow`,
+          headers: {
+            'Content-Type': 'application/json',
+            // The CLI throws if this is not present on environment
+            'Circle-Token': process.env.CIRCLE_TOKEN
+          },
+          method: 'GET'
+        }, options)
+      };
+    },
+    jobs: _ref7 => {
+      let workflowId = _ref7.workflowId;
+      return {
+        execute: options => execute({
+          url: `/workflow/${workflowId}/job`,
+          headers: {
+            'Content-Type': 'application/json',
+            // The CLI throws if this is not present on environment
+            'Circle-Token': process.env.CIRCLE_TOKEN
+          },
+          method: 'GET'
+        }, options)
+      };
+    },
+    approve: _ref8 => {
+      let workflowId = _ref8.workflowId,
+        approvalRequestId = _ref8.approvalRequestId;
+      return {
+        execute: options => execute({
+          url: `/workflow/${workflowId}/approve/${approvalRequestId} `,
+          headers: {
+            'Content-Type': 'application/json',
+            // The CLI throws if this is not present on environment
+            'Circle-Token': process.env.CIRCLE_TOKEN
+          },
+          method: 'POST'
+        }, options)
+      };
+    }
+  };
+}
+
+const cli = cac.cac('deployment-cli');
+async function run() {
+  const config = await loadConfig();
+  throwIfConfigurationLacksRequiredValues(config);
+  const circleCiApis = createCircleCiClient({
+    projectName: config.CircleCI.projectName,
+    apiBaseUrl: config.CircleCI.apiBaseUrl
+  });
+
+  // General CLI options
+  cli.option('--dry-run', '(optional) Simulate a deployment.', {
+    default: false
+  });
+  cli.option('--debug', '(optional) Print additional debug information.', {
+    default: false
+  });
+
+  // Default command
+  cli.command('').usage('\n\n  Approve deployment jobs on CI for different components related to MC.').action(cli.outputHelp);
+
+  // Command: Approve
+  const usageApprove = 'Approves a job and by this triggers a deployment of a component. It requires a "CIRCLE_TOKEN" environment variable (https://circleci.com/docs/2.0/managing-api-tokens/).';
+  cli.command('approve', usageApprove).usage(`approve \n\n  ${usageApprove}`).option('--approval-job <string>', 'The name of the approval job to approve a deployment with.').option('--deployment-job [string]', '(optional) The name of the deployment job triggered by the approval job. If passed the CLI will print a URL to the deployment triggered on CircleCI.').option('--deployment [string]', '(optional) The name of a deployment configured in the configuration file.').option('--build-revision [git-sha]', '(optional) The git commit SHA that needs to be deployed. If not specified, the last successful pipeline is used.').option('--branch [string]', '(optional) The git branch to deploy from. If not specified.', {
+    default: 'main'
+  }).option('--yes', '(optional) Skip all confirmation prompts. Useful in Continuous integration (CI) to automatically answer confirmation questions.', {
+    default: false
+  }).action(async options => {
+    if (options.dryRun) {
+      console.log(`🙊 Do not worry. This is a dry run!`);
+    }
+    throwIfRequiredEnvironmentVariableIsUnset(['CIRCLE_TOKEN']);
+    await approve(options, config, circleCiApis);
+  });
+  cli.help();
+  cli.version(pkgJson.version);
+  cli.parse(process.argv, {
+    run: false
+  });
+  await cli.runMatchedCommand();
+}
+
+exports.run = run;