@ckeditor/ckeditor5-dev-release-tools 37.0.1 → 38.0.0-alpha.0

package/lib/index.js

@@ -5,28 +5,40 @@
 
 'use strict';
 
-const releaseSubRepositories = require( './tasks/releasesubrepositories' );
-const preparePackages = require( './tasks/preparepackages' );
-const bumpVersions = require( './tasks/bumpversions' );
 const generateChangelogForSinglePackage = require( './tasks/generatechangelogforsinglepackage' );
 const generateChangelogForMonoRepository = require( './tasks/generatechangelogformonorepository' );
-const updateCKEditor5Dependencies = require( './tasks/updateckeditor5dependencies' );
-const updateDependenciesVersions = require( './utils/updatedependenciesversions' );
+const updateDependencies = require( './tasks/updatedependencies' );
+const commitAndTag = require( './tasks/commitandtag' );
+const createGithubRelease = require( './tasks/creategithubrelease' );
+const reassignNpmTags = require( './tasks/reassignnpmtags' );
+const prepareRepository = require( './tasks/preparerepository' );
+const push = require( './tasks/push' );
+const publishPackages = require( './tasks/publishpackages' );
+const updateVersions = require( './tasks/updateversions' );
+const cleanUpPackages = require( './tasks/cleanuppackages' );
 const { getLastFromChangelog, getCurrent, getLastTagFromGit } = require( './utils/versions' );
 const { getChangesForVersion, getChangelog, saveChangelog } = require( './utils/changelog' );
+const executeInParallel = require( './utils/executeinparallel' );
+const validateRepositoryToRelease = require( './utils/validaterepositorytorelease' );
 
 module.exports = {
-	releaseSubRepositories,
-	preparePackages,
-	bumpVersions,
 	generateChangelogForSinglePackage,
 	generateChangelogForMonoRepository,
-	updateCKEditor5Dependencies,
+	updateDependencies,
+	updateVersions,
+	prepareRepository,
+	commitAndTag,
+	createGithubRelease,
+	push,
+	cleanUpPackages,
+	publishPackages,
+	reassignNpmTags,
+	executeInParallel,
 	getLastFromChangelog,
 	getCurrent,
 	getLastTagFromGit,
 	getChangesForVersion,
 	getChangelog,
 	saveChangelog,
-	updateDependenciesVersions
+	validateRepositoryToRelease
 };

package/lib/tasks/cleanuppackages.js

@@ -0,0 +1,175 @@
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+'use strict';
+
+const fs = require( 'fs-extra' );
+const upath = require( 'upath' );
+const { glob } = require( 'glob' );
+
+/**
+ * The purpose of the script is to clean all packages prepared for the release. The cleaning consists of two stages:
+ *
+ * - Removes unnecessary files and empty directories from the package directory. Unnecessary files are those not matched by any entry from
+ *   the `files` field in `package.json`. Some files are never removed, even if they are not matched by the `files` patterns:
+ *   - `package.json`,
+ *   - `LICENSE.md`
+ *   - `README.md`
+ *   - file pointed by the `main` field from `package.json`
+ *   - file pointed by the `types` field from `package.json`
+ * - Removes unnecessary fields from the `package.json` file.
+ *
+ * @param {Object} options
+ * @param {String} options.packagesDirectory Relative path to a location of packages to be cleaned up.
+ * @param {Array.<String>} [options.packageJsonFieldsToRemove] Fields to remove from `package.json`. If not set, a predefined list is used.
+ * @param {String} [options.cwd] Current working directory from which all paths will be resolved.
+ * @returns {Promise}
+ */
+module.exports = async function cleanUpPackages( options ) {
+	const { packagesDirectory, packageJsonFieldsToRemove, cwd } = parseOptions( options );
+
+	const packageJsonPaths = await glob( '*/package.json', {
+		cwd: upath.join( cwd, packagesDirectory ),
+		nodir: true,
+		absolute: true
+	} );
+
+	for ( const packageJsonPath of packageJsonPaths ) {
+		const packagePath = upath.dirname( packageJsonPath );
+		const packageJson = await fs.readJson( packageJsonPath );
+
+		await cleanUpPackageDirectory( packageJson, packagePath );
+		cleanUpPackageJson( packageJson, packageJsonFieldsToRemove );
+
+		await fs.writeJson( packageJsonPath, packageJson, { spaces: 2 } );
+	}
+};
+
+/**
+ * Prepares the configuration options for the script.
+ *
+ * @param {Object} options
+ * @param {String} options.packagesDirectory
+ * @param {Array.<String>} [options.packageJsonFieldsToRemove=['devDependencies','depcheckIgnore','scripts','private']]
+ * @param {String} [options.cwd=process.cwd()]
+ * @returns {Object}
+ */
+function parseOptions( options ) {
+	const {
+		packagesDirectory,
+		packageJsonFieldsToRemove = [ 'devDependencies', 'depcheckIgnore', 'scripts', 'private' ],
+		cwd = process.cwd()
+	} = options;
+
+	return {
+		packagesDirectory: upath.normalizeTrim( packagesDirectory ),
+		packageJsonFieldsToRemove,
+		cwd: upath.normalizeTrim( cwd )
+	};
+}
+
+/**
+ * Removes unnecessary files and directories from the package directory.
+ *
+ * @param {Object} packageJson
+ * @param {String} packagePath
+ * @returns {Promise}
+ */
+async function cleanUpPackageDirectory( packageJson, packagePath ) {
+	if ( packageJson.files ) {
+		// Find and remove files that don't match the `files` field in the `package.json`.
+		const files = await glob( '**', {
+			cwd: packagePath,
+			absolute: true,
+			nodir: true,
+			dot: true,
+			ignore: [
+				'README.md',
+				'LICENSE.md',
+				'package.json',
+				...getIgnoredFilePatterns( packageJson )
+			]
+		} );
+
+		for ( const file of files ) {
+			await fs.remove( file );
+		}
+	}
+
+	// Find and remove empty directories in the package directory.
+	const globResults = await glob( '**/', {
+		cwd: packagePath,
+		absolute: true,
+		dot: true
+	} );
+	const directories = globResults
+		.map( path => upath.normalize( path ) )
+		.sort( sortPathsFromDeepestFirst );
+
+	for ( const directory of directories ) {
+		const isEmpty = ( await fs.readdir( directory ) ).length === 0;
+
+		if ( isEmpty ) {
+			await fs.remove( directory );
+		}
+	}
+
+	// Remove `node_modules`.
+	await fs.remove( upath.join( packagePath, 'node_modules' ) );
+}
+
+/**
+ * Creates an array of patterns to ignore for the `glob` calls.
+ *
+ * @param {Object} packageJson
+ * @returns {Array.<String>}
+ */
+function getIgnoredFilePatterns( packageJson ) {
+	// The patterns supported by `package.json` in the `files` field do not correspond 1:1 to the patterns expected by the `glob`.
+	// For this reason, we always treat each pattern from `files` as if it was the beginning of a path to match - not just a final path.
+	//
+	// Example: for the entry `src` we prepare the `src/**` pattern for `glob`.
+	//
+	// If the globstar pattern (`**`) is alone in a path portion, then it matches zero or more directories and subdirectories.
+	const patterns = packageJson.files.map( pattern => pattern + '/**' );
+
+	if ( packageJson.main ) {
+		patterns.push( packageJson.main );
+	}
+
+	if ( packageJson.types ) {
+		patterns.push( packageJson.types );
+	}
+
+	return patterns;
+}
+
+/**
+ * Removes unnecessary fields from the `package.json`.
+ *
+ * @param {Object} packageJson
+ * @param {Array.<String>} packageJsonFieldsToRemove
+ */
+function cleanUpPackageJson( packageJson, packageJsonFieldsToRemove ) {
+	for ( const key of Object.keys( packageJson ) ) {
+		if ( packageJsonFieldsToRemove.includes( key ) ) {
+			delete packageJson[ key ];
+		}
+	}
+}
+
+/**
+ * Sort function that defines the order of the paths. It sorts paths from the most nested ones first.
+ *
+ * @param {String} firstPath
+ * @param {String} secondPath
+ * @returns {Number}
+ */
+function sortPathsFromDeepestFirst( firstPath, secondPath ) {
+	const firstPathSegments = firstPath.split( '/' ).length;
+	const secondPathSegments = secondPath.split( '/' ).length;
+
+	return secondPathSegments - firstPathSegments;
+}

package/lib/tasks/commitandtag.js

@@ -0,0 +1,28 @@
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+'use strict';
+
+const { tools } = require( '@ckeditor/ckeditor5-dev-utils' );
+const { toUnix } = require( 'upath' );
+const { glob } = require( 'glob' );
+
+/**
+ * Creates a commit and a tag for specified version.
+ *
+ * @param {Object} options
+ * @param {String} options.version The commit will contain this param in its message and the tag will have a `v` prefix.
+ * @param {Array.<String>} options.files Array of glob patterns for files to be added to the release commit.
+ * @param {String} [options.cwd=process.cwd()] Current working directory from which all paths will be resolved.
+ * @returns {Promise}
+ */
+module.exports = async function commitAndTag( { version, files, cwd = process.cwd() } ) {
+	const normalizedCwd = toUnix( cwd );
+	const filePathsToAdd = await glob( files, { cwd: normalizedCwd, absolute: true, nodir: true } );
+
+	await tools.shExec( `git add ${ filePathsToAdd.join( ' ' ) }`, { cwd: normalizedCwd, async: true } );
+	await tools.shExec( `git commit --message "Release: v${ version }."`, { cwd: normalizedCwd, async: true } );
+	await tools.shExec( `git tag v${ version }`, { cwd: normalizedCwd, async: true } );
+};

package/lib/tasks/creategithubrelease.js

@@ -0,0 +1,104 @@
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+'use strict';
+
+const { Octokit } = require( '@octokit/rest' );
+const semver = require( 'semver' );
+
+/**
+ * Create a GitHub release.
+ *
+ * @param {Object} options
+ * @param {String} options.token Token used to authenticate with GitHub.
+ * @param {String} options.version Name of tag connected with the release.
+ * @param {String} options.repositoryOwner Owner of the repository.
+ * @param {String} options.repositoryName Repository name.
+ * @param {String} options.description Description of the release.
+ * @returns {Promise.<String>}
+ */
+module.exports = async function createGithubRelease( options ) {
+	const {
+		token,
+		version,
+		repositoryOwner,
+		repositoryName,
+		description
+	} = options;
+
+	const github = new Octokit( {
+		version: '3.0.0',
+		auth: `token ${ token }`
+	} );
+
+	if ( await shouldCreateRelease( github, repositoryOwner, repositoryName, version ) ) {
+		await github.repos.createRelease( {
+			tag_name: `v${ version }`,
+			owner: repositoryOwner,
+			repo: repositoryName,
+			body: description,
+			prerelease: getVersionTag( version ) !== 'latest'
+		} );
+	}
+
+	return `https://github.com/${ repositoryOwner }/${ repositoryName }/releases/tag/v${ version }`;
+};
+
+/**
+ * Returns an npm tag based on the specified release version.
+ *
+ * @param {String} version
+ * @returns {String}
+ */
+function getVersionTag( version ) {
+	const [ versionTag ] = semver.prerelease( version ) || [ 'latest' ];
+
+	return versionTag;
+}
+
+/**
+ * Resolves a promise containing a flag if the GitHub contains the release page for given version.
+ *
+ * @param {Octokit} github
+ * @param {String} repositoryOwner
+ * @param {String} repositoryName
+ * @param {String} version
+ * @returns {Promise.<boolean>}
+ */
+async function shouldCreateRelease( github, repositoryOwner, repositoryName, version ) {
+	const releaseDetails = await getLastRelease( github, repositoryOwner, repositoryName );
+
+	// It can be `null` if there is no releases on GitHub.
+	let githubVersion = releaseDetails.data.tag_name;
+
+	if ( githubVersion ) {
+		githubVersion = releaseDetails.data.tag_name.replace( /^v/, '' );
+	}
+
+	// If versions are different, we are ready to create a new release.
+	return githubVersion !== version;
+}
+
+function getLastRelease( github, repositoryOwner, repositoryName ) {
+	const requestParams = {
+		owner: repositoryOwner,
+		repo: repositoryName
+	};
+
+	return github.repos.getLatestRelease( requestParams )
+		.catch( err => {
+			// If the "last release" returned the 404 error page, it means that this release
+			// will be the first one for specified `repositoryOwner/repositoryName` package.
+			if ( err.status == 404 ) {
+				return Promise.resolve( {
+					data: {
+						tag_name: null
+					}
+				} );
+			}
+
+			return Promise.reject( err );
+		} );
+}

package/lib/tasks/preparerepository.js

@@ -0,0 +1,149 @@
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+'use strict';
+
+const fs = require( 'fs-extra' );
+const glob = require( 'glob' );
+const upath = require( 'upath' );
+
+/**
+ * The goal is to prepare the release directory containing the packages we want to publish.
+ *
+ * @param {Object} options
+ * @param {String} options.outputDirectory Relative path to the destination directory where packages will be stored.
+ * @param {String} [options.cwd] Root of the repository to prepare. `process.cwd()` by default.
+ * @param {String} [options.packagesDirectory] Relative path to a location of packages.
+ * If specified, all of the found packages will be copied.
+ * @param {Array.<String>} [options.packagesToCopy] List of packages that should be processed.
+ * If not specified, all packages found in `packagesDirectory` are considered.
+ * @param {RootPackageJson} [options.rootPackageJson] Object containing values to use in the created the `package.json` file.
+ * If not specified, the root package will not be created.
+ * @returns {Promise}
+ */
+module.exports = async function prepareRepository( options ) {
+	const {
+		outputDirectory,
+		packagesDirectory,
+		packagesToCopy,
+		rootPackageJson,
+		cwd = process.cwd()
+	} = options;
+
+	if ( !rootPackageJson && !packagesDirectory ) {
+		return;
+	}
+
+	const outputDirectoryPath = upath.join( cwd, outputDirectory );
+	await fs.ensureDir( outputDirectoryPath );
+	const outputDirContent = await fs.readdir( outputDirectoryPath );
+
+	if ( outputDirContent.length ) {
+		throw new Error( `Output directory is not empty: "${ outputDirectoryPath }".` );
+	}
+
+	const copyPromises = [];
+
+	if ( rootPackageJson ) {
+		validateRootPackage( rootPackageJson );
+
+		const copyRootItemsPromises = await processRootPackage( {
+			cwd,
+			rootPackageJson,
+			outputDirectoryPath
+		} );
+
+		copyPromises.push( ...copyRootItemsPromises );
+	}
+
+	if ( packagesDirectory ) {
+		const copyPackagesPromises = await processMonorepoPackages( {
+			cwd,
+			packagesDirectory,
+			packagesToCopy,
+			outputDirectoryPath
+		} );
+
+		copyPromises.push( ...copyPackagesPromises );
+	}
+
+	return Promise.all( copyPromises );
+};
+
+/**
+ * @param {Object} packageJson
+ * @param {String} [packageJson.name]
+ * @param {Array.<String>} [packageJson.files]
+ */
+function validateRootPackage( packageJson ) {
+	if ( !packageJson.name ) {
+		throw new Error( '"rootPackageJson" option object must have a "name" field.' );
+	}
+
+	if ( !packageJson.files ) {
+		throw new Error( '"rootPackageJson" option object must have a "files" field.' );
+	}
+}
+
+/**
+ * @param {Object} options
+ * @param {String} options.cwd
+ * @param {RootPackageJson} options.rootPackageJson
+ * @param {String} options.outputDirectoryPath
+ * @returns {Promise}
+ */
+async function processRootPackage( { cwd, rootPackageJson, outputDirectoryPath } ) {
+	const rootPackageOutputPath = upath.join( outputDirectoryPath, rootPackageJson.name );
+	const pkgJsonOutputPath = upath.join( rootPackageOutputPath, 'package.json' );
+
+	await fs.ensureDir( rootPackageOutputPath );
+	await fs.writeJson( pkgJsonOutputPath, rootPackageJson, { spaces: 2, EOL: '\n' } );
+
+	return glob.sync( rootPackageJson.files ).map( absoluteFilePath => {
+		const relativeFilePath = upath.relative( cwd, absoluteFilePath );
+		const absoluteFileOutputPath = upath.join( rootPackageOutputPath, relativeFilePath );
+
+		return fs.copy( absoluteFilePath, absoluteFileOutputPath );
+	} );
+}
+
+/**
+ * @param {Object} options
+ * @param {String} options.cwd
+ * @param {String} options.packagesDirectory
+ * @param {String} options.outputDirectoryPath
+ * @param {Array.<String>} [options.packagesToCopy]
+ * @returns {Promise}
+ */
+async function processMonorepoPackages( { cwd, packagesDirectory, packagesToCopy, outputDirectoryPath } ) {
+	const packagesDirectoryPath = upath.join( cwd, packagesDirectory );
+	const packageDirs = packagesToCopy || await fs.readdir( packagesDirectoryPath );
+
+	return packageDirs.map( async packageDir => {
+		const packagePath = upath.join( packagesDirectoryPath, packageDir );
+		const isDir = ( await fs.lstat( packagePath ) ).isDirectory();
+
+		if ( !isDir ) {
+			return;
+		}
+
+		const pkgJsonPath = upath.join( packagePath, 'package.json' );
+		const hasPkgJson = await fs.exists( pkgJsonPath );
+
+		if ( !hasPkgJson ) {
+			return;
+		}
+
+		return fs.copy( packagePath, upath.join( outputDirectoryPath, packageDir ) );
+	} );
+}
+
+/**
+ * @typedef {Object} RootPackageJson
+ *
+ * @param {String} options.rootPackageJson.name Name of the package. Required value.
+ *
+ * @param {Array.<String>} options.rootPackageJson.files Array containing a list of files or directories to copy. Required value.
+ */

package/lib/tasks/publishpackages.js

@@ -0,0 +1,69 @@
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+'use strict';
+
+const upath = require( 'upath' );
+const { glob } = require( 'glob' );
+const assertNpmAuthorization = require( '../utils/assertnpmauthorization' );
+const assertPackages = require( '../utils/assertpackages' );
+const assertNpmTag = require( '../utils/assertnpmtag' );
+const assertFilesToPublish = require( '../utils/assertfilestopublish' );
+const publishPackagesOnNpm = require( '../utils/publishpackagesonnpm' );
+
+/**
+ * The purpose of the script is to validate the packages prepared for the release and then release them on npm.
+ *
+ * The validation contains the following steps in each package:
+ * - User must be logged to npm on the specified account.
+ * - The package directory mmust contain `package.json` file.
+ * - All other files expected to be released must exist in the package directory.
+ * - The npm tag must match the tag calculated from the package version.
+ *
+ * When the validation for each package passes, packages are published on npm. Optional callback is called for confirmation whether to
+ * continue.
+ *
+ * @param {Object} options
+ * @param {String} options.packagesDirectory Relative path to a location of packages to release.
+ * @param {String} options.npmOwner The account name on npm, which should be used to publish the packages.
+ * @param {ListrTaskObject} options.listrTask An instance of `ListrTask`.
+ * @param {String} [options.npmTag='staging'] The npm distribution tag.
+ * @param {Object.<String, Array.<String>>|null} [options.optionalEntries=null] Specifies which entries from the `files` field in the
+ * `package.json` are optional. The key is a package name, and its value is an array of optional entries from the `files` field, for which
+ * it is allowed not to match any file. The `options.optionalEntries` object may also contain the `default` key, which is used for all
+ * packages that do not have own definition.
+ * @param {String} [options.confirmationCallback=null] An callback whose response decides to continue the publishing packages. Synchronous
+ * and asynchronous callbacks are supported.
+ * @param {String} [options.cwd=process.cwd()] Current working directory from which all paths will be resolved.
+ * @returns {Promise}
+ */
+module.exports = async function publishPackages( options ) {
+	const {
+		packagesDirectory,
+		npmOwner,
+		listrTask,
+		npmTag = 'staging',
+		optionalEntries = null,
+		confirmationCallback = null,
+		cwd = process.cwd()
+	} = options;
+
+	await assertNpmAuthorization( npmOwner );
+
+	const packagePaths = await glob( '*/', {
+		cwd: upath.join( cwd, packagesDirectory ),
+		absolute: true
+	} );
+
+	await assertPackages( packagePaths );
+	await assertFilesToPublish( packagePaths, optionalEntries );
+	await assertNpmTag( packagePaths, npmTag );
+
+	const shouldPublishPackages = confirmationCallback ? await confirmationCallback() : true;
+
+	if ( shouldPublishPackages ) {
+		await publishPackagesOnNpm( packagePaths, npmTag, listrTask );
+	}
+};

package/lib/tasks/push.js

@@ -0,0 +1,29 @@
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+'use strict';
+
+const { tools } = require( '@ckeditor/ckeditor5-dev-utils' );
+
+/**
+ * Push the local changes to a remote server.
+ *
+ * @param {Object} options
+ * @param {String} options.releaseBranch A name of the branch that should be used for releasing packages.
+ * @param {String} options.version Name of tag connected with the release.
+ * @param {String} [options.cwd] Root of the repository to prepare. `process.cwd()` by default.
+ * @returns {Promise}
+ */
+module.exports = async function push( options ) {
+	const {
+		releaseBranch,
+		version,
+		cwd = process.cwd()
+	} = options;
+
+	const command = `git push origin ${ releaseBranch } v${ version }`;
+
+	return tools.shExec( command, { cwd, verbosity: 'error', async: true } );
+};

package/lib/tasks/reassignnpmtags.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+/* eslint-env node */
+
+'use strict';
+
+const chalk = require( 'chalk' );
+const columns = require( 'cli-columns' );
+const { tools } = require( '@ckeditor/ckeditor5-dev-utils' );
+const assertNpmAuthorization = require( '../utils/assertnpmauthorization' );
+
+/**
+ * Used to switch the tags from `staging` to `latest` for specified array of packages.
+ *
+ * @param {Object} options
+ * @param {String} options.npmOwner User that is authorized to release packages.
+ * @param {String} options.version Specifies the version of packages to reassign the tags for.
+ * @param {Array.<String>} options.packages Array of packages' names to reassign tags for.
+ * @returns {Promise}
+ */
+module.exports = async function reassignNpmTags( { npmOwner, version, packages } ) {
+	const errors = [];
+	const packagesSkipped = [];
+	const packagesUpdated = [];
+
+	await assertNpmAuthorization( npmOwner );
+
+	const counter = tools.createSpinner( 'Reassigning npm tags...', { total: packages.length } );
+	counter.start();
+
+	for ( const packageName of packages ) {
+		const latestVersion = await exec( `npm show ${ packageName }@latest version` )
+			.then( version => version.trim() )
+			.catch( error => {
+				errors.push( trimErrorMessage( error.message ) );
+			} );
+
+		if ( latestVersion === version ) {
+			packagesSkipped.push( packageName );
+
+			continue;
+		}
+
+		await exec( `npm dist-tag add ${ packageName }@${ version } latest` )
+			.then( () => {
+				packagesUpdated.push( packageName );
+			} )
+			.catch( error => {
+				errors.push( trimErrorMessage( error.message ) );
+			} )
+			.finally( () => {
+				counter.increase();
+			} );
+	}
+
+	counter.finish();
+
+	if ( packagesUpdated.length ) {
+		console.log( chalk.bold.green( '✨ Tags updated:' ) );
+		console.log( columns( packagesUpdated ) );
+	}
+
+	if ( packagesSkipped.length ) {
+		console.log( chalk.bold.yellow( '⬇️ Packages skipped:' ) );
+		console.log( columns( packagesSkipped ) );
+	}
+
+	if ( errors.length ) {
+		console.log( chalk.bold.red( '🐛 Errors found:' ) );
+		errors.forEach( msg => console.log( `* ${ msg }` ) );
+	}
+};
+
+/**
+ * @param {String} message
+ * @returns {String}
+ */
+function trimErrorMessage( message ) {
+	return message.replace( /npm ERR!.*\n/g, '' ).trim();
+}
+
+/**
+ * @param {String} command
+ * @returns {Promise.<String>}
+ */
+async function exec( command ) {
+	return tools.shExec( command, { verbosity: 'silent', async: true } );
+}