@ckeditor/ckeditor5-dev-release-tools 44.0.0 → 44.1.0

package/lib/index.js

@@ -33,3 +33,4 @@ export { default as verifyPackagesPublishedCorrectly } from './tasks/verifypacka
 export { default as getNpmTagFromVersion } from './utils/getnpmtagfromversion.js';
 export { default as isVersionPublishableForTag } from './utils/isversionpublishablefortag.js';
 export { default as provideToken } from './utils/providetoken.js';
+export { default as findPathsToPackages } from './utils/findpathstopackages.js';

package/lib/tasks/cleanuppackages.js

@@ -6,6 +6,7 @@
 import fs from 'fs-extra';
 import upath from 'upath';
 import { glob } from 'glob';
+import findPathsToPackages from '../utils/findpathstopackages.js';
 
 /**
  * The purpose of the script is to clean all packages prepared for the release. The cleaning consists of two stages:
@@ -29,12 +30,7 @@ import { glob } from 'glob';
  */
 export default async function cleanUpPackages( options ) {
 	const { packagesDirectory, packageJsonFieldsToRemove, preservePostInstallHook, cwd } = parseOptions( options );
-
-	const packageJsonPaths = await glob( '*/package.json', {
-		cwd: upath.join( cwd, packagesDirectory ),
-		nodir: true,
-		absolute: true
-	} );
+	const packageJsonPaths = await findPathsToPackages( cwd, packagesDirectory, { includePackageJson: true } );
 
 	for ( const packageJsonPath of packageJsonPaths ) {
 		const packagePath = upath.dirname( packageJsonPath );

package/lib/tasks/commitandtag.js

@@ -4,9 +4,8 @@
  */
 
 import upath from 'upath';
-import { tools } from '@ckeditor/ckeditor5-dev-utils';
 import { glob } from 'glob';
-import shellEscape from 'shell-escape';
+import { simpleGit } from 'simple-git';
 
 const { toUnix } = upath;
 
@@ -27,22 +26,18 @@ export default async function commitAndTag( { version, files, cwd = process.cwd(
 		return;
 	}
 
-	const shExecOptions = {
-		cwd: normalizedCwd,
-		async: true,
-		verbosity: 'silent'
-	};
+	const git = simpleGit( {
+		baseDir: normalizedCwd
+	} );
 
-	// Run the command separately for each file to avoid exceeding the maximum command length on Windows, which is 32767 characters.
-	for ( const filePath of filePathsToAdd ) {
-		await tools.shExec( `git add ${ shellEscape( [ filePath ] ) }`, shExecOptions );
-	}
+	const { all: availableTags } = await git.tags();
+	const tagForVersion = availableTags.find( tag => tag.endsWith( version ) );
 
-	const escapedVersion = {
-		commit: shellEscape( [ `Release: v${ version }.` ] ),
-		tag: shellEscape( [ `v${ version }` ] )
-	};
+	// Do not commit and create tags if a tag is already taken. It might happen when a release job is restarted.
+	if ( tagForVersion ) {
+		return;
+	}
 
-	await tools.shExec( `git commit --message ${ escapedVersion.commit } --no-verify`, shExecOptions );
-	await tools.shExec( `git tag ${ escapedVersion.tag }`, shExecOptions );
+	await git.commit( `Release: v${ version }.`, filePathsToAdd );
+	await git.addTag( `v${ version }` );
 }

package/lib/tasks/creategithubrelease.js

@@ -4,8 +4,8 @@
  */
 
 import { Octokit } from '@octokit/rest';
-import semver from 'semver';
 import * as transformCommitUtils from '../utils/transformcommitutils.js';
+import getNpmTagFromVersion from '../utils/getnpmtagfromversion.js';
 
 const { getRepositoryUrl } = transformCommitUtils;
 
@@ -41,25 +41,13 @@ export default async function createGithubRelease( options ) {
 			owner: repositoryOwner,
 			repo: repositoryName,
 			body: description,
-			prerelease: getVersionTag( version ) !== 'latest'
+			prerelease: getNpmTagFromVersion( 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.
  *

package/lib/tasks/generatechangelogformonorepository.js

@@ -301,7 +301,14 @@ export default async function generateChangelogForMonoRepository( options ) {
 			bumpType = 'patch';
 		}
 
-		return provideNewVersionForMonoRepository( highestVersion, packageHighestVersion, bumpType, { indentLevel: 1 } )
+		const provideVersionOptions = {
+			packageName: packageHighestVersion,
+			version: highestVersion,
+			bumpType,
+			indentLevel: 1
+		};
+
+		return provideNewVersionForMonoRepository( provideVersionOptions )
 			.then( version => {
 				nextVersion = version;
 

package/lib/tasks/generatechangelogforsinglepackage.js

@@ -79,11 +79,14 @@ export default async function generateChangelogForSinglePackage( options = {} )
 		.then( () => {
 			logProcess( 'Preparing new version for the package...' );
 
-			const releaseType = getNewVersionType( allCommits );
-
 			displayCommits( allCommits, { indentLevel: 1 } );
 
-			return provideVersion( pkgJson.version, releaseType, { indentLevel: 1 } );
+			return provideVersion( {
+				packageName: pkgJson.name,
+				version: pkgJson.version,
+				indentLevel: 1,
+				releaseTypeOrNewVersion: getNewVersionType( allCommits )
+			} );
 		} )
 		.then( version => {
 			if ( version === 'skip' ) {

package/lib/tasks/publishpackages.js

@@ -4,44 +4,50 @@
  */
 
 import upath from 'upath';
-import { glob } from 'glob';
+import fs from 'fs-extra';
 import assertNpmAuthorization from '../utils/assertnpmauthorization.js';
 import assertPackages from '../utils/assertpackages.js';
 import assertNpmTag from '../utils/assertnpmtag.js';
 import assertFilesToPublish from '../utils/assertfilestopublish.js';
 import executeInParallel from '../utils/executeinparallel.js';
 import publishPackageOnNpmCallback from '../utils/publishpackageonnpmcallback.js';
+import checkVersionAvailability from '../utils/checkversionavailability.js';
+import findPathsToPackages from '../utils/findpathstopackages.js';
 
 /**
  * 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.
+ * - The package directory must 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.
  *
+ * If a package has already been published, the script does not try to publish it again. Instead, it treats the package as published.
+ * Whenever a communication between the script and npm fails, it tries to re-publish a package (up to three attempts).
+ *
  * @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 {ListrTaskObject} [options.listrTask] An instance of `ListrTask`.
  * @param {AbortSignal|null} [options.signal=null] Signal to abort the asynchronous process.
  * @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 {function|null} [options.confirmationCallback=null] An callback whose response decides to continue the publishing packages.
+ * Synchronous and asynchronous callbacks are supported.
  * @param {boolean} [options.requireEntryPoint=false] Whether to verify if packages to publish define an entry point. In other words,
  * whether their `package.json` define the `main` field.
  * @param {Array.<string>} [options.optionalEntryPointPackages=[]] If the entry point validator is enabled (`requireEntryPoint=true`),
  * this array contains a list of packages that will not be checked. In other words, they do not have to define the entry point.
  * @param {string} [options.cwd=process.cwd()] Current working directory from which all paths will be resolved.
  * @param {number} [options.concurrency=4] Number of CPUs that will execute the task.
+ * @param {number} [options.attempts=3] Number of attempts. After reaching 0, it won't be publishing packages again.
  * @returns {Promise}
  */
 export default async function publishPackages( options ) {
@@ -56,15 +62,14 @@ export default async function publishPackages( options ) {
 		requireEntryPoint = false,
 		optionalEntryPointPackages = [],
 		cwd = process.cwd(),
-		concurrency = 4
+		concurrency = 4,
+		attempts = 3
 	} = options;
 
+	const remainingAttempts = attempts - 1;
 	await assertNpmAuthorization( npmOwner );
 
-	const packagePaths = await glob( '*/', {
-		cwd: upath.join( cwd, packagesDirectory ),
-		absolute: true
-	} );
+	const packagePaths = await findPathsToPackages( cwd, packagesDirectory );
 
 	await assertPackages( packagePaths, { requireEntryPoint, optionalEntryPointPackages } );
 	await assertFilesToPublish( packagePaths, optionalEntries );
@@ -72,17 +77,69 @@ export default async function publishPackages( options ) {
 
 	const shouldPublishPackages = confirmationCallback ? await confirmationCallback() : true;
 
-	if ( shouldPublishPackages ) {
-		await executeInParallel( {
-			cwd,
-			packagesDirectory,
-			listrTask,
-			taskToExecute: publishPackageOnNpmCallback,
-			taskOptions: {
-				npmTag
-			},
-			signal,
-			concurrency
-		} );
+	if ( !shouldPublishPackages ) {
+		return Promise.resolve();
 	}
+
+	await removeAlreadyPublishedPackages( packagePaths );
+
+	await executeInParallel( {
+		cwd,
+		packagesDirectory,
+		listrTask,
+		taskToExecute: publishPackageOnNpmCallback,
+		taskOptions: {
+			npmTag
+		},
+		signal,
+		concurrency
+	} );
+
+	const packagePathsAfterPublishing = await findPathsToPackages( cwd, packagesDirectory );
+
+	// All packages have been published. No need for re-executing.
+	if ( !packagePathsAfterPublishing.length ) {
+		return Promise.resolve();
+	}
+
+	// No more attempts. Abort.
+	if ( remainingAttempts <= 0 ) {
+		throw new Error( 'Some packages could not be published.' );
+	}
+
+	// Let's give an npm a moment for taking a breath...
+	await wait( 1000 );
+
+	// ...and try again.
+	return publishPackages( {
+		packagesDirectory,
+		npmOwner,
+		listrTask,
+		signal,
+		npmTag,
+		optionalEntries,
+		requireEntryPoint,
+		optionalEntryPointPackages,
+		cwd,
+		concurrency,
+		confirmationCallback: null, // Do not ask again if already here.
+		attempts: remainingAttempts
+	} );
+}
+
+async function removeAlreadyPublishedPackages( packagePaths ) {
+	for ( const absolutePackagePath of packagePaths ) {
+		const pkgJson = await fs.readJson( upath.join( absolutePackagePath, 'package.json' ) );
+		const isAvailable = await checkVersionAvailability( pkgJson.version, pkgJson.name );
+
+		if ( !isAvailable ) {
+			await fs.remove( absolutePackagePath );
+		}
+	}
+}
+
+function wait( time ) {
+	return new Promise( resolve => {
+		setTimeout( resolve, time );
+	} );
 }

package/lib/tasks/updatedependencies.js

@@ -4,8 +4,10 @@
  */
 
 import fs from 'fs-extra';
-import { glob } from 'glob';
 import upath from 'upath';
+import findPathsToPackages from '../utils/findpathstopackages.js';
+
+const { normalizeTrim } = upath;
 
 /**
  * The purpose of this script is to update all eligible dependencies to a version specified in the `options.version`. The following packages
@@ -38,15 +40,15 @@ export default async function updateDependencies( options ) {
 		cwd = process.cwd()
 	} = options;
 
-	const globPatterns = [ 'package.json' ];
-
-	if ( packagesDirectory ) {
-		const packagesDirectoryPattern = upath.join( packagesDirectory, '*', 'package.json' );
-
-		globPatterns.push( packagesDirectoryPattern );
-	}
-
-	const pkgJsonPaths = await getPackageJsonPaths( cwd, globPatterns, packagesDirectoryFilter );
+	const pkgJsonPaths = await findPathsToPackages(
+		cwd,
+		packagesDirectory ? normalizeTrim( packagesDirectory ) : null,
+		{
+			includePackageJson: true,
+			includeCwd: true,
+			packagesDirectoryFilter
+		}
+	);
 
 	for ( const pkgJsonPath of pkgJsonPaths ) {
 		const pkgJson = await fs.readJson( pkgJsonPath );
@@ -78,28 +80,6 @@ function updateVersion( version, callback, dependencies ) {
 	}
 }
 
-/**
- * @param {string} cwd
- * @param {Array.<string>} globPatterns
- * @param {UpdateDependenciesPackagesDirectoryFilter|null} packagesDirectoryFilter
- * @returns {Promise.<Array.<string>>}
- */
-async function getPackageJsonPaths( cwd, globPatterns, packagesDirectoryFilter ) {
-	const globOptions = {
-		cwd,
-		nodir: true,
-		absolute: true
-	};
-
-	const pkgJsonPaths = await glob( globPatterns, globOptions );
-
-	if ( !packagesDirectoryFilter ) {
-		return pkgJsonPaths;
-	}
-
-	return pkgJsonPaths.filter( packagesDirectoryFilter );
-}
-
 /**
  * @callback UpdateVersionCallback
  *

package/lib/tasks/updateversions.js

@@ -5,11 +5,10 @@
 
 import upath from 'upath';
 import fs from 'fs-extra';
-import { glob } from 'glob';
 import semver from 'semver';
-import checkVersionAvailability from '../utils/checkversionavailability.js';
+import findPathsToPackages from '../utils/findpathstopackages.js';
 
-const { normalizeTrim, toUnix, dirname, join } = upath;
+const { normalizeTrim } = upath;
 
 /**
  * The purpose of the script is to update the version of a root package found in the current working
@@ -38,24 +37,18 @@ export default async function updateVersions( options ) {
 		packagesDirectoryFilter = null,
 		cwd = process.cwd()
 	} = options;
-	const normalizedCwd = toUnix( cwd );
-	const normalizedPackagesDir = packagesDirectory ? normalizeTrim( packagesDirectory ) : null;
 
-	const globPatterns = getGlobPatterns( normalizedPackagesDir );
-	const pkgJsonPaths = await getPackageJsonPaths( cwd, globPatterns, packagesDirectoryFilter );
-
-	const randomPackagePath = getRandomPackagePath( pkgJsonPaths, normalizedPackagesDir );
-
-	const { version: rootPackageVersion } = await readPackageJson( normalizedCwd );
-	const { name: randomPackageName } = await readPackageJson( randomPackagePath );
-
-	checkIfVersionIsValid( version, rootPackageVersion );
+	const pkgJsonPaths = await findPathsToPackages(
+		cwd,
+		packagesDirectory ? normalizeTrim( packagesDirectory ) : null,
+		{
+			includePackageJson: true,
+			includeCwd: true,
+			packagesDirectoryFilter
+		}
+	);
 
-	const isVersionAvailable = await checkVersionAvailability( version, randomPackageName );
-
-	if ( !isVersionAvailable ) {
-		throw new Error( `The "${ randomPackageName }@${ version }" already exists in the npm registry.` );
-	}
+	checkIfVersionIsValid( version );
 
 	for ( const pkgJsonPath of pkgJsonPaths ) {
 		const pkgJson = await fs.readJson( pkgJsonPath );
@@ -66,78 +59,11 @@ export default async function updateVersions( options ) {
 }
 
 /**
- * @param {string} cwd
- * @param {Array.<string>} globPatterns
- * @param {UpdateVersionsPackagesDirectoryFilter|null} packagesDirectoryFilter
- * @returns {Promise.<Array.<string>>}
- */
-async function getPackageJsonPaths( cwd, globPatterns, packagesDirectoryFilter ) {
-	const pkgJsonPaths = await glob( globPatterns, {
-		cwd,
-		absolute: true,
-		nodir: true
-	} );
-
-	if ( !packagesDirectoryFilter ) {
-		return pkgJsonPaths;
-	}
-
-	return pkgJsonPaths.filter( packagesDirectoryFilter );
-}
-
-/**
- * @param {string} packagesDirectory
- * @returns {Promise.<object>}
+ * @param {string} version
  */
-function readPackageJson( packagesDirectory ) {
-	const packageJsonPath = join( packagesDirectory, 'package.json' );
-
-	return fs.readJson( packageJsonPath );
-}
-
-/**
- * @param {string|null} packagesDirectory
- * @returns {Array.<string>}
- */
-function getGlobPatterns( packagesDirectory ) {
-	const patterns = [ 'package.json' ];
-
-	if ( packagesDirectory ) {
-		patterns.push( packagesDirectory + '/*/package.json' );
-	}
-
-	return patterns;
-}
-
-/**
- * @param {Array.<string>} pkgJsonPaths
- * @param {string|null} packagesDirectory
- * @returns {object}
- */
-function getRandomPackagePath( pkgJsonPaths, packagesDirectory ) {
-	const randomPkgJsonPaths = packagesDirectory ?
-		pkgJsonPaths.filter( packagePath => packagePath.includes( packagesDirectory ) ) :
-		pkgJsonPaths;
-	const randomPkgJsonPath = randomPkgJsonPaths[ Math.floor( Math.random() * randomPkgJsonPaths.length ) ];
-
-	return dirname( randomPkgJsonPath );
-}
-
-/**
- * Checks if the specified version is greater than the current one.
- *
- * A nightly version is always considered as valid.
- *
- * @param {string} newVersion
- * @param {string} currentVersion
- */
-function checkIfVersionIsValid( newVersion, currentVersion ) {
-	if ( newVersion.startsWith( '0.0.0-nightly' ) ) {
-		return;
-	}
-
-	if ( !semver.gt( newVersion, currentVersion ) ) {
-		throw new Error( `Provided version ${ newVersion } must be greater than ${ currentVersion } or match pattern 0.0.0-nightly.` );
+function checkIfVersionIsValid( version ) {
+	if ( !semver.valid( version ) ) {
+		throw new Error( `Provided version ${ version } must follow the "Semantic Versioning" standard.` );
 	}
 }
 

package/lib/tasks/verifypackagespublishedcorrectly.js

@@ -19,6 +19,16 @@ import checkVersionAvailability from '../utils/checkversionavailability.js';
  * @returns {Promise}
  */
 export default async function verifyPackagesPublishedCorrectly( options ) {
+	process.emitWarning(
+		'The `verifyPackagesPublishedCorrectly()` function is deprecated and will be removed in the upcoming release (v45). ' +
+		'Its responsibility has been merged with `publishPackages()`.',
+		{
+			type: 'DeprecationWarning',
+			code: 'DEP0001',
+			detail: 'https://github.com/ckeditor/ckeditor5-dev/blob/master/DEPRECATIONS.md#dep0001-verifypackagespublishedcorrectly'
+		}
+	);
+
 	const { packagesDirectory, version, onSuccess } = options;
 	const packagesToVerify = await glob( upath.join( packagesDirectory, '*' ), { absolute: true } );
 	const errors = [];
@@ -32,16 +42,12 @@ export default async function verifyPackagesPublishedCorrectly( options ) {
 	for ( const packageToVerify of packagesToVerify ) {
 		const packageJson = await fs.readJson( upath.join( packageToVerify, 'package.json' ) );
 
-		try {
-			const packageWasUploadedCorrectly = !await checkVersionAvailability( version, packageJson.name );
+		const isPackageVersionAvailable = await checkVersionAvailability( version, packageJson.name );
 
-			if ( packageWasUploadedCorrectly ) {
-				await fs.remove( packageToVerify );
-			} else {
-				errors.push( packageJson.name );
-			}
-		} catch {
+		if ( isPackageVersionAvailable ) {
 			errors.push( packageJson.name );
+		} else {
+			await fs.remove( packageToVerify );
 		}
 	}
 

package/lib/utils/assertnpmtag.js

@@ -5,7 +5,12 @@
 
 import fs from 'fs-extra';
 import upath from 'upath';
-import semver from 'semver';
+import getNpmTagFromVersion from './getnpmtagfromversion.js';
+
+const ALLOWED_NPM_LATEST_TAGS = [
+	'staging',
+	'next'
+];
 
 /**
  * Checks if the npm tag matches the tag calculated from the package version. Verification takes place for all packages.
@@ -20,13 +25,13 @@ export default async function assertNpmTag( packagePaths, npmTag ) {
 	for ( const packagePath of packagePaths ) {
 		const packageJsonPath = upath.join( packagePath, 'package.json' );
 		const packageJson = await fs.readJson( packageJsonPath );
-		const versionTag = getVersionTag( packageJson.version );
+		const versionTag = getNpmTagFromVersion( packageJson.version );
 
 		if ( versionTag === npmTag ) {
 			continue;
 		}
 
-		if ( versionTag === 'latest' && npmTag === 'staging' ) {
+		if ( versionTag === 'latest' && ALLOWED_NPM_LATEST_TAGS.includes( npmTag ) ) {
 			continue;
 		}
 
@@ -37,22 +42,3 @@ export default async function assertNpmTag( packagePaths, npmTag ) {
 		throw new Error( errors.join( '\n' ) );
 	}
 }
-
-/**
- * Returns the version tag for the package.
- *
- * For the official release, returns the "latest" tag. For a non-official release (pre-release), returns the version tag extracted from
- * the package version.
- *
- * @param {string} version
- * @returns {string}
- */
-function getVersionTag( version ) {
-	const [ versionTag ] = semver.prerelease( version ) || [ 'latest' ];
-
-	if ( versionTag.startsWith( 'nightly' ) ) {
-		return 'nightly';
-	}
-
-	return versionTag;
-}

package/lib/utils/checkversionavailability.js

@@ -3,41 +3,25 @@
  * For licensing, see LICENSE.md.
  */
 
-import { tools } from '@ckeditor/ckeditor5-dev-utils';
-import shellEscape from 'shell-escape';
+import pacote from 'pacote';
 
 /**
  * Checks if the provided version for the package exists in the npm registry.
  *
  * Returns a promise that resolves to `true` if the provided version does not exist or resolves the promise to `false` otherwise.
- * If the `npm show` command exits with an error, it is re-thrown.
  *
  * @param {string} version
  * @param {string} packageName
  * @returns {Promise}
  */
 export default async function checkVersionAvailability( version, packageName ) {
-	const command = `npm show ${ shellEscape( [ packageName ] ) }@${ shellEscape( [ version ] ) } version`;
-
-	return tools.shExec( command, { verbosity: 'silent', async: true } )
-		.then( result => {
-			// Explicit check for npm < 8.13.0, which does not return anything (an empty result) and it exits with a zero status code when
-			// the version for the provided package does not exist in the npm registry.
-			if ( !result ) {
-				return true;
-			}
-
-			// Provided version exists in the npm registry.
+	return pacote.manifest( `${ packageName }@${ version }` )
+		.then( () => {
+			// If `pacote.manifest` resolves, a package with the given version exists.
 			return false;
 		} )
-		.catch( error => {
-			// All errors except the "E404" are re-thrown.
-			if ( !error.toString().includes( 'code E404' ) ) {
-				throw error;
-			}
-
-			// Npm >= 8.13.0 throws an "E404" error if a version does not exist.
-			// Npm < 8.13.0 should never reach this line.
+		.catch( () => {
+			// When throws, the package does not exist.
 			return true;
 		} );
 }

package/lib/utils/executeinparallel.js

@@ -10,8 +10,8 @@ import upath from 'upath';
 import os from 'os';
 import fs from 'fs/promises';
 import { Worker } from 'worker_threads';
-import { glob } from 'glob';
 import { registerAbortController, deregisterAbortController } from './abortcontroller.js';
+import findPathsToPackages from './findpathstopackages.js';
 
 const WORKER_SCRIPT = new URL( './parallelworker.js', import.meta.url );
 
@@ -49,15 +49,9 @@ export default async function executeInParallel( options ) {
 	} = options;
 
 	const concurrencyAsInteger = Math.floor( concurrency ) || 1;
-	const normalizedCwd = upath.toUnix( cwd );
-	const packages = ( await glob( `${ packagesDirectory }/*/`, {
-		cwd: normalizedCwd,
-		absolute: true
-	} ) ).map( upath.normalize );
-
-	const packagesToProcess = packagesDirectoryFilter ?
-		packages.filter( packagesDirectoryFilter ) :
-		packages;
+	const packagesToProcess = await findPathsToPackages( cwd, packagesDirectory, {
+		packagesDirectoryFilter
+	} );
 
 	const packagesInThreads = getPackagesGroupedByThreads( packagesToProcess, concurrencyAsInteger );
 

package/lib/utils/findpathstopackages.js

@@ -0,0 +1,78 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+import upath from 'upath';
+import { glob } from 'glob';
+
+/**
+ * Returns an array containing paths to packages found in the `packagesDirectory` directory.
+ *
+ * @param {string} cwd
+ * @param {string|null} packagesDirectory
+ * @param {object} [options={}]
+ * @param {boolean} [options.includePackageJson=false]
+ * @param {boolean} [options.includeCwd=false]
+ * @param {PackagesDirectoryFilter|null} [options.packagesDirectoryFilter=null]
+ * @returns {Array.<string>}
+ */
+export default async function findPathsToPackages( cwd, packagesDirectory, options = {} ) {
+	const {
+		includePackageJson = false,
+		includeCwd = false,
+		packagesDirectoryFilter = null
+	} = options;
+
+	const packagePaths = await getPackages( cwd, packagesDirectory, includePackageJson );
+
+	if ( includeCwd ) {
+		if ( includePackageJson ) {
+			packagePaths.push( upath.join( cwd, 'package.json' ) );
+		} else {
+			packagePaths.push( cwd );
+		}
+	}
+
+	const normalizedPaths = packagePaths.map( item => upath.normalize( item ) );
+
+	if ( packagesDirectoryFilter ) {
+		return normalizedPaths.filter( item => packagesDirectoryFilter( item ) );
+	}
+
+	return normalizedPaths;
+}
+
+/**
+ * @param {string} cwd
+ * @param {string|null} packagesDirectory
+ * @param {boolean} includePackageJson
+ * @returns {Promise.<Array.<string>>}
+ */
+function getPackages( cwd, packagesDirectory, includePackageJson ) {
+	if ( !packagesDirectory ) {
+		return [];
+	}
+
+	const globOptions = {
+		cwd: upath.join( cwd, packagesDirectory ),
+		absolute: true
+	};
+
+	let pattern = '*/';
+
+	if ( includePackageJson ) {
+		pattern += 'package.json';
+		globOptions.nodir = true;
+	}
+
+	return glob( pattern, globOptions );
+}
+
+/**
+ * @callback PackagesDirectoryFilter
+ *
+ * @param {string} packageJsonPath An absolute path to a `package.json` file.
+ *
+ * @returns {boolean} Whether to include (`true`) or skip (`false`) processing the given directory/package.
+ */

package/lib/utils/getnpmtagfromversion.js

@@ -6,11 +6,20 @@
 import semver from 'semver';
 
 /**
+ * Returns a version tag from specified `version`.
+ *
+ * For the official release, returns the "latest" tag. For a non-official release (pre-release),
+ * returns the version tag extracted from the passed version.
+ *
  * @param {string} version
  * @returns {string}
  */
 export default function getNpmTagFromVersion( version ) {
 	const [ versionTag ] = semver.prerelease( version ) || [ 'latest' ];
 
+	if ( versionTag.startsWith( 'nightly' ) ) {
+		return 'nightly';
+	}
+
 	return versionTag;
 }

package/lib/utils/isversionpublishablefortag.js

@@ -3,9 +3,8 @@
  * For licensing, see LICENSE.md.
  */
 
-import { tools } from '@ckeditor/ckeditor5-dev-utils';
 import semver from 'semver';
-import shellEscape from 'shell-escape';
+import pacote from 'pacote';
 
 /**
  * This util aims to verify if the given `packageName` can be published with the given `version` on the `npmTag`.
@@ -16,10 +15,9 @@ import shellEscape from 'shell-escape';
  * @returns {Promise.<boolean>}
  */
 export default async function isVersionPublishableForTag( packageName, version, npmTag ) {
-	const command = `npm view ${ shellEscape( [ packageName ] ) }@${ shellEscape( [ npmTag ] ) } version --silent`;
-	const npmVersion = await tools.shExec( command, { async: true, verbosity: 'silent' } )
-		.then( value => value.trim() )
-		// An `npmTag` does not exist.
+	const npmVersion = await pacote.manifest( `${ packageName }@${ npmTag }` )
+		.then( ( { version } ) => version )
+		// An `npmTag` does not exist, or it's a first release of a package.
 		.catch( () => null );
 
 	if ( npmVersion && semver.lte( version, npmVersion ) ) {

package/lib/utils/providenewversionformonorepository.js

@@ -7,23 +7,29 @@ import inquirer from 'inquirer';
 import semver from 'semver';
 import chalk from 'chalk';
 import { CLI_INDENT_SIZE } from './constants.js';
+import checkVersionAvailability from './checkversionavailability.js';
 
 /**
  * Asks a user for providing the new version for a major release.
  *
- * @param {string} version
- * @param {string} foundPackage
- * @param {string} bumpType
- * @param {object} [options={}]
+ * @param {object} options
+ * @param {string} options.packageName
+ * @param {string} options.version
+ * @param {string} options.bumpType
  * @param {number} [options.indentLevel=0] The indent level.
  * @returns {Promise.<string>}
  */
-export default async function provideNewVersionForMonoRepository( version, foundPackage, bumpType, options = {} ) {
-	const indentLevel = options.indentLevel || 0;
-	const suggestedVersion = semver.inc( version, bumpType );
+export default async function provideNewVersionForMonoRepository( options ) {
+	const {
+		version,
+		packageName,
+		bumpType,
+		indentLevel = 0
+	} = options;
 
+	const suggestedVersion = semver.inc( version, bumpType );
 	const message = 'Type the new version ' +
-		`(current highest: "${ version }" found in "${ chalk.underline( foundPackage ) }", suggested: "${ suggestedVersion }"):`;
+		`(current highest: "${ version }" found in "${ chalk.underline( packageName ) }", suggested: "${ suggestedVersion }"):`;
 
 	const versionQuestion = {
 		type: 'input',
@@ -35,12 +41,22 @@ export default async function provideNewVersionForMonoRepository( version, found
 			return input.trim();
 		},
 
-		validate( input ) {
+		async validate( input ) {
 			if ( !semver.valid( input ) ) {
 				return 'Please provide a valid version.';
 			}
 
-			return semver.gt( input, version ) ? true : `Provided version must be higher than "${ version }".`;
+			if ( !semver.gt( input, version ) ) {
+				return `Provided version must be higher than "${ version }".`;
+			}
+
+			const isAvailable = await checkVersionAvailability( input, packageName );
+
+			if ( !isAvailable ) {
+				return 'Given version is already taken.';
+			}
+
+			return true;
 		},
 		prefix: ' '.repeat( indentLevel * CLI_INDENT_SIZE ) + chalk.cyan( '?' )
 	};

package/lib/utils/provideversion.js

@@ -7,22 +7,30 @@ import inquirer from 'inquirer';
 import semver from 'semver';
 import chalk from 'chalk';
 import { CLI_INDENT_SIZE } from './constants.js';
+import checkVersionAvailability from './checkversionavailability.js';
 
 /**
  * Asks a user for providing the new version.
  *
- * @param {string} packageVersion
- * @param {string|null} releaseTypeOrNewVersion
- * @param {object} [options]
+ * @param {object} options
+ * @param {string} options.packageName
+ * @param {string} options.version
+ * @param {string|null} options.releaseTypeOrNewVersion
  * @param {boolean} [options.disableInternalVersion=false] Whether to "internal" version is enabled.
  * @param {boolean} [options.disableSkipVersion=false] Whether to "skip" version is enabled.
  * @param {number} [options.indentLevel=0] The indent level.
  * @returns {Promise.<string>}
  */
-export default function provideVersion( packageVersion, releaseTypeOrNewVersion, options = {} ) {
-	const indentLevel = options.indentLevel || 0;
+export default function provideVersion( options ) {
+	const {
+		packageName,
+		version,
+		releaseTypeOrNewVersion,
+		indentLevel = 0
+	} = options;
+
 	const suggestedVersion = getSuggestedVersion( {
-		packageVersion,
+		version,
 		releaseTypeOrNewVersion,
 		disableInternalVersion: options.disableInternalVersion
 	} );
@@ -33,7 +41,7 @@ export default function provideVersion( packageVersion, releaseTypeOrNewVersion,
 		message = 'Type the new version or "skip"';
 	}
 
-	message += ` (suggested: "${ suggestedVersion }", current: "${ packageVersion }"):`;
+	message += ` (suggested: "${ suggestedVersion }", current: "${ version }"):`;
 
 	const versionQuestion = {
 		type: 'input',
@@ -45,7 +53,7 @@ export default function provideVersion( packageVersion, releaseTypeOrNewVersion,
 			return input.trim();
 		},
 
-		validate( input ) {
+		async validate( input ) {
 			if ( !options.disableSkipVersion && input === 'skip' ) {
 				return true;
 			}
@@ -54,8 +62,17 @@ export default function provideVersion( packageVersion, releaseTypeOrNewVersion,
 				return true;
 			}
 
-			// TODO: Check whether provided version is available.
-			return semver.valid( input ) ? true : 'Please provide a valid version.';
+			if ( !semver.valid( input ) ) {
+				return 'Please provide a valid version.';
+			}
+
+			const isAvailable = await checkVersionAvailability( input, packageName );
+
+			if ( !isAvailable ) {
+				return 'Given version is already taken.';
+			}
+
+			return true;
 		},
 
 		prefix: ' '.repeat( indentLevel * CLI_INDENT_SIZE ) + chalk.cyan( '?' )
@@ -67,12 +84,12 @@ export default function provideVersion( packageVersion, releaseTypeOrNewVersion,
 
 /**
  * @param {object} options
- * @param {string} options.packageVersion
+ * @param {string} options.version
  * @param {string|null} options.releaseTypeOrNewVersion
  * @param {boolean} options.disableInternalVersion
  * @returns {string}
  */
-function getSuggestedVersion( { packageVersion, releaseTypeOrNewVersion, disableInternalVersion } ) {
+function getSuggestedVersion( { version, releaseTypeOrNewVersion, disableInternalVersion } ) {
 	if ( !releaseTypeOrNewVersion || releaseTypeOrNewVersion === 'skip' ) {
 		return 'skip';
 	}
@@ -85,14 +102,14 @@ function getSuggestedVersion( { packageVersion, releaseTypeOrNewVersion, disable
 		return disableInternalVersion ? 'skip' : 'internal';
 	}
 
-	if ( semver.prerelease( packageVersion ) ) {
+	if ( semver.prerelease( version ) ) {
 		releaseTypeOrNewVersion = 'prerelease';
 	}
 
 	// If package's version is below the '1.0.0', bump the 'minor' instead of 'major'
-	if ( releaseTypeOrNewVersion === 'major' && semver.gt( '1.0.0', packageVersion ) ) {
-		return semver.inc( packageVersion, 'minor' );
+	if ( releaseTypeOrNewVersion === 'major' && semver.gt( '1.0.0', version ) ) {
+		return semver.inc( version, 'minor' );
 	}
 
-	return semver.inc( packageVersion, releaseTypeOrNewVersion );
+	return semver.inc( version, releaseTypeOrNewVersion );
 }

package/lib/utils/publishpackageonnpmcallback.js

@@ -14,26 +14,16 @@
 export default async function publishPackageOnNpmCallback( packagePath, taskOptions ) {
 	const { tools } = await import( '@ckeditor/ckeditor5-dev-utils' );
 	const { default: fs } = await import( 'fs-extra' );
-	const { default: path } = await import( 'upath' );
 
-	const options = {
-		cwd: packagePath,
-		async: true,
-		verbosity: 'error'
-	};
-
-	const result = await tools.shExec( `npm publish --access=public --tag ${ taskOptions.npmTag }`, options )
-		.catch( e => {
-			const packageName = path.basename( packagePath );
-
-			if ( e.toString().includes( 'code E409' ) ) {
-				return { shouldKeepDirectory: true };
-			}
-
-			throw new Error( `Unable to publish "${ packageName }" package.` );
+	try {
+		await tools.shExec( `npm publish --access=public --tag ${ taskOptions.npmTag }`, {
+			cwd: packagePath,
+			async: true,
+			verbosity: 'error'
 		} );
 
-	if ( !result || !result.shouldKeepDirectory ) {
 		await fs.remove( packagePath );
+	} catch {
+		// Do nothing if an error occurs. A parent task will handle it.
 	}
 }

package/lib/utils/versions.js

@@ -4,6 +4,7 @@
  */
 
 import { tools } from '@ckeditor/ckeditor5-dev-utils';
+import pacote from 'pacote';
 import getChangelog from './getchangelog.js';
 import getPackageJson from './getpackagejson.js';
 
@@ -37,9 +38,9 @@ export function getLastFromChangelog( cwd = process.cwd() ) {
 export function getLastPreRelease( releaseIdentifier, cwd = process.cwd() ) {
 	const packageName = getPackageJson( cwd ).name;
 
-	return tools.shExec( `npm view ${ packageName } versions --json`, { verbosity: 'silent', async: true } )
+	return pacote.packument( packageName )
 		.then( result => {
-			const lastVersion = JSON.parse( result )
+			const lastVersion = Object.keys( result.versions )
 				.filter( version => version.startsWith( releaseIdentifier ) )
 				.sort( ( a, b ) => a.localeCompare( b, undefined, { numeric: true } ) )
 				.pop();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ckeditor/ckeditor5-dev-release-tools",
-  "version": "44.0.0",
+  "version": "44.1.0",
   "description": "Tools used for releasing CKEditor 5 and related packages.",
   "keywords": [],
   "author": "CKSource (http://cksource.com/)",
@@ -22,7 +22,7 @@
     "lib"
   ],
   "dependencies": {
-    "@ckeditor/ckeditor5-dev-utils": "^44.0.0",
+    "@ckeditor/ckeditor5-dev-utils": "^44.1.0",
     "@octokit/rest": "^21.0.0",
     "chalk": "^5.0.0",
     "cli-columns": "^4.0.0",
@@ -38,6 +38,7 @@
     "inquirer": "^11.0.0",
     "lodash-es": "^4.17.21",
     "minimatch": "^9.0.0",
+    "pacote": "^19.0.0",
     "semver": "^7.6.3",
     "shell-escape": "^0.2.0",
     "upath": "^2.0.1"