@suitegeezus/suitecloud-cli 3.1.4

package/src/core/CommandOptionsValidator.js

@@ -0,0 +1,42 @@
+/*
+** Copyright (c) 2024 Oracle and/or its affiliates.  All rights reserved.
+** Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
+*/
+'use strict';
+
+const NodeTranslationService = require('../services/NodeTranslationService');
+const TRANSLATION_KEYS = require('../services/TranslationKeys');
+const assert = require('assert');
+
+module.exports = class CommandOptionsValidator {
+	validate(options) {
+		assert(options);
+		assert(options.commandOptions);
+		assert(options.arguments);
+
+		const validationErrors = [];
+
+		const isMandatoryOptionPresent = (optionId, aliasId, args) => {
+			return args[optionId] || args[aliasId];
+		};
+
+		for (const optionId in options.commandOptions) {
+			const option = options.commandOptions[optionId];
+			const aliasId = option.alias;
+			if (options.commandOptions.hasOwnProperty(optionId)) {
+				if (
+					option.mandatory &&
+					!isMandatoryOptionPresent(optionId, aliasId, options.arguments)
+				) {
+					validationErrors.push(
+						NodeTranslationService.getMessage(
+							TRANSLATION_KEYS.COMMAND_OPTIONS.IS_MANDATORY,
+							option.name
+						)
+					);
+				}
+			}
+		}
+		return validationErrors;
+	}
+};

package/src/core/CommandRegistrationService.js

@@ -0,0 +1,130 @@
+/*
+ ** Copyright (c) 2024 Oracle and/or its affiliates.  All rights reserved.
+ ** Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
+ */
+'use strict';
+
+const { Option } = require('commander');
+
+const assert = require('assert');
+const NodeTranslationService = require('../services/NodeTranslationService');
+const { COMMAND_OPTIONS } = require('../services/TranslationKeys');
+const OPTION_TYPE = {
+	FLAG: 'FLAG',
+	SINGLE: 'SINGLE',
+	MULTIPLE: 'MULTIPLE',
+};
+const INTERACTIVE_OPTION_NAME = 'interactive';
+const INTERACTIVE_OPTION_ALIAS = 'i';
+const HELP_OPTION_ALIAS_NAME = '-h, --help';
+
+const EXIT_CODE = {
+	SUCCESS: 0,
+	ERROR: 1,
+};
+
+module.exports = class CommandRegistrationService {
+	register(options) {
+		assert(options);
+		assert(options.commandMetadata);
+		assert(options.program);
+		assert(options.executeCommandFunction);
+		assert(typeof options.runInInteractiveMode === 'boolean');
+
+		const commandMetadata = options.commandMetadata;
+		const program = options.program;
+		const executeCommandFunction = options.executeCommandFunction;
+		const runInInteractiveMode = options.runInInteractiveMode;
+
+		const helpMessage = NodeTranslationService.getMessage(COMMAND_OPTIONS.HELP);
+
+		let commandSetup = program.command(commandMetadata.name).helpOption(HELP_OPTION_ALIAS_NAME, helpMessage);
+
+		if (!runInInteractiveMode) {
+			if (commandMetadata.supportsInteractiveMode) {
+				const interactiveOptionHelp = NodeTranslationService.getMessage(COMMAND_OPTIONS.INTERACTIVE_HELP, commandMetadata.name);
+				commandMetadata.options.interactive = {
+					name: INTERACTIVE_OPTION_NAME,
+					alias: INTERACTIVE_OPTION_ALIAS,
+					description: interactiveOptionHelp,
+					type: OPTION_TYPE.FLAG,
+					mandatory: false,
+				};
+			}
+			commandSetup = this._addNonInteractiveCommandOptions(commandSetup, commandMetadata.options);
+		} else {
+			commandSetup = this._addInteractiveCommandOptions(commandSetup, commandMetadata.options);
+
+		}
+
+		commandSetup.description(commandMetadata.description).action(async (options) => {
+			const actionResult = await executeCommandFunction(options);
+			process.exitCode = actionResult.isSuccess() ? EXIT_CODE.SUCCESS : EXIT_CODE.ERROR;
+		});
+	}
+
+	_addInteractiveCommandOptions(commandSetup,options){
+		const filteredOptions = Object.entries(options).filter(([key,o])=>{
+			return ['authid','project','config','debug'].includes(o.name);
+		});
+		filteredOptions.push(['interactive',{
+			"name": "interactive",
+			"option": "interactive",
+			"description": "Be interactive",
+			"mandatory": true,
+			"type": "FLAG",
+			"usage": "",
+			"defaultOption": true,
+			"disableInIntegrationMode": false,
+			"conflicts": []
+		}]);
+		return this._addNonInteractiveCommandOptions(commandSetup, Object.fromEntries(filteredOptions));
+	}
+
+	_addNonInteractiveCommandOptions(commandSetup, options) {
+		const optionsSortedByName = Object.values(options).sort((option1, option2) => option1.name.localeCompare(option2.name));
+		optionsSortedByName.forEach((option) => {
+			if (option.disableInIntegrationMode) {
+				return;
+			}
+			const Optional = 'Optional:';
+			let optionString = '';
+			if (option.alias) {
+				optionString = `-${option.alias}, `;
+			}
+			optionString += `--${option.name}`;
+
+			if (option.type === OPTION_TYPE.SINGLE) {
+				optionString += ` <argument>`;
+			} else if (option.type === OPTION_TYPE.MULTIPLE) {
+				optionString += ` <arguments...>`;
+			}
+
+			const description = [option.description];
+			if( !option.mandatory ) description.unshift(Optional);
+			else description.unshift(''.padStart(Optional.length));
+
+			if( Array.isArray(option.conflicts)){
+				description.push('\nConflict: ' + option.conflicts)
+			}
+
+			// if( option.env)
+				//description.push('\nEnv:'.padEnd(Optional.length), options.env);
+
+			const commandOption = new Option(optionString, description.join(' '));
+			if (option.hidden) {
+				commandOption.hideHelp();
+			}
+			if( Array.isArray(option.conflicts)){
+				commandOption.conflicts(option.conflicts);
+			}
+
+			if( option.env ){
+				commandOption.env(option.env)
+			}
+
+			commandSetup.addOption(commandOption);
+		});
+		return commandSetup;
+	}
+};

package/src/core/CommandsMetadataService.js

@@ -0,0 +1,104 @@
+/*
+ ** Copyright (c) 2024 Oracle and/or its affiliates.  All rights reserved.
+ ** Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
+ */
+'use strict';
+
+const path = require('path');
+const FileUtils = require('../utils/FileUtils');
+const {
+	SDK_COMMANDS_METADATA_FILE,
+	SDK_COMMANDS_METADATA_PATCH_FILE,
+	NODE_COMMANDS_METADATA_FILE,
+	COMMAND_GENERATORS_METADATA_FILE,
+} = require('../ApplicationConstants');
+
+let commandsMetadataCache;
+
+function executeForEachCommandMetadata(commandsMetadata, func) {
+	for (const commandMetadataId in commandsMetadata) {
+		if (commandsMetadata.hasOwnProperty(commandMetadataId)) {
+			const commandMetadata = commandsMetadata[commandMetadataId];
+			func(commandMetadata);
+		}
+	}
+}
+
+module.exports = class CommandsMetadataService {
+	constructor() {
+		this._rootCLIPath = path.dirname(__dirname, '../');
+		this._initializeCommandsMetadata();
+	}
+
+	_initializeCommandsMetadata() {
+		if (!commandsMetadataCache) {
+			const sdkCommandsMetadata = this._getMetadataFromFile(path.join(this._rootCLIPath, SDK_COMMANDS_METADATA_FILE));
+			const SdkCommandsMetadataPatch = this._getMetadataFromFile(path.join(this._rootCLIPath, SDK_COMMANDS_METADATA_PATCH_FILE));
+			const nodeCommandsMetadata = this._getMetadataFromFile(path.join(this._rootCLIPath, NODE_COMMANDS_METADATA_FILE));
+			const commandGeneratorsMetadata = this._getMetadataFromFile(path.join(this._rootCLIPath, COMMAND_GENERATORS_METADATA_FILE));
+
+			let combinedSdkCommandMetadata = this._combineMetadata(sdkCommandsMetadata, SdkCommandsMetadataPatch);
+			let combinedMetadata = {
+				...combinedSdkCommandMetadata,
+				...nodeCommandsMetadata,
+			};
+			combinedMetadata = this._addCommandGeneratorMetadata(commandGeneratorsMetadata, combinedMetadata);
+			commandsMetadataCache = combinedMetadata;
+		}
+	}
+
+	_combineMetadata(sdkCommandsMetadata, modifiedSdkCommandsMetadata) {
+		return this._replaceObjectProperties(sdkCommandsMetadata, modifiedSdkCommandsMetadata);
+	}
+
+	_replaceObjectProperties(originalObject, newObject) {
+		const resultObject = originalObject;
+		Object.entries(newObject).forEach((entry) => {
+			const [propertyKey, propertyValue] = entry;
+			resultObject[propertyKey] = this._replacePropertyValue(originalObject[propertyKey], propertyValue);
+		});
+		return resultObject;
+	}
+
+	_replacePropertyValue(originalPropertyValue, newPropertyValue) {
+		if (originalPropertyValue && typeof newPropertyValue === 'object') {
+			return this._replaceObjectProperties(originalPropertyValue, newPropertyValue);
+		} else {
+			return newPropertyValue;
+		}
+	}
+
+	getCommandsMetadata() {
+		return commandsMetadataCache;
+	}
+
+	getCommandMetadataByName(commandName) {
+		const commandMetadata = commandsMetadataCache[commandName];
+		if (!commandMetadata) {
+			throw `No metadata found or initialized for Command ${commandName}`;
+		}
+		return commandMetadata;
+	}
+
+	_getMetadataFromFile(filepath) {
+		if (!FileUtils.exists(filepath)) {
+			throw `Commands Metadata in filepath ${filepath} not found`;
+		}
+		try {
+			return FileUtils.readAsJson(filepath);
+		} catch (error) {
+			throw `Error parsing Commands Metadata from ${filepath}`;
+		}
+	}
+
+	_addCommandGeneratorMetadata(commandGeneratorsMetadata, commandsMetadata) {
+		executeForEachCommandMetadata(commandsMetadata, (commandMetadata) => {
+			const generatorMetadata = commandGeneratorsMetadata.find((generatorMetadata) => {
+				return generatorMetadata.commandName === commandMetadata.name;
+			});
+			commandMetadata.generator = path.join(this._rootCLIPath, generatorMetadata.generator);
+			commandMetadata.supportsInteractiveMode = generatorMetadata.supportsInteractiveMode;
+		});
+		return commandsMetadata;
+	}
+};

package/src/core/extensibility/CLIConfigurationService.js

@@ -0,0 +1,192 @@
+/*
+ ** Copyright (c) 2024 Oracle and/or its affiliates.  All rights reserved.
+ ** Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
+ */
+'use strict';
+
+const { lineBreak } = require('../../loggers/LoggerOsConstants');
+const FileUtils = require('../../utils/FileUtils');
+const path = require('path');
+const NodeTranslationService = require('./../../services/NodeTranslationService');
+const { ERRORS } = require('./../../services/TranslationKeys');
+const FileService = require('../../services/FileSystemService');
+const { getProjectDefaultAuthId } = require('../../utils/AuthenticationUtils');
+const CommandUserExtension = require('./CommandUserExtension');
+const { ENV_VARS, FILES, FOLDERS } = require('../../ApplicationConstants');
+const CLI_CONFIG_FILES = [...FILES.CLI_CONFIG_FILE_JS, ...FILES.CLI_CONFIG_FILE_JSON];
+const PROJECT_DIRS = [FOLDERS.FILE_CABINET, FOLDERS.OBJECTS];
+const DEFAULT_AUTH_ID_PROPERTY = 'defaultAuthId';
+const DEFAULT_CONFIG = {
+	defaultProjectFolder: '',
+	[DEFAULT_AUTH_ID_PROPERTY]: null,
+	commands: {},
+};
+
+const isString = (str) => typeof str === 'string' || str instanceof String;
+
+module.exports = class CLIConfigurationService {
+	constructor() {
+		this._cliConfig = DEFAULT_CONFIG;
+	}
+
+	initialize(executionPath, override = false) {
+		let cliConfigFile;
+		const fileServiceInstance = new FileService();
+
+		if (!override) {
+			cliConfigFile = fileServiceInstance.getFirstAncestorByName(CLI_CONFIG_FILES, executionPath, false);
+			// try by directory
+		} else if (!executionPath) {
+			// noconfig mode
+			this._executionPath = process.cwd();
+			return;
+		}
+
+		// it might be something like @suitegeezus/cool-package/sdf.config.js
+		if(/^@\w\b/.test(executionPath)){
+			cliConfigFile = require.resolve(executionPath);
+		} else if (!/[.]js(on)?$/.test(executionPath)) {
+			cliConfigFile = fileServiceInstance.getFirstAncestorByName(CLI_CONFIG_FILES, executionPath, false);
+		} else if (typeof executionPath === 'string') {
+			cliConfigFile = fileServiceInstance.getFirstAncestorByName(
+				[path.basename(executionPath)],
+				path.dirname(executionPath),
+				false,
+			);
+		}
+		if (!cliConfigFile) {
+			const candidateDir = fileServiceInstance.getFirstAncestorByName(PROJECT_DIRS, executionPath, true);
+			if (candidateDir) this._executionPath = candidateDir;
+			else this._executionPath = executionPath;
+		} else {
+			this._executionPath = path.dirname(cliConfigFile);
+		}
+
+		if (!FileUtils.exists(cliConfigFile)) {
+			return;
+		}
+
+		try {
+			this._cliConfig = require(cliConfigFile);
+		} catch (error) {
+			throw NodeTranslationService.getMessage(ERRORS.CLI_CONFIG_ERROR_LOADING_CONFIGURATION_MODULE, cliConfigFile, lineBreak, error);
+		}
+	}
+
+	getCommandUserExtension(commandName) {
+		const commandExtension =
+			this._cliConfig && this._cliConfig.commands && this._cliConfig.commands[commandName] ? this._cliConfig.commands[commandName] : {};
+		return new CommandUserExtension(commandExtension);
+	}
+
+	/**
+	 * @private
+	 * @param {string} projectFolder
+	 * @param {string} file
+	 * @param {string} property
+	 * @returns {*}
+	 * @private
+	 */
+	__getPropertyFromFile(projectFolder, file, property) {
+		const projectFilePath = path.join(projectFolder, file);
+
+		if (FileUtils.exists(projectFilePath)) {
+			try {
+				const fileContentJson = FileUtils.readAsJson(projectFilePath);
+				return fileContentJson[property];
+			} catch (error) {
+				// if( throwError === false ) return;
+				throw NodeTranslationService.getMessage(ERRORS.WRONG_JSON_FILE, projectFilePath, error) +
+				lineBreak + NodeTranslationService.getMessage(ERRORS.RUN_SETUP_ACCOUNT);
+			}
+		}
+	}
+
+	getAuthId(command, projectPath, adhoc) {
+		// how do we determine which project.json to use if the folder was specified?
+		const lookInConfig = () => {
+			try {
+				return this.__getPropertyFromFile(projectPath, FILES.PROJECT_JSON, DEFAULT_AUTH_ID_PROPERTY);
+			} catch {
+				//
+			}
+		};
+
+		const commandConfig = this._cliConfig && this._cliConfig.commands && this._cliConfig.commands[command];
+		switch (true) {
+			// look in the command
+			case Boolean(commandConfig && commandConfig.authId):
+				return commandConfig.authId;
+
+			case Boolean(adhoc):
+				return adhoc;
+
+			case Boolean(process.env[ENV_VARS.SUITECLOUD_AUTHID]):
+				return process.env[ENV_VARS.SUITECLOUD_AUTHID];
+
+			case Boolean(lookInConfig()):
+				return lookInConfig();
+
+			// look in fixed config
+			case  Boolean(this._cliConfig.defaultAuthId):
+				return this._cliConfig.defaultAuthId;
+
+			default:
+				throw NodeTranslationService.getMessage(ERRORS.MISSING_DEFAULT_AUTH_ID, DEFAULT_AUTH_ID_PROPERTY);
+
+		}
+	}
+
+	setAuthId(value) {
+		if (!this._authId) {
+			this._authId = value;
+			return true;
+		}
+		return false;
+	}
+
+	getProjectFolder(command, adhoc) {
+		// recall that empty string is a value projectFolder so we use undefined here
+		const pathBits = { projectFolder: undefined };
+
+		const commandConfig = this._cliConfig && this._cliConfig.commands && this._cliConfig.commands[command];
+		/** @todo look in process.cwd()/project.json */
+		switch (true) {
+
+			// look in the command
+			case Boolean(commandConfig && isString(commandConfig.projectFolder)):
+				pathBits.projectFolder = commandConfig.projectFolder;
+				break;
+
+			// adhoc
+			case  typeof pathBits.projectFolder !== 'string' && typeof adhoc === 'string' :
+				pathBits.projectFolder = adhoc;
+				break;
+
+			// look in env
+			case typeof pathBits.projectFolder !== 'string' && typeof process.env[ENV_VARS.SUITECLOUD_PROJECT_FOLDER] === 'string':
+				pathBits.projectFolder = process.env[ENV_VARS.SUITECLOUD_PROJECT_FOLDER];
+				break;
+
+			// look in fixed config
+			case isString(this._cliConfig.defaultProjectFolder):
+				pathBits.projectFolder = this._cliConfig.defaultProjectFolder;
+				break;
+
+			// default
+			default: {
+				// attempt to resolve
+				const files = (new FileService()).getFoldersFromDirectoryRecursively(this._executionPath);
+				const firstFc = files.find((f) => /\bFileCabinet\b/.test(f));
+				pathBits.projectFolder = path.relative(this._executionPath, firstFc.replace(/^(.*).\bFileCabinet\b.*$/, '$1'));
+				break;
+			}
+		}
+
+		return pathBits.projectFolder;
+	}
+
+	getProjectPath(projectFolder) {
+		return path.join(this._executionPath, projectFolder);
+	}
+};

package/src/core/extensibility/CommandUserExtension.js

@@ -0,0 +1,64 @@
+/*
+ ** Copyright (c) 2024 Oracle and/or its affiliates.  All rights reserved.
+ ** Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
+ */
+'use strict';
+
+const assert = require('assert');
+const nodePath = require('node:path');
+const NodeTranslationService = require('../../services/NodeTranslationService');
+const { lineBreak } = require('../../loggers/LoggerOsConstants');
+const { ERRORS } = require('../../services/TranslationKeys');
+
+module.exports = class CommandUserExtension {
+	constructor(cliConfig) {
+		this._cliConfig = cliConfig;
+	}
+
+	async beforeExecuting(options) {
+		assert(options);
+		assert(options.commandName);
+		assert(typeof options.projectFolder === 'string');
+		assert(options.projectPath);
+		assert(options.arguments);
+
+		try {
+			if (!this._cliConfig.beforeExecuting) {
+				return options;
+			}
+			const beforeExecutingContext = {
+				command: options.commandName,
+				projectPath: options.projectPath,
+				projectFolder: nodePath.relative(options.executionPath, options.projectPath),
+				arguments: options.arguments,
+			};
+			if( options.executionPath) beforeExecutingContext.executionPath = options.executionPath;
+			if( options.authId) beforeExecutingContext.authId = options.authId;
+			const result = await this._cliConfig.beforeExecuting(beforeExecutingContext);
+			this._validateBeforeExecutingResult(result);
+			return result;
+		} catch (error) {
+			throw NodeTranslationService.getMessage(ERRORS.CLI_CONFIG_BEFORE_EXECUTING_FAILED, lineBreak, error);
+		}
+	}
+
+	onCompleted(options) {
+		if (!this._cliConfig.onCompleted) {
+			return options;
+		}
+		this._cliConfig.onCompleted(options);
+	}
+
+	onError(options) {
+		if (!this._cliConfig.onError) {
+			return options;
+		}
+		this._cliConfig.onError(options);
+	}
+
+	_validateBeforeExecutingResult(result) {
+		if (typeof result === 'undefined' || typeof result.arguments !== 'object') {
+			throw NodeTranslationService.getMessage(ERRORS.CLI_CONFIG_BEFORE_EXECUTING_WRONG_RETURN_VALUE);
+		}
+	}
+};

package/src/core/sdksetup/SdkDownloadService.js

@@ -0,0 +1,109 @@
+/*
+ ** Copyright (c) 2024 Oracle and/or its affiliates.  All rights reserved.
+ ** Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const SdkProperties = require('./SdkProperties');
+
+const https = require('https');
+const http = require('http');
+const { URL } = require('url');
+const ProxyAgent = require('../../utils/http/ProxyAgent');
+const { ENCODING, EVENT, HEADER, PROTOCOL } = require('../../utils/http/HttpConstants');
+
+const HOME_PATH = require('os').homedir();
+
+const { FOLDERS } = require('../../ApplicationConstants');
+
+const unwrapExceptionMessage = require('../../utils/ExceptionUtils').unwrapExceptionMessage;
+
+const NodeTranslationService = require('../../services/NodeTranslationService');
+const FileSystemService = require('../../services/FileSystemService');
+
+const { SDK_DOWNLOAD_SERVICE } = require('../../services/TranslationKeys');
+
+const VALID_JAR_CONTENT_TYPES = ['application/java-archive', 'application/x-java-archive', 'application/x-jar'];
+const ERROR_CODE = -1;
+
+class SdkDownloadService {
+	constructor() {
+		this._fileSystemService = new FileSystemService();
+	}
+
+	async download() {
+		const sdkParentDirectory = this._fileSystemService.createFolder(HOME_PATH, FOLDERS.SUITECLOUD_SDK);
+		// remove OLD jar files
+		this._removeJarFilesFrom(sdkParentDirectory);
+		const sdkDirectory = this._fileSystemService.createFolder(sdkParentDirectory, FOLDERS.NODE_CLI);
+
+		const fullURL = `${SdkProperties.getDownloadURL()}/${SdkProperties.getSdkFileName()}`;
+		const destinationFilePath = path.join(sdkDirectory, SdkProperties.getSdkFileName());
+		const proxy = process.env.SUITECLOUD_PROXY || process.env.npm_config_https_proxy || process.env.npm_config_proxy;
+		const skipProxy = SdkProperties.configFileExists();
+
+		try {
+			await this._downloadJarFilePromise(fullURL, destinationFilePath, proxy, skipProxy);
+		} catch (error) {
+			console.error(NodeTranslationService.getMessage(SDK_DOWNLOAD_SERVICE.ERROR, fullURL, unwrapExceptionMessage(error)));
+			process.exit(ERROR_CODE);
+		}
+	}
+
+	_downloadJarFilePromise(downloadUrl, destinationFilePath, proxy, skipProxy) {
+		const downloadUrlObject = new URL(downloadUrl);
+		const downloadUrlProtocol = downloadUrlObject.protocol;
+
+		const requestOptions = {
+			encoding: ENCODING.BINARY,
+			...(proxy && !skipProxy && { agent: new ProxyAgent(proxy, { tunnel: true, timeout: 15000 }) }),
+		};
+
+		if (!/^http:$|^https:$/.test(downloadUrlProtocol)) {
+			throw new Error(NodeTranslationService.getMessage(SDK_DOWNLOAD_SERVICE.WRONG_DOWNLOAD_URL_PROTOCOL));
+		}
+
+		const httpxModule = PROTOCOL.HTTP.match(downloadUrlObject.protocol) ? http : https;
+
+		return new Promise((resolve, reject) => {
+			const clientReq = httpxModule.get(downloadUrlObject, requestOptions, (response) => {
+				const chunks = [];
+				response.on(EVENT.DATA, (chunk) => chunks.push(Buffer.from(chunk, ENCODING.BINARY)));
+
+				response.on(EVENT.END, () => {
+					if (!VALID_JAR_CONTENT_TYPES.includes(response.headers[HEADER.CONTENT_TYPE])) {
+						reject(NodeTranslationService.getMessage(SDK_DOWNLOAD_SERVICE.FILE_NOT_AVAILABLE_ERROR));
+					}
+
+					const jarFile = fs.createWriteStream(destinationFilePath);
+					jarFile.write(Buffer.concat(chunks), ENCODING.BINARY);
+					jarFile.end();
+					resolve();
+				});
+
+				response.on(EVENT.ERROR, (error) => {
+					reject(NodeTranslationService.getMessage(SDK_DOWNLOAD_SERVICE.FILE_NOT_AVAILABLE_ERROR));
+				});
+			});
+
+			clientReq
+				.once(EVENT.TIMEOUT, () => {
+					clientReq.destroy();
+					reject(new Error(NodeTranslationService.getMessage(SDK_DOWNLOAD_SERVICE.GET_TIMEOUT)));
+				})
+				.once(EVENT.ERROR, (err) => reject(err))
+				.end();
+		});
+	}
+
+	_removeJarFilesFrom(folder) {
+		// remove all JAR files before writing response to file
+		fs.readdirSync(folder)
+			.filter((file) => /[.]jar$/.test(file))
+			.map((file) => fs.unlinkSync(path.join(folder, file)));
+	}
+}
+
+module.exports = new SdkDownloadService();

package/src/core/sdksetup/SdkLicense.js

@@ -0,0 +1,39 @@
+'use strict';
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const LICENSE_PATH = path.normalize('./resources/FUTC-LICENSE.txt');
+const WINDOWS_PLATFORM = 'win32';
+const LINUX_PLATFORM = 'linux';
+const OSX_PLATFORM = 'darwin';
+const WINDOWS_CMD = 'start';
+const LINUX_CMD = 'xdg-open';
+const OSX_CMD = 'open';
+const ERROR_MESSAGE = 'Something went wrong.';
+const LICENSE_MESSAGE = 'Use the --acceptsuitecloudsdklicense flag to accept the FUTC license:' +
+	' https://www.oracle.com/downloads/licenses/oracle-free-license.html';
+const supportedPlatformsCommands = {
+	[WINDOWS_PLATFORM]: WINDOWS_CMD,
+	[LINUX_PLATFORM]: LINUX_CMD,
+	[OSX_PLATFORM]: OSX_CMD,
+};
+
+class SdkLicense {
+
+	show() {
+		if (process.env.npm_config_acceptsuitecloudsdklicense || process.env.npm_config_acceptSuiteCloudSDKLicense) {
+			return;
+		}
+		const currentPlatform = os.platform();
+		const command = supportedPlatformsCommands[currentPlatform];
+		const execution = spawnSync(command, [LICENSE_PATH], { stdio: 'ignore', detached: true, shell: true });
+		if (execution.error || execution.status !== 0) {
+			console.error(ERROR_MESSAGE);
+			console.error(LICENSE_MESSAGE);
+			return process.exit(execution.error?.errno || execution.status);
+		}
+	}
+}
+
+module.exports = new SdkLicense();