@eclipse-glsp/cli 1.1.0-next.e31f2e5.119 → 2.0.0

package/package.json

@@ -1,21 +1,21 @@
 {
   "name": "@eclipse-glsp/cli",
-  "version": "1.1.0-next.e31f2e5.119+e31f2e5",
+  "version": "2.0.0",
   "description": "CLI Tooling & scripts for GLSP components",
-  "license": "(EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0)",
   "keywords": [
     "eclipse",
     "tsconfig"
   ],
-  "author": {
-    "name": "Eclipse GLSP"
-  },
   "homepage": "https://www.eclipse.org/glsp/",
+  "bugs": "https://github.com/eclipse-glsp/glsp/issues",
   "repository": {
     "type": "git",
     "url": "https://github.com/eclipse-glsp/glsp.git"
   },
-  "bugs": "https://github.com/eclipse-glsp/glsp/issues",
+  "license": "(EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0)",
+  "author": {
+    "name": "Eclipse GLSP"
+  },
   "contributors": [
     {
       "name": "Eclipse GLSP Project",
@@ -23,6 +23,14 @@
       "url": "https://projects.eclipse.org/projects/ecd.glsp"
     }
   ],
+  "bin": {
+    "glsp": "bin/glsp"
+  },
+  "files": [
+    "src",
+    "bin",
+    "lib"
+  ],
   "scripts": {
     "build": "tsc -b",
     "clean": "rimraf lib tsconfig.tsbuildinfo",
@@ -32,31 +40,24 @@
     "start": "node --enable-source-maps lib/app.js",
     "watch": "tsc -w"
   },
-  "publishConfig": {
-    "access": "public"
-  },
   "dependencies": {
-    "commander": "^9.4.0",
-    "node-fetch": "2.6.7",
+    "commander": "^10.0.1",
+    "glob": "^10.3.10",
+    "node-fetch": "^2.6.11",
     "readline-sync": "^1.4.10",
-    "semver": "^7.3.7",
-    "shelljs": "0.8.5"
+    "semver": "^7.5.1",
+    "shelljs": "^0.8.5"
   },
   "devDependencies": {
-    "@eclipse-glsp/config": "1.1.0-next.e31f2e5.119+e31f2e5",
-    "@types/node-fetch": "2.6.2",
-    "@types/readline-sync": "1.4.4",
-    "@types/semver": "7.3.12",
-    "@types/shelljs": "0.8.11",
-    "ts-node": "^10.9.1"
+    "@eclipse-glsp/config": "~2.0.0",
+    "@types/glob": "^8.1.0",
+    "@types/node-fetch": "^2.6.6",
+    "@types/readline-sync": "^1.4.5",
+    "@types/semver": "^7.5.3",
+    "@types/shelljs": "^0.8.13"
   },
-  "bin": {
-    "glsp": "bin/glsp"
+  "publishConfig": {
+    "access": "public"
   },
-  "files": [
-    "src",
-    "bin",
-    "lib"
-  ],
-  "gitHead": "e31f2e57b5be8c784247c469669ed2a20ec548ee"
+  "gitHead": "de11704de0f39591d2a991c3956df4e0ce88d451"
 }

package/src/app.ts

@@ -14,15 +14,18 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { CheckHeaderCommand } from './commands/check-header';
 import { CoverageReportCommand } from './commands/coverage-report';
 import { ReleaseCommand } from './commands/release/release';
 import { baseCommand } from './util/command-util';
+
 export const COMMAND_VERSION = '1.1.0-next';
 
 const app = baseCommand() //
     .version(COMMAND_VERSION)
     .name('glsp')
+    .addCommand(CoverageReportCommand)
     .addCommand(ReleaseCommand)
-    .addCommand(CoverageReportCommand);
+    .addCommand(CheckHeaderCommand);
 
 app.parse(process.argv);

package/src/commands/check-header.ts

@@ -0,0 +1,355 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+/* eslint-disable max-len */
+import { Option } from 'commander';
+import * as fs from 'fs';
+import { glob } from 'glob';
+import * as minimatch from 'minimatch';
+import * as readline from 'readline-sync';
+import * as sh from 'shelljs';
+import { baseCommand, configureShell, getShellConfig } from '../util/command-util';
+import {
+    getChangesOfLastCommit,
+    getFirstCommit,
+    getFirstModificationDate,
+    getInitialCommit,
+    getLastModificationDate,
+    getUncommittedChanges
+} from '../util/git-util';
+
+import { LOGGER } from '../util/logger';
+import { validateGitDirectory } from '../util/validation-util';
+import path = require('path');
+export interface HeaderCheckOptions {
+    type: CheckType;
+    exclude: string[];
+    fileExtensions: string[];
+    json: boolean;
+    excludeDefaults: boolean;
+    autoFix: boolean;
+    severity: Severity;
+}
+
+const checkTypes = ['full', 'changes', 'lastCommit'] as const;
+type CheckType = typeof checkTypes[number];
+
+const severityTypes = ['error', 'warn', 'ok'] as const;
+
+type Severity = typeof severityTypes[number];
+
+const DEFAULT_EXCLUDES = ['**/@(node_modules|lib|dist|bundle)/**'];
+const YEAR_RANGE_REGEX = /\d{4}(?:-d{4})?/g;
+const HEADER_PATTERN = 'Copyright \\([cC]\\) \\d{4}(-d{4})?';
+const AUTO_FIX_MESSAGE = 'Fix copyright header violations';
+
+export const CheckHeaderCommand = baseCommand() //
+    .name('checkHeaders')
+    .description('Validates the copyright year range of license header files')
+    .argument('<rootDir>', 'The starting directory for the check', validateGitDirectory)
+    .addOption(
+        new Option(
+            '-t, --type <type>',
+            'The scope of the check. In addition to a full recursive check, is also possible to only' +
+                ' consider pending changes or the last commit'
+        )
+            .choices(checkTypes)
+            .default('full')
+    )
+    .option('-f, --fileExtensions <extensions...>', 'File extensions that should be checked', ['ts', 'tsx'])
+    .addOption(
+        new Option(
+            '-e, --exclude <exclude...>',
+            'File patterns that should be excluded from the check. New exclude patterns are added to the default patterns'
+        ).default([], `[${DEFAULT_EXCLUDES}]`)
+    )
+    .option(
+        '--no-exclude-defaults',
+        'Disables the default excludes patterns. Only explicitly passed exclude patterns (-e, --exclude) are considered'
+    )
+    .option('-j, --json', 'Also persist validation results as json file', false)
+    .addOption(
+        new Option('-s, --severity <severity>', 'The severity of validation results that should be printed.')
+            .choices(severityTypes)
+            .default('error', '"error" (only)')
+    )
+    .option('-a, --autoFix', 'Auto apply & commit fixes without prompting the user', false)
+    .action(checkHeaders);
+
+export function checkHeaders(rootDir: string, options: HeaderCheckOptions): void {
+    configureShell({ silent: true, fatal: true });
+
+    if (options.excludeDefaults) {
+        options.exclude.push(...DEFAULT_EXCLUDES);
+    }
+
+    sh.cd(rootDir);
+    const files = getFiles(rootDir, options);
+    LOGGER.info(`Check copy right headers of ${files.length} files`);
+    if (files.length === 0) {
+        LOGGER.info('Check completed');
+        return;
+    }
+    const results = validate(rootDir, files, options);
+    handleValidationResults(rootDir, results, options);
+}
+
+function getFiles(rootDir: string, options: HeaderCheckOptions): string[] {
+    const includePattern = `**/*.@(${options.fileExtensions.join('|')})`;
+    const excludePattern = options.exclude;
+
+    if (options.type === 'full') {
+        return glob.sync(includePattern, {
+            cwd: rootDir,
+            ignore: excludePattern
+        });
+    }
+
+    let changedFiles = options.type === 'changes' ? getUncommittedChanges(rootDir) : getChangesOfLastCommit(rootDir);
+    changedFiles = changedFiles.filter(minimatch.filter(includePattern));
+
+    excludePattern.forEach(pattern => {
+        changedFiles = changedFiles.filter(minimatch.filter(`!${pattern}`));
+    });
+    return changedFiles.filter(file => fs.existsSync(file));
+}
+
+function validate(rootDir: string, files: string[], options: HeaderCheckOptions): ValidationResult[] {
+    // Derives all files with valid headers, their copyright years and all files with no or invalid headers
+    const filesWithHeader = sh.grep('-l', HEADER_PATTERN, files).stdout.trim().split('\n');
+    const copyrightYears = sh
+        .grep(HEADER_PATTERN, files)
+        .stdout.trim()
+        .split('\n')
+        .map(line => line.match(YEAR_RANGE_REGEX)!.map(string => Number.parseInt(string, 10)));
+    const noHeaders = files.filter(file => !filesWithHeader.includes(file));
+
+    const results: ValidationResult[] = [];
+
+    const allFilesLength = files.length;
+
+    // Create validation results for all files with no or invalid headers
+    const noHeadersLength = noHeaders.length;
+    if (noHeadersLength > 0) {
+        LOGGER.info(`Found ${noHeadersLength} files with no (or an invalid) copyright header`);
+    }
+    noHeaders.forEach((file, i) => {
+        printFileProgress(i + 1, allFilesLength, `Validating ${file}`);
+        results.push({ file: path.resolve(rootDir, file), violation: 'noOrMissingHeader', severity: 'error' });
+    });
+
+    // Performance optimization: avoid retrieving the dates for each individual file by precalculating the endYear if possible.
+    let defaultEndYear: number | undefined;
+    if (options.type === 'changes') {
+        defaultEndYear = new Date().getFullYear();
+    } else if (options.type === 'lastCommit') {
+        defaultEndYear = getLastModificationDate(undefined, rootDir)?.getFullYear();
+    }
+
+    // Create validation results for all files with valid headers
+    filesWithHeader.forEach((file, i) => {
+        printFileProgress(i + 1 + noHeadersLength, allFilesLength, `Validating ${file}`);
+
+        const result: DateValidationResult = {
+            currentStartYear: copyrightYears[i].shift()!,
+            expectedStartYear: getFirstModificationDate(file, rootDir, AUTO_FIX_MESSAGE)!.getFullYear(),
+            currentEndYear: copyrightYears[i].shift(),
+            expectedEndYear: defaultEndYear ?? getLastModificationDate(file, rootDir, AUTO_FIX_MESSAGE)!.getFullYear(),
+            file,
+            severity: 'ok',
+            violation: 'none'
+        };
+
+        if (result.expectedStartYear === result.expectedEndYear) {
+            validateSingleYear(result);
+        } else {
+            validateTimePeriod(result);
+        }
+        results.push(result);
+    });
+
+    results.sort((a, b) => a.file.localeCompare(b.file));
+
+    process.stdout.clearLine(0);
+    return results;
+}
+
+function validateSingleYear(result: DateValidationResult): void {
+    const { currentStartYear, expectedStartYear, currentEndYear } = result;
+    result.violation = 'invalidCopyrightYear';
+    result.severity = 'error';
+
+    if (!currentEndYear) {
+        if (currentStartYear === expectedStartYear) {
+            result.violation = 'none';
+            result.severity = 'ok';
+        }
+        return;
+    }
+
+    // Cornercase: For files of the initial contribution the copyright header predates the first git modification date.
+    // => declare as warning if not part of the initial contribution.
+    if (expectedStartYear === currentEndYear && currentStartYear < expectedStartYear) {
+        if (getFirstCommit(result.file) === getInitialCommit()) {
+            result.violation = 'none';
+            result.severity = 'ok';
+        } else {
+            result.severity = 'warn';
+        }
+    }
+}
+
+function validateTimePeriod(result: DateValidationResult): void {
+    const { currentStartYear, expectedStartYear, expectedEndYear, currentEndYear } = result;
+
+    result.violation = 'incorrectCopyrightPeriod';
+    result.severity = 'error';
+    if (!currentEndYear) {
+        result.severity = 'error';
+        return;
+    }
+
+    if (currentStartYear === expectedStartYear && currentEndYear === expectedEndYear) {
+        result.violation = 'none';
+        result.severity = 'ok';
+        return;
+    }
+
+    // Cornercase: For files of the initial contribution the copyright header predates the first git modification date.
+    // => declare as warning if not part of the initial contribution.
+    if (currentEndYear === expectedEndYear && currentStartYear < expectedEndYear) {
+        if (getFirstCommit(result.file) === getInitialCommit()) {
+            result.violation = 'none';
+            result.severity = 'ok';
+        } else {
+            result.severity = 'warn';
+        }
+    }
+}
+
+function printFileProgress(currentFileCount: number, maxFileCount: number, message: string, clear = true): void {
+    if (clear) {
+        process.stdout.clearLine(0);
+        process.stdout.cursorTo(0);
+    }
+    process.stdout.write(`[${currentFileCount} of ${maxFileCount}] ${message}`);
+    if (!clear) {
+        process.stdout.write('\n');
+    }
+}
+
+export function handleValidationResults(rootDir: string, results: ValidationResult[], options: HeaderCheckOptions): void {
+    LOGGER.newLine();
+    LOGGER.info(`Header validation for ${results.length} files completed`);
+    const violations = results.filter(result => result.severity === 'error');
+    // Adjust results to print based on configured severity level
+    let toPrint = results;
+    if (options.severity === 'error') {
+        toPrint = violations;
+    } else if (options.severity === 'warn') {
+        toPrint = results.filter(result => result.severity !== 'ok');
+    }
+
+    LOGGER.info(`Found ${toPrint.length} copyright header violations:`);
+    LOGGER.newLine();
+
+    toPrint.forEach((result, i) => LOGGER.info(`${i + 1}. `, result.file, ':', toPrintMessage(result)));
+
+    LOGGER.newLine();
+
+    if (options.json) {
+        fs.writeFileSync(path.join(rootDir, 'headerCheck.json'), JSON.stringify(results, undefined, 2));
+    }
+
+    if (violations.length > 0 && (options.autoFix || readline.keyInYN('Do you want automatically fix copyright year range violations?'))) {
+        const toFix = violations.filter(
+            violation => violation.severity === 'error' && isDateValidationResult(violation)
+        ) as DateValidationResult[];
+        fixViolations(rootDir, toFix, options);
+    }
+
+    LOGGER.info('Check completed');
+}
+
+function toPrintMessage(result: ValidationResult): string {
+    const colors: Record<Severity, string> = {
+        error: '\x1b[31m',
+        warn: '\x1b[33m',
+        ok: '\x1b[32m'
+    } as const;
+
+    if (
+        isDateValidationResult(result) &&
+        (result.violation === 'incorrectCopyrightPeriod' || result.violation === 'invalidCopyrightYear')
+    ) {
+        const expected =
+            result.expectedStartYear !== result.expectedEndYear
+                ? `${result.expectedStartYear}-${result.expectedEndYear}`
+                : result.expectedStartYear.toString();
+        const actual = result.currentEndYear ? `${result.currentStartYear}-${result.currentEndYear}` : result.currentStartYear.toString();
+        const message = result.violation === 'incorrectCopyrightPeriod' ? 'Invalid copyright period' : 'Invalid copyright year';
+        return `${colors[result.severity]} ${message}! Expected '${expected}' but is '${actual}'`;
+    } else if (result.violation === 'noOrMissingHeader') {
+        return `${colors[result.severity]} No or invalid copyright header!`;
+    }
+
+    return `${colors[result.severity]} OK`;
+}
+
+function fixViolations(rootDir: string, violations: DateValidationResult[], options: HeaderCheckOptions): void {
+    LOGGER.newLine();
+    violations.forEach((violation, i) => {
+        printFileProgress(i + 1, violations.length, `Fix ${violation.file}`, false);
+        const fixedStartYear =
+            violation.currentStartYear < violation.expectedStartYear ? violation.currentStartYear : violation.expectedStartYear;
+
+        const currentRange = `${violation.currentStartYear}${violation.currentEndYear ? '-' + violation.currentEndYear : ''}`;
+
+        let fixedRange = `${fixedStartYear}`;
+        if (violation.expectedEndYear !== violation.expectedStartYear || fixedStartYear !== violation.expectedStartYear) {
+            fixedRange = `${fixedStartYear}-${violation.expectedEndYear}`;
+        }
+
+        sh.sed('-i', RegExp('Copyright \\([cC]\\) ' + currentRange), `Copyright (c) ${fixedRange}`, violation.file);
+    });
+    LOGGER.newLine();
+    if (options.autoFix || readline.keyInYN('Do you want to create a commit for the fixed files?')) {
+        LOGGER.newLine();
+        const files = violations.map(violation => violation.file).join(' ');
+        sh.exec(`git add ${files}`, getShellConfig());
+        sh.exec(`git commit -m "${AUTO_FIX_MESSAGE}"`);
+        LOGGER.newLine();
+    }
+}
+
+// Helper types
+interface ValidationResult {
+    file: string;
+    severity: Severity;
+    violation: Violation;
+}
+
+interface DateValidationResult extends ValidationResult {
+    currentStartYear: number;
+    expectedStartYear: number;
+    currentEndYear?: number;
+    expectedEndYear: number;
+}
+
+function isDateValidationResult(object: ValidationResult): object is DateValidationResult {
+    return 'currentStartYear' in object && 'expectedStartYear' in object && 'expectedEndYear' in object;
+}
+
+type Violation = 'none' | 'noOrMissingHeader' | 'incorrectCopyrightPeriod' | 'invalidCopyrightYear';

package/src/commands/release/common.ts

@@ -21,7 +21,7 @@ import * as readline from 'readline-sync';
 import * as semver from 'semver';
 import * as sh from 'shelljs';
 import { fatalExec, getShellConfig } from '../../util/command-util';
-import { getLatestRelease, getLatestTag, hasGitChanges, isGitRepository } from '../../util/git-util';
+import { getLatestGithubRelease, getLatestTag, hasGitChanges, isGitRepository } from '../../util/git-util';
 import { LOGGER } from '../../util/logger';
 import { validateVersion } from '../../util/validation-util';
 
@@ -134,8 +134,8 @@ export function checkoutAndCd(options: ReleaseOptions): string {
     sh.exec(`gh repo clone ${ghUrl}`, getShellConfig());
     LOGGER.debug(`Successfully cloned to ${directory}`);
     sh.cd(directory);
-    if (options.checkoutDir !== 'master') {
-        sh.exec(`git switch ${options.branch} `);
+    if (options.branch !== 'master' && options.branch !== 'main') {
+        sh.exec(`git checkout ${options.branch} `);
     }
     return sh.pwd();
 }
@@ -175,7 +175,7 @@ export function publish(repositoryPath: string, options: ReleaseOptions): void {
         throw new Error('Publish failed. The repository has pending changes');
     }
 
-    const latestReleaseTag = getLatestRelease();
+    const latestReleaseTag = getLatestGithubRelease();
     const localTag = getLatestTag();
     validateTag(latestReleaseTag, localTag);
     const preRelease = options.releaseType === 'rc' || localTag.includes('-');
@@ -186,7 +186,7 @@ function doPublish(tag: string, preRelease: boolean, latestRelease: string, draf
     fatalExec(`git push origin HEAD:${tag}`, 'Could not push release branch to Github', getShellConfig({ silent: false }));
     fatalExec(`git push origin tag ${tag}`, 'Could not push tag to Github', getShellConfig({ silent: false }));
     const version = tagToVersion(tag);
-    const titleSuffix = preRelease ? ` Candiate ${version.substring(version.length - 1)}` : '';
+    const titleSuffix = preRelease ? ` Candidate ${version.substring(version.lastIndexOf('-RC') + 3)}` : '';
     const title = `${version.replace(/-.*/, '')} Release${titleSuffix} `;
     sh.exec(
         `gh release create ${tag} -t "${title}" --notes-start-tag ${latestRelease} --generate-notes ${draft ? '-d' : ''} ${
@@ -257,8 +257,8 @@ export function asMvnVersion(version: string): string {
     return mavenVersion;
 }
 
-export async function checkIfNpmVersionExists(pckgName: string, newVersion: string): Promise<void> {
-    LOGGER.debug(`Check if version exists on npm: ${newVersion}`);
+export async function checkIfNpmVersionIsNew(pckgName: string, newVersion: string): Promise<void> {
+    LOGGER.debug(`Check that the release version is new i.e. does not exist on npm: ${newVersion}`);
 
     const response = await fetch(`https://registry.npmjs.org/${pckgName}/${newVersion}`);
     const data = await response.json();

package/src/commands/release/release-client.ts

@@ -16,15 +16,13 @@
 import * as sh from 'shelljs';
 import { LOGGER } from '../../util/logger';
 import {
-    asMvnVersion,
-    checkJavaServerVersion,
     checkoutAndCd,
     commitAndTag,
     lernaSetVersion,
     publish,
     ReleaseOptions,
     updateLernaForDryRun,
-    updateServerConfig,
+    updateVersion,
     yarnInstall
 } from './common';
 
@@ -34,7 +32,7 @@ export async function releaseClient(options: ReleaseOptions): Promise<void> {
     LOGGER.info('Prepare glsp-client release');
     LOGGER.debug('Release options: ', options.version);
     REPO_ROOT = checkoutAndCd(options);
-    await updateDownloadServerScript(options.version, options.force);
+    updateExternalGLSPDependencies(options.version);
     generateChangeLog();
     lernaSetVersion(REPO_ROOT, options.version);
     build();
@@ -45,12 +43,10 @@ export async function releaseClient(options: ReleaseOptions): Promise<void> {
     publish(REPO_ROOT, options);
 }
 
-async function updateDownloadServerScript(version: string, force: boolean): Promise<void> {
-    LOGGER.info('Update example server download config');
-    const mvnVersion = asMvnVersion(version);
-    checkJavaServerVersion(version, force);
-    sh.cd(`${REPO_ROOT}/examples/workflow-glsp/scripts`);
-    updateServerConfig('config.json', mvnVersion, false);
+function updateExternalGLSPDependencies(version: string): void {
+    LOGGER.info('Update external GLSP dependencies (workflow example server)');
+    sh.cd(REPO_ROOT);
+    updateVersion({ name: '@eclipse-glsp-examples/workflow-server-bundled', version });
 }
 
 function generateChangeLog(): void {

package/src/commands/release/release-java-server.ts

@@ -67,7 +67,7 @@ function build(): void {
     LOGGER.info('Build M2 & P2');
     LOGGER.debug('M2');
     fatalExec('mvn clean install -Pm2', 'M2 build failed', getShellConfig({ silent: false }));
-    console.log('');
+    LOGGER.newLine();
     LOGGER.debug('P2');
     fatalExec('mvn clean install -Pp2', 'P2 build failed', getShellConfig({ silent: false }));
 }

package/src/commands/release/release-theia-integration.ts

@@ -17,15 +17,12 @@
 import * as sh from 'shelljs';
 import { LOGGER } from '../../util/logger';
 import {
-    asMvnVersion,
     checkoutAndCd,
     commitAndTag,
-    isExistingMavenVersion,
     lernaSetVersion,
     publish,
     ReleaseOptions,
     updateLernaForDryRun,
-    updateServerConfig,
     updateVersion,
     yarnInstall
 } from './common';
@@ -37,7 +34,6 @@ export async function releaseTheiaIntegration(options: ReleaseOptions): Promise<
     LOGGER.debug('Release options: ', options);
     REPO_ROOT = checkoutAndCd(options);
     updateExternalGLSPDependencies(options.version);
-    await updateDownloadServerScript(options.version);
     generateChangeLog();
     lernaSetVersion(REPO_ROOT, options.version);
     build();
@@ -49,21 +45,13 @@ export async function releaseTheiaIntegration(options: ReleaseOptions): Promise<
 }
 
 function updateExternalGLSPDependencies(version: string): void {
-    LOGGER.info('Update external GLSP dependencies (Client and workflow example)');
+    LOGGER.info('Update external GLSP dependencies (Client and workflow example & server)');
     sh.cd(REPO_ROOT);
-    updateVersion({ name: '@eclipse-glsp/client', version }, { name: '@eclipse-glsp-examples/workflow-glsp', version });
-}
-
-async function updateDownloadServerScript(version: string): Promise<void> {
-    LOGGER.info('Update example server download config');
-    const mvnVersion = asMvnVersion(version);
-    if (!isExistingMavenVersion('org.eclipse.glsp', 'org.eclipse.glsp.server', mvnVersion)) {
-        LOGGER.warn(`No Java GLSP server with version ${mvnVersion} found on maven central!. Please release a new Java GLSP Server version
-        before publishing this release!`);
-    }
-
-    sh.cd(`${REPO_ROOT}/examples/workflow-theia/src/node`);
-    updateServerConfig('server-config.json', mvnVersion, false);
+    updateVersion(
+        { name: '@eclipse-glsp/client', version },
+        { name: '@eclipse-glsp-examples/workflow-glsp', version },
+        { name: '@eclipse-glsp-examples/workflow-server', version }
+    );
 }
 
 function build(): void {

package/src/commands/release/release-vscode-integration.ts

@@ -50,7 +50,8 @@ function updateExternalGLSPDependencies(version: string): void {
     updateVersion(
         { name: '@eclipse-glsp/protocol', version },
         { name: '@eclipse-glsp/client', version },
-        { name: '@eclipse-glsp-examples/workflow-glsp', version }
+        { name: '@eclipse-glsp-examples/workflow-glsp', version },
+        { name: '@eclipse-glsp-examples/workflow-server', version }
     );
 }