@leverege/build-tools 2.59.0 → 2.59.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leverege/build-tools",
-  "version": "2.59.0",
+  "version": "2.59.2",
   "description": "A collection of build / support tools for Leverege developers",
   "main": "index.js",
   "repository": {

package/src/circleate.sh

@@ -120,6 +120,7 @@ jobs:
           path: reports
 
   docs:
+    circleci_ip_ranges: true
     docker:
       - image: $CIRCLE_NODE_IMG
     steps:
@@ -339,6 +340,7 @@ jobs:
           path: reports
 
   docs:
+    circleci_ip_ranges: true
     docker:
       - image: $CIRCLE_NODE_IMG
     steps:

package/src/helm-charts/redis/helmup.plugin

@@ -4,7 +4,7 @@ showInstalling "Redis"
 
 OCI_CHART="oci://registry-1.docker.io/bitnamicharts/redis"
 
-[ -z "$REDIS_CHART_VERSION" ] && REDIS_CHART_VERSION="20.6.0"
+[ -z "$REDIS_CHART_VERSION" ] && REDIS_CHART_VERSION="20.6.1"
 
 helm upgrade --install redis $OCI_CHART       \
              --values  redis/redis-local.yaml \

package/src/helm-charts/velero/velero-local.yaml

@@ -129,6 +129,10 @@ serviceAccount:
     create: false
     name: velero
 
+metrics:
+  serviceMonitor:
+    enabled: true
+
 # Workload Identity Federation (WIF) uses service accounts and IAM roles to
 # define a service's permissions - the useSecret setting will be set to false
 # for WIF enabled clusters.

package/src/k8cryo.sh

@@ -1,20 +0,0 @@
-#!/bin/bash
-#
-. `build-tools --bashfun`
-
-daysToKeep=${1:-60}
-let hoursToKeep="$daysToKeep*24"
-printf "\ncryo backup set to keep for $daysToKeep days / $hoursToKeep hours\n"
-
-if [ "`basename $0`" == "k8thaw" ];
-then
-  errorExit "k8thaw - UNDER CONSTRUCTION"
-fi
-
-# Gets the UTC time in the same format that velero schedules use for
-# generating the Date Time Stamp for scheduled backups.
-DTS="`date -u +\"%Y%m%d%H%M%S\"`"
-
-printf "\nExecuting = > velero backup create velero-cryo-$DTS --ttl ${hoursToKeep}h\n"
-
-velero backup create velero-cryo-$DTS --ttl ${hoursToKeep}h

package/src/tag-release.mjs

@@ -1,692 +0,0 @@
-#!/usr/bin/env node
-/* eslint-disable security/detect-unsafe-regex */
-/* eslint-disable no-console */
-
-import path from 'node:path'
-
-import cliArgs from 'command-line-args'
-import cliHelp from 'command-line-usage'
-import { $, fs } from 'zx'
-import pkg from 'enquirer'
-import colors from 'ansi-colors'
-import { readPackage } from 'read-pkg'
-
-const { prompt } = pkg
-
-const NPMJS_TAGS = {
-  ALPHA : 'alpha',
-  BETA : 'beta',
-  LATEST : 'latest',
-}
-
-const DEFAULT_PACKAGES_PATH = './packages/*'
-
-/**
- * Functions
- */
-
-const validateVersionArg = ( { args } ) => {
-  if ( !args.version ) {
-    return
-  }
-
-  const isValid = /^\d+\.\d+\.\d+(-[a-zA-Z]+\.\d+)?$/.test( args.version )
-  if ( !isValid ) {
-    console.log( `
-${colors.bold.red( 'ERROR:' )} Invalid version arg: ${colors.bold.yellow( args.version )}.
-Use SemVer specs (e.g: ${colors.bold.yellow( '2.25.5-beta.1' )}).
-` )
-    process.exit( 1 )
-  }
-}
-
-const validateNpmjsTag = ( { args, config } ) => {
-  const npmjsTags = Object.values( NPMJS_TAGS )
-  if ( args['npmjs-tag'] && !npmjsTags.includes( args['npmjs-tag'] ) ) {
-    console.log( `
-${colors.bold.red( 'ERROR:' )} Invalid npmjs tag: ${colors.bold.yellow( args['npmjs-tag'] )}.
-Possible values: ${colors.bold.yellow( npmjsTags.join( ', ' ) )}.
-` )
-    process.exit( 1 )
-  }
-
-  if (
-    ( config?.isBetaRelease === true || args?.version?.includes( '-beta.' ) ) &&
-    args['npmjs-tag'] === NPMJS_TAGS.LATEST
-  ) {
-    console.log( `
-${colors.bold.red( 'ERROR:' )} It's not possible to publish a beta release to npmjs with tag ${colors.bold.yellow( 'latest' )}.
-  ` )
-    process.exit( 1 )
-  }
-}
-
-const validateArgs = ( args ) => {
-  validateVersionArg( { args } )
-  validateNpmjsTag( { args } )
-}
-
-const getCurrentBranch = async () => {
-  const { stdout } =
-    await $`git branch --show-current`
-      .nothrow()
-      .quiet()
-
-  return stdout.split( '\n' )[0]
-}
-
-const getLatestBranches = async ( { n = 10, branchFilter } ) => {
-  const grepFilter = branchFilter || ''
-
-  const { stdout } =
-    await $`git branch -r --sort=-committerdate --format "%(refname:lstrip=3)" | grep "${grepFilter}"`
-      .nothrow()
-      .quiet()
-
-  const branches = stdout.split( '\n' ).slice( 0, -1 ).filter( branch => branch !== 'HEAD' )
-  return branches.slice( 0, n )
-}
-
-const promptForBranch = async ( latestBranches, currentBranch ) => {
-  if ( latestBranches.length === 0 ) {
-    console.log( `
-${colors.bold.red( 'ERROR:' )} Could not find git branches.
-` )
-    process.exit( 1 )
-  }
-
-  const { branch } = await prompt( {
-    type : 'select',
-    name : 'branch',
-    message : 'Which branch would you like to release?',
-    choices : latestBranches.map( option => ( { value : option } ) ),
-    initial : currentBranch
-  } )
-  return branch
-}
-
-const getBranch = async ( branchFilter ) => {
-  const currentBranch = await getCurrentBranch()
-  const latestBranches = await getLatestBranches( branchFilter )
-  return promptForBranch( latestBranches, currentBranch )
-}
-
-const getGitRootDirectory = async () => {
-  const { stdout } = await $`git rev-parse --show-toplevel`.quiet()
-  return stdout.split( '\n' )[0]
-}
-
-const getSubDirectories = async ( repositoryRoot, directory ) => {
-  const absolutePathDirectory = path.join( repositoryRoot, directory )
-  const relativeDirectory = path.relative( repositoryRoot, absolutePathDirectory )
-  try {
-    const entries = await fs.promises.readdir( absolutePathDirectory, { withFileTypes : true } )
-    const subDirectories = entries.filter( entry => entry.isDirectory() )
-    return subDirectories.map( entry => path.join( relativeDirectory, entry.name ) )
-  } catch ( err ) {
-    return []
-  }
-}
-
-const fileExists = async ( filePath ) => {
-  try {
-    await fs.promises.access( filePath )
-    return true
-  } catch ( err ) {
-    return false
-  }
-}
-
-const findPackagesInDirectories = async ( repositoryRoot, directories ) => {
-  return directories.reduce( async ( accPromise, directory ) => {
-    const acc = await accPromise
-    const hasWildcard = directory.endsWith( '*' )
-    const basePath = hasWildcard ? directory.slice( 0, -1 ) : directory
-    const directoriesToSearch = hasWildcard ?
-      await getSubDirectories( repositoryRoot, basePath ) :
-      [ basePath ]
-    
-    for ( let i = 0; i < directoriesToSearch.length; i++ ) {
-      const currentDirectory = directoriesToSearch[i]
-      const pkgPath = path.join( directoriesToSearch[i], 'package.json' )
-      const pkgExists = await fileExists( path.join( repositoryRoot, pkgPath ) ) // eslint-disable-line no-await-in-loop
-      if ( pkgExists ) {
-        acc.push( currentDirectory )
-      }      
-    }
-    return acc
-    
-  }, Promise.resolve( [] ) )
-}
-
-const getMonorepoPackagePaths = async ( repositoryRoot, packagesPath ) => {
-  let pkg
-  try {
-    pkg = await readPackage( { cwd : repositoryRoot } )
-  } catch ( err ) {}
-
-  return findPackagesInDirectories( repositoryRoot, pkg?.workspaces || [ packagesPath ] )
-}
-
-const selectPackageToUpdate = async ( repositoryRoot, packagePaths ) => {
-  const currentPath = process.cwd()
-  const currentPackageRelativePath = path.relative( repositoryRoot, currentPath )
-  
-  const { packageName } = await prompt( {
-    type : 'select',
-    name : 'packageName',
-    message : 'What package are you releasing?',
-    choices : packagePaths,
-    initial : currentPackageRelativePath
-  } )
-
-  return path.join( repositoryRoot, packageName )
-}
-
-const getPackagePath = async ( { repositoryRoot, packagesPath = DEFAULT_PACKAGES_PATH } ) => {
-  const packagePaths = await getMonorepoPackagePaths( repositoryRoot, packagesPath )
-  if ( packagePaths.length > 0 ) {
-    return selectPackageToUpdate( repositoryRoot, packagePaths )
-  }
-
-  return repositoryRoot
-}
-
-const checkoutToBranch = async ( { branch } ) => {
-  try {
-    await $`git checkout ${branch}`
-  } catch ( err ) {
-    console.log( err.stderr || err )
-    process.exit( 1 )
-  }
-}
-
-const getPackageJsonVersion = async ( packagePath ) => {
-  if ( !packagePath ) {
-    console.log( `
-${colors.bold.red( 'ERROR:' )} Could not find a package.json file.
-The tag-release script must run from a npm project.
-  ` )
-    return process.exit( 1 )
-  }
-
-  const packageJson = await readPackage( { cwd : packagePath } )
-  return packageJson.version
-}
-
-const getNextVersions = ( currentVersion ) => {
-  const regex = /^(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:-(\w+)\.(\d+))?$/i
-  const [ , dirtyMajor, dirtyMinor, dirtyPatch, testTag, dirtyTestVersion ] = currentVersion.match( regex )
-  const major = parseInt( dirtyMajor )
-  const minor = parseInt( dirtyMinor ) || 0
-  const patch = parseInt( dirtyPatch ) || 0
-  const testVersion = parseInt( dirtyTestVersion ) || 0
-
-  const nextMajor = `${major + 1}.0.0`
-  const nextMinor = `${major}.${minor + 1}.0`
-  const nextPatch = `${major}.${minor}.${patch + 1}`
-
-  const nextAlpha = testTag === 'alpha' ?
-    `${major}.${minor}.${patch}-alpha.${testVersion + 1}` :
-    `${major}.${minor}.${patch + 1}-alpha.1`
-
-  const nextBeta = testTag === 'beta' ?
-    `${major}.${minor}.${patch}-beta.${testVersion + 1}` :
-    `${major}.${minor}.${patch + 1}-beta.1`
-
-  const nextTestTag = testTag && ![ 'alpha', 'beta' ].includes( testTag ) ?
-    `${major}.${minor}.${patch}-${testTag}.${testVersion + 1}` :
-    null
-
-  return {
-    nextMajor,
-    nextMinor,
-    nextPatch,
-    nextAlpha,
-    nextBeta,
-    nextTestTag,
-    testTag,
-  }
-}
-
-const promptForVersion = async ( currentVersion ) => {
-  const {
-    nextMajor,
-    nextMinor,
-    nextPatch,
-    nextAlpha,
-    nextBeta,
-    nextTestTag,
-    testTag
-  } = getNextVersions( currentVersion )
-
-  const choices = [
-    { hint : '(major release)', value : nextMajor },
-    { hint : '(minor release)', value : nextMinor },
-    { hint : '(patch release)', value : nextPatch },
-    { hint : '(alpha release)', value : nextAlpha },
-    { hint : '(beta release)', value : nextBeta },
-    ...( nextTestTag ? [ { hint : `(${testTag} release)`, value : nextTestTag } ] : [] ),
-    { hint : '(current version)', value : currentVersion },
-    { value : 'custom' },
-  ]
-  const { version } = await prompt( {
-    type : 'select',
-    name : 'version',
-    message : `What version are you releasing (current version is ${currentVersion})?`,
-    choices,
-  } )
-
-  if ( version === 'custom' ) {
-    const { customVersion } = await prompt( {
-      type : 'input',
-      name : 'customVersion',
-      message : `What custom version are you releasing (current version is ${currentVersion})?`,
-      initial : currentVersion
-    } )
-    return customVersion
-  }
-
-  return version
-}
-
-const getVersion = async ( { branch, packagePath } ) => {
-  const currentVersion = await getPackageJsonVersion( packagePath )
-  return promptForVersion( currentVersion )
-}
-
-const getPackageName = async ( { packagePath } ) => {
-  const noTrailingSlashPath = packagePath.slice( -1 ) === '/' ?
-    packagePath.substr( 0, packagePath.length - 1 ) :
-    packagePath
-  return noTrailingSlashPath.split( '/' ).slice( -1 )[0]
-}
-
-const getBuildMessage = ( { isPackageInRepositoryRoot, packageName, version } ) => {
-  if ( isPackageInRepositoryRoot ) {
-    return `BUILD v${version}`
-  }
-  return `BUILD ${packageName}/v${version}`
-}
-
-const getGitTagSuffix = async () => {
-  const { tagSuffix } = await prompt( {
-    type : 'input',
-    name : 'tagSuffix',
-    message : 'What suffix you like to add to the tag name for git? (e.g: "-RC.1" for v1.2.3-RC.1)',
-  } )
-  return tagSuffix
-}
-
-const getGitAnnotationMessage = async ( { tagName } ) => {
-  const { annotationMessage } = await prompt( {
-    type : 'input',
-    name : 'annotationMessage',
-    message : 'What annotation message would you like to add to git tag?',
-    initial : tagName
-  } )
-  return annotationMessage
-}
-
-const confirmPushCommit = async ( buildMessage ) => {
-  const { confirm } = await prompt( [ {
-    type : 'confirm',
-    name : 'confirm',
-    message : `${colors.bold.red( '[Warning]' )} Commit and push ${colors.bold.yellow( buildMessage )} to git remote?`
-  } ] )
-  return confirm
-}
-
-const isPackageInRepositoryRoot = async ( { repositoryRoot, packagePath } ) => {
-  return repositoryRoot === packagePath
-}
-
-const promptForNpmjsTag = async ( { isBetaRelease } ) => {
-  const choices = Object.values( NPMJS_TAGS ).map( option => ( {
-    value : option,
-    ...( ( isBetaRelease && option === NPMJS_TAGS.LATEST ) && { disabled : '(not available for beta releases)' } )
-  } ) )
-  const { npmjsTag } = await prompt( {
-    type : 'select',
-    name : 'npmjsTag',
-    message : 'Which npmjs tag would you like to use when publishing?',
-    choices,
-    initial : isBetaRelease ? NPMJS_TAGS.BETA : NPMJS_TAGS.LATEST,
-  } )
-  return npmjsTag
-}
-
-const confirmTagRelease = async ( { isBetaRelease, publishable } ) => {
-  const message = [
-    'Releasing will commit',
-    isBetaRelease ? ' and push' : ', push, and tag',
-    ' the version in git',
-    publishable ? ' and npm' : '',
-    '. Proceed?'
-  ].join( '' )
-
-  const { confirmResponse } = await prompt( {
-    type : 'select',
-    name : 'confirmResponse',
-    message,
-    choices : [ 'yes', 'no', 'advanced' ],
-    initial : 'yes',
-  } )
-
-  if ( confirmResponse === 'no' ) {
-    console.log( 'Aborting...' )
-    process.exit()
-  }
-
-  return confirmResponse
-}
-
-const isWorkspacePackage = async () => {
-  const gitRootDirectory = await getGitRootDirectory()
-  try {
-    const packageJson = await readPackage( { cwd : gitRootDirectory } )
-    return packageJson?.workspaces?.length > 0
-  } catch ( err ) {
-    return false
-  }
-}
-
-const updateNpmPackageJsonAndLock = async ( config ) => {
-  const { version, packagePath, isPackageInRepositoryRoot } = config
-
-  const isWorkspace = await isWorkspacePackage()
-
-  try {
-    if ( !isPackageInRepositoryRoot ) {
-      await $`npm version --no-git-tag-version ${version} --prefix ${packagePath}`.quiet().nothrow()
-      if ( isWorkspace ) {
-        await $`npm install`
-      } else {
-        await $`npm install --prefix ${packagePath}`
-      }
-    } else {
-      await $`npm version --no-git-tag-version ${version}`.quiet().nothrow()
-    }
-  } catch ( err ) {
-    console.log( err.stderr || err )
-    process.exit( 1 )
-  }
-}
-
-const createNewBuildCommit = async ( { buildMessage } ) => {
-  try {
-    await $`git add .`
-    await $`git commit --allow-empty -m ${buildMessage}`
-  } catch ( err ) {
-    console.log( err.stderr || err )
-    process.exit( 1 )
-  }
-}
-
-const pushToGitRemote = async () => {
-  try {
-    await $`git push`
-  } catch ( err ) {
-    console.log( err.stderr || err )
-    process.exit( 1 )
-  }
-}
-
-const commitAndPushNewBuild = async ( config ) => {
-  const { buildMessage, noConfirm } = config
-
-  const confirmAnswer = noConfirm || await confirmPushCommit( buildMessage )
-  if ( !confirmAnswer ) {
-    console.log( 'Aborting...' )
-    process.exit()
-  }
-
-  await updateNpmPackageJsonAndLock( config )
-  await createNewBuildCommit( config )
-  await pushToGitRemote()
-}
-
-const confirmPushTag = async ( tagName, annotationMessage ) => {
-  const { confirm } = await prompt( [ {
-    type : 'confirm',
-    name : 'confirm',
-    message : `${colors.bold.red( '[Warning]' )} Push new tag ${colors.bold.yellow( tagName )} with annotation message "${colors.bold.yellow( annotationMessage )}" to git remote?`
-  } ] )
-  return confirm
-}
-
-const createGitTag = async ( tagName, annotationMessage ) => {
-  try {
-    await $`git tag -a ${tagName} -m "${annotationMessage}"`
-  } catch ( err ) {
-    console.log( err.stderr || err )
-    process.exit( 1 )
-  }
-}
-
-const pushGitTag = async ( tagName ) => {
-  try {
-    await $`git push origin ${tagName}`
-  } catch ( err ) {
-    console.log( err.stderr || err )
-    process.exit( 1 )
-  }
-}
-
-const createAndPushGitTag = async ( { tagName, annotationMessage, noConfirm } ) => {
-  const confirmAnswer = noConfirm || await confirmPushTag( tagName, annotationMessage )
-  if ( confirmAnswer ) {
-    await createGitTag( tagName, annotationMessage )
-    await pushGitTag( tagName )
-  }
-}
-
-const confirmPublishToNpmjs = async ( version, npmjsTag ) => {
-  const { confirm } = await prompt( [ {
-    type : 'confirm',
-    name : 'confirm',
-    message : `${colors.bold.red( '[Warning]' )} Publish new version ${colors.bold.yellow( version )} to npmjs with tag ${colors.bold.yellow( npmjsTag )}?`
-  } ] )
-  return confirm
-}
-
-const publishToNpmjs = async ( { version, npmjsTag, noConfirm } ) => {
-  const confirmAnswer = noConfirm || await confirmPublishToNpmjs( version, npmjsTag )
-  if ( !confirmAnswer ) {
-    console.log( 'Aborting...' )
-    process.exit()
-  }
-
-  try {
-    await $`npm publish --tag ${npmjsTag}`
-  } catch ( err ) {
-    console.log( err.stderr || err )
-    process.exit( 1 )
-  }
-}
-
-const displayReleaseInfo = ( config ) => {
-  const {
-    branch,
-    version,
-    repositoryRoot,
-    packageName,
-    packagePath,
-    buildMessage,
-    tagName,
-    annotationMessage,
-    publishable,
-    npmjsTag,
-    isBetaRelease,
-    noGitTag,
-  } = config
-
-  console.log( `
-
-${colors.bold.green( '============ Tag Release Summary ============' )}
-${colors.blue( 'Branch:' )} ${branch}
-${colors.blue( 'Version:' )} ${version}
-${colors.blue( 'Root directory:' )} ${repositoryRoot}
-${colors.blue( 'Package name:' )} ${packageName}
-${colors.blue( 'package.json path:' )} ${path.join( packagePath, 'package.json' )}${buildMessage ? `
-${colors.blue( 'Commit message:' )} ${buildMessage}` : ''}${isBetaRelease || noGitTag ? '' : `
-${colors.blue( 'Git tag:' )} ${tagName}`}${isBetaRelease || noGitTag ? '' : `
-${colors.blue( 'Git tag annotation:' )} ${annotationMessage}`}${publishable ? `
-${colors.blue( 'Npmjs tag:' )} ${npmjsTag}` : ''}
-${colors.bold.green( '=============================================' )}
-` )
-}
-
-/**
- * Script
- */
-
-const optionList = [
-  { 
-    name : 'branch',
-    type : String,
-    alias : 'b',
-    description : 'branch where the tag will be created',
-  },
-  {
-    name : 'npmjs-tag',
-    type : String,
-    alias : 'n',
-    description : 'npmjs package tag to be used when publishing (for npmjs lib repositories)',
-    typeLabel : 'alpha|beta|latest'
-  },
-  {
-    name : 'version',
-    type : String,
-    alias : 'v',
-    description : 'version to be tagged',
-  },
-  {
-    name : 'publishable',
-    type : Boolean,
-    alias : 'p',
-    description : 'flag to indicate the repository is publishable to npmjs',
-  },
-  {
-    name : 'package-path',
-    type : String,
-    alias : 'a',
-    description : 'relative path to the package from the projec\'s root in case it\'s a monorepo',
-  },
-  {
-    name : 'tag-suffix',
-    type : String,
-    alias : 't',
-    description : 'tag suffix to be appended to the version when pushing to git',
-  },
-  {
-    name : 'annotation-message',
-    type : String,
-    alias : 'm',
-    description : 'annotation message that will annotate the git tag',
-  },
-  { 
-    name : 'branch-filter',
-    type : String,
-    alias : 'f',
-    description : 'branch filter used to filter available branches in interactive mode',
-  },
-  {
-    name : 'no-commit',
-    type : Boolean,
-    description : 'do not create a new commit on git (in case the goal is just tagging it)',
-  },
-  {
-    name : 'no-git-tag',
-    type : Boolean,
-    description : 'do not create a new tag on git',
-  },
-  { 
-    name : 'no-confirm',
-    type : Boolean,
-    description : 'push to git and publish to npmjs without asking for confirmation',
-  },
-  { 
-    name : 'help',
-    type : Boolean,
-    alias : 'h',
-    description : 'show this help',
-  },
-]
-
-const sections = [
-  {
-    header : 'Tag release script',
-    content : 'This script is intended to give users a simple way to create git tags, push them and publish to Npmjs (if the --publishable flag is passed)',
-  },
-  { header : 'Options',
-    optionList,
-  },
-]
-
-const args = cliArgs( optionList, { partial : true } )
-const help = cliHelp( sections )
-
-if ( args.help ) {
-  console.log( help )
-  process.exit()
-}
-
-validateArgs( args )
-
-const config = {}
-
-config.noConfirm = !!args['no-confirm']
-
-config.noCommit = !!args['no-commit']
-
-config.noGitTag = !!args['no-git-tag']
-
-config.repositoryRoot = await getGitRootDirectory()
-
-config.branch = args.branch || await getBranch( { branchFilter : args['branch-filter'] } )
-
-await checkoutToBranch( config )
-
-const argsPackagePath = args['package-path'] && path.join( config.repositoryRoot, args['package-path'] )
-config.packagePath = argsPackagePath || await getPackagePath( config )
-
-config.isPackageInRepositoryRoot = await isPackageInRepositoryRoot( config )
-
-config.version = args.version || await getVersion( config )
-
-config.packageName = await getPackageName( config )
-
-config.buildMessage = config.noCommit ? '' : getBuildMessage( config )
-
-config.isBetaRelease = config.version.includes( '-beta.' )
-
-if ( !config.isBetaRelease && !config.noGitTag ) {
-  const tagSuffix = args['tag-suffix'] ?? await getGitTagSuffix()
-  const tagPrefix = config.isPackageInRepositoryRoot ? '' : `${config.packageName}/`
-  config.tagName = `${tagPrefix}v${config.version}${tagSuffix}`
-
-  const annotationMessage = args['annotation-message'] ?? await getGitAnnotationMessage( config )
-  config.annotationMessage = annotationMessage
-}
-
-config.publishable = !!args.publishable
-if ( config.publishable ) {
-  validateNpmjsTag( { config, args } )
-  config.npmjsTag = args['npmjs-tag'] || await promptForNpmjsTag( config )
-}
-
-displayReleaseInfo( config )
-
-if ( !config.noConfirm ) {
-  const confirmResponse = await confirmTagRelease( config )
-  if ( confirmResponse === 'yes' ) {
-    config.noConfirm = true
-  }
-}
-
-if ( !config.noCommit ) { await commitAndPushNewBuild( config ) }
-if ( !config.isBetaRelease && !config.noGitTag ) { await createAndPushGitTag( config ) }
-if ( config.publishable ) { await publishToNpmjs( config ) }
-
-process.exit()