@ckeditor/ckeditor5-dev-ci 54.3.3 → 54.3.4

package/README.md

@@ -55,6 +55,11 @@ These commands accept a mix of environment variables and command line arguments.
   - `--task` — Command to execute at the end; default: `pnpm ckeditor5-dev-ci-notify-circle-status`.
   - `--ignore` — Job name to ignore when waiting (repeatable; can be passed multiple times).
 
+  **Behavior:**
+  - Retries transient CircleCI API errors up to **5 attempts** with a **10s delay** between attempts.
+  - Fails immediately for non-retryable API errors (for example: invalid token or wrong workflow ID).
+  - If transient errors persist, it exits with an explicit message asking to verify workflow results manually.
+
 - ⚙️ **`ckeditor5-dev-ci-is-job-triggered-by-member`**
 
   Verifies that a **CircleCI approval job** was approved by a user who belongs to a specified GitHub team.

package/bin/circle-workflow-notifier.js

@@ -9,6 +9,7 @@ import { parseArgs } from 'node:util';
 import { execSync } from 'node:child_process';
 import processJobStatuses from '../lib/process-job-statuses.js';
 import isWorkflowFinished from '../lib/utils/is-workflow-finished.js';
+import getOtherWorkflowJobs from '../lib/utils/get-other-workflow-jobs.js';
 
 // This script allows the creation of a new job within a workflow that will be executed
 // in the end, when all other jobs will be finished or errored.
@@ -81,6 +82,9 @@ const { values: { task, ignore } } = parseArgs( {
 	}
 } );
 
+const CIRCLE_API_MAX_ATTEMPTS = 5;
+const CIRCLE_API_RETRY_DELAY_MS = 10 * 1000;
+
 waitForOtherJobsAndSendNotification()
 	.catch( err => {
 		console.error( err );
@@ -89,7 +93,17 @@ waitForOtherJobsAndSendNotification()
 	} );
 
 async function waitForOtherJobsAndSendNotification() {
-	const jobs = processJobStatuses( await getOtherJobsData() )
+	assertRequiredEnvironmentVariables();
+
+	const allJobs = await getOtherWorkflowJobs( {
+		circleToken: CKE5_CIRCLE_TOKEN,
+		workflowId: CIRCLE_WORKFLOW_ID,
+		currentJobName: CIRCLE_JOB,
+		maxAttempts: CIRCLE_API_MAX_ATTEMPTS,
+		retryDelayMs: CIRCLE_API_RETRY_DELAY_MS
+	} );
+
+	const jobs = processJobStatuses( allJobs )
 		.filter( job => !ignore.includes( job.name ) );
 
 	if ( !isWorkflowFinished( jobs ) ) {
@@ -108,20 +122,16 @@ async function waitForOtherJobsAndSendNotification() {
 	console.log( 'All jobs were successful.' );
 }
 
-/**
- * Fetches and returns data of all jobs except the one where this script runs.
- */
-async function getOtherJobsData() {
-	const url = `https://circleci.com/api/v2/workflow/${ CIRCLE_WORKFLOW_ID }/job`;
-	const options = {
-		method: 'GET',
-		headers: {
-			'Circle-Token': CKE5_CIRCLE_TOKEN
-		}
-	};
+function assertRequiredEnvironmentVariables() {
+	if ( !CKE5_CIRCLE_TOKEN ) {
+		throw new Error( 'Missing environment variable: CKE5_CIRCLE_TOKEN' );
+	}
 
-	const response = await fetch( url, options );
-	const data = await response.json();
+	if ( !CIRCLE_WORKFLOW_ID ) {
+		throw new Error( 'Missing environment variable: CIRCLE_WORKFLOW_ID' );
+	}
 
-	return data.items.filter( job => job.name !== CIRCLE_JOB );
+	if ( !CIRCLE_JOB ) {
+		throw new Error( 'Missing environment variable: CIRCLE_JOB' );
+	}
 }

package/lib/utils/get-other-workflow-jobs.js

@@ -0,0 +1,163 @@
+/**
+ * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+const RETRYABLE_STATUSES = new Set( [ 429, 500, 502, 503, 504 ] );
+
+/**
+ * Fetches and returns all jobs from a workflow except the currently running job.
+ *
+ * Retries transient API errors up to `maxAttempts` times.
+ *
+ * @param {object} options
+ * @param {string} options.circleToken
+ * @param {string} options.workflowId
+ * @param {string} options.currentJobName
+ * @param {number} [options.maxAttempts=5]
+ * @param {number} [options.retryDelayMs=10000]
+ * @returns {Promise<Array.<object>>}
+ */
+export default async function getOtherWorkflowJobs( options ) {
+	const {
+		circleToken,
+		workflowId,
+		currentJobName,
+		maxAttempts = 5,
+		retryDelayMs = 10 * 1000
+	} = options;
+
+	if ( !Number.isInteger( maxAttempts ) || maxAttempts < 1 ) {
+		throw new Error( `Invalid option: "maxAttempts" must be a positive integer (received: ${ maxAttempts }).` );
+	}
+
+	if ( retryDelayMs < 0 ) {
+		throw new Error( `Invalid option: "retryDelayMs" must be greater than or equal to 0 (received: ${ retryDelayMs }).` );
+	}
+
+	const requestUrl = `https://circleci.com/api/v2/workflow/${ workflowId }/job`;
+	const requestOptions = {
+		method: 'GET',
+		headers: {
+			'Circle-Token': circleToken
+		}
+	};
+
+	for ( let attempt = 1; attempt <= maxAttempts; attempt++ ) {
+		try {
+			const response = await fetch( requestUrl, requestOptions )
+				.catch( error => {
+					throw createTransientError( `CircleCI API request failed due to a network error: ${ error.message }`, error );
+				} );
+
+			if ( !response.ok ) {
+				const responseData = await parseResponseDataSafely( response );
+				const details = getResponseMessage( responseData );
+				const statusMessage = details ? `${ response.status }: ${ details }` : String( response.status );
+
+				if ( RETRYABLE_STATUSES.has( response.status ) ) {
+					throw createTransientError( `CircleCI API request failed with a retryable status (${ statusMessage }).` );
+				}
+
+				throw new Error(
+					`CircleCI API request failed with a non-retryable status (${ statusMessage }). ` +
+					'Verify CircleCI token and workflow configuration.'
+				);
+			}
+
+			const responseData = await parseResponseData( response );
+
+			if ( !responseData || !Array.isArray( responseData.items ) ) {
+				throw createTransientError( 'CircleCI API response does not contain the "items" array.' );
+			}
+
+			return responseData.items.filter( job => job.name !== currentJobName );
+		} catch ( error ) {
+			if ( !isTransientError( error ) ) {
+				throw error;
+			}
+
+			if ( attempt === maxAttempts ) {
+				throw new Error(
+					`CircleCI API seems unstable. Failed to fetch workflow jobs after ${ maxAttempts } attempts. ` +
+					`Last error: ${ error.message } Please verify workflow results manually.`
+				);
+			}
+
+			console.warn(
+				`CircleCI API request failed (attempt ${ attempt }/${ maxAttempts }): ${ error.message } ` +
+				`Retrying in ${ retryDelayMs }ms...`
+			);
+
+			await wait( retryDelayMs );
+		}
+	}
+}
+
+/**
+ * @param {Response} response
+ * @returns {Promise<object>}
+ */
+async function parseResponseData( response ) {
+	try {
+		return await response.json();
+	} catch ( error ) {
+		throw createTransientError( 'CircleCI API returned an invalid JSON response.', error );
+	}
+}
+
+/**
+ * @param {Response} response
+ * @returns {Promise<object|null>}
+ */
+async function parseResponseDataSafely( response ) {
+	try {
+		return await response.json();
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * @param {object} responseData
+ * @returns {string|null}
+ */
+function getResponseMessage( responseData ) {
+	if ( responseData && typeof responseData.message === 'string' ) {
+		return responseData.message;
+	}
+
+	if ( responseData && typeof responseData.error === 'string' ) {
+		return responseData.error;
+	}
+
+	return null;
+}
+
+/**
+ * @param {number} delay
+ * @returns {Promise<void>}
+ */
+function wait( delay ) {
+	return new Promise( resolve => setTimeout( resolve, delay ) );
+}
+
+/**
+ * @param {string} message
+ * @param {Error} [cause]
+ * @returns {Error & {code: 'CIRCLE_API_TRANSIENT'}}
+ */
+function createTransientError( message, cause ) {
+	const error = new Error( message, { cause } );
+	error.code = 'CIRCLE_API_TRANSIENT';
+
+	return error;
+}
+
+/**
+ * @param {unknown} error
+ * @returns {error is Error & {code: 'CIRCLE_API_TRANSIENT'}}
+ */
+function isTransientError( error ) {
+	return error instanceof Error && error.code === 'CIRCLE_API_TRANSIENT';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ckeditor/ckeditor5-dev-ci",
-  "version": "54.3.3",
+  "version": "54.3.4",
   "description": "Utils used on various Continuous Integration services.",
   "keywords": [],
   "author": "CKSource (http://cksource.com/)",