@suitegeezus/suitecloud-cli 3.1.4

package/src/commands/project/validate/ValidateAction.js

@@ -0,0 +1,106 @@
+/*
+ ** 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 BaseAction = require('../../base/BaseAction');
+const DeployActionResult = require('../../../services/actionresult/DeployActionResult');
+const SdkExecutionContext = require('../../../SdkExecutionContext');
+const SdkOperationResultUtils = require('../../../utils/SdkOperationResultUtils');
+const NodeTranslationService = require('../../../services/NodeTranslationService');
+const CommandUtils = require('../../../utils/CommandUtils');
+const ProjectInfoService = require('../../../services/ProjectInfoService');
+const AccountSpecificValuesUtils = require('../../../utils/AccountSpecificValuesUtils');
+const ApplyInstallationPreferencesUtils = require('../../../utils/ApplyInstallationPreferencesUtils');
+const { executeWithSpinner } = require('../../../ui/CliSpinner');
+const { getProjectDefaultAuthId } = require('../../../utils/AuthenticationUtils');
+
+const {
+	COMMAND_VALIDATE: { MESSAGES },
+} = require('../../../services/TranslationKeys');
+
+const COMMAND_OPTIONS = {
+	SERVER: 'server',
+	ACCOUNT_SPECIFIC_VALUES: 'accountspecificvalues',
+	APPLY_INSTALLATION_PREFERENCES: 'applyinstallprefs',
+	PROJECT: 'project',
+	AUTH_ID: 'authid',
+};
+
+module.exports = class ValidateAction extends BaseAction {
+	constructor(options) {
+		super(options);
+		const projectInfoService = new ProjectInfoService(this._projectFolder);
+		this._projectType = projectInfoService.getProjectType()
+		this._projectName = projectInfoService.getProjectName()
+	}
+
+	preExecute(params) {
+		params[COMMAND_OPTIONS.PROJECT] = CommandUtils.quoteString(this._projectFolder);
+
+		AccountSpecificValuesUtils.validate(params, this._projectFolder);
+		ApplyInstallationPreferencesUtils.validate(params, this._projectFolder, this._commandMetadata.name, this._log);
+
+		return {
+			...params,
+			...AccountSpecificValuesUtils.transformArgument(params),
+		};
+	}
+
+	async execute(params) {
+		try {
+			let isServerValidation = false;
+			let installationPreferencesApplied = false;
+			const flags = [];
+
+			if (params[COMMAND_OPTIONS.SERVER]) {
+				flags.push(COMMAND_OPTIONS.SERVER);
+				isServerValidation = true;
+				delete params[COMMAND_OPTIONS.SERVER];
+			}
+
+			if (params[COMMAND_OPTIONS.APPLY_INSTALLATION_PREFERENCES]) {
+				delete params[COMMAND_OPTIONS.APPLY_INSTALLATION_PREFERENCES];
+				flags.push(COMMAND_OPTIONS.APPLY_INSTALLATION_PREFERENCES);
+				installationPreferencesApplied = true;
+			}
+
+			const sdkParams = CommandUtils.extractCommandOptions(params, this._commandMetadata);
+
+			const executionContext = SdkExecutionContext.Builder.forCommand(this._commandMetadata.sdkCommand)
+				.integration()
+				.addParams(sdkParams)
+				.addFlags(flags)
+				.build();
+
+			const operationResult = await executeWithSpinner({
+				action: this._sdkExecutor.execute(executionContext),
+				message: NodeTranslationService.getMessage(
+					MESSAGES.VALIDATING,
+					this._projectName,
+					this._authId
+				)
+			});
+
+			return operationResult.status === SdkOperationResultUtils.STATUS.SUCCESS
+				? DeployActionResult.Builder.withData(operationResult.data)
+						.withResultMessage(operationResult.resultMessage)
+						.withServerValidation(isServerValidation)
+						.withAppliedInstallationPreferences(installationPreferencesApplied)
+						.withProjectType(this._projectType)
+						.withProjectFolder(this._projectFolder)
+						.withCommandParameters(sdkParams)
+						.withCommandFlags(flags)
+						.build()
+				: DeployActionResult.Builder.withErrors(operationResult.errorMessages)
+						.withServerValidation(isServerValidation)
+						.withCommandParameters(sdkParams)
+						.withCommandFlags(flags)
+						.build();
+		} catch (error) {
+			return DeployActionResult.Builder.withErrors([error]).build();
+		}
+	}
+};

package/src/commands/project/validate/ValidateCommand.js

@@ -0,0 +1,20 @@
+/*
+ ** 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 Command = require('../../Command');
+const ValidateAction = require('./ValidateAction');
+const ValidateInputHandler = require('./ValidateInputHandler');
+const ValidateOutputHandler = require('./ValidateOutputHandler');
+
+module.exports = {
+	create(options) {
+		return Command.Builder.withOptions(options)
+			.withAction(ValidateAction)
+			.withInput(ValidateInputHandler)
+			.withOutput(ValidateOutputHandler)
+			.build();
+	}
+};

package/src/commands/project/validate/ValidateInputHandler.js

@@ -0,0 +1,92 @@
+/*
+ ** 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 { default: { prompt } } = require('inquirer');
+const BaseInputHandler = require('../../base/BaseInputHandler');
+const NodeTranslationService = require('../../../services/NodeTranslationService');
+const CommandUtils = require('../../../utils/CommandUtils');
+const ProjectInfoService = require('../../../services/ProjectInfoService');
+const { ACCOUNT_SPECIFIC_VALUES_OPTIONS } = require('../../../utils/AccountSpecificValuesUtils');
+const { PROJECT_ACP, PROJECT_SUITEAPP } = require('../../../ApplicationConstants');
+
+const {
+	COMMAND_VALIDATE: { QUESTIONS, QUESTIONS_CHOICES },
+	YES,
+	NO,
+} = require('../../../services/TranslationKeys');
+
+const COMMAND_OPTIONS = {
+	SERVER: 'server',
+	ACCOUNT_SPECIFIC_VALUES: 'accountspecificvalues',
+	APPLY_INSTALLATION_PREFERENCES: 'applyinstallprefs',
+	PROJECT: 'project',
+	AUTH_ID: 'authid',
+};
+
+module.exports = class ValidateInputHandler extends BaseInputHandler {
+	constructor(options) {
+		super(options);
+		this._projectInfoService = new ProjectInfoService(this._projectFolder);
+	}
+
+	async getParameters(params) {
+
+		const answers = await prompt([
+			{
+				type: CommandUtils.INQUIRER_TYPES.LIST,
+				name: COMMAND_OPTIONS.SERVER,
+				message: NodeTranslationService.getMessage(QUESTIONS.SERVER_SIDE),
+				default: true,
+				choices: [
+					{
+						name: NodeTranslationService.getMessage(QUESTIONS_CHOICES.ACCOUNT_OR_LOCAL.ACCOUNT),
+						value: true,
+					},
+					{
+						name: NodeTranslationService.getMessage(QUESTIONS_CHOICES.ACCOUNT_OR_LOCAL.LOCAL),
+						value: false,
+					},
+				],
+			},
+			{
+				when: this._projectInfoService.getProjectType() === PROJECT_ACP,
+				type: CommandUtils.INQUIRER_TYPES.LIST,
+				name: COMMAND_OPTIONS.ACCOUNT_SPECIFIC_VALUES,
+				message: NodeTranslationService.getMessage(QUESTIONS.ACCOUNT_SPECIFIC_VALUES),
+				default: ACCOUNT_SPECIFIC_VALUES_OPTIONS.ERROR,
+				choices: [
+					{
+						name: NodeTranslationService.getMessage(QUESTIONS_CHOICES.ACCOUNT_SPECIFIC_VALUES.WARNING),
+						value: ACCOUNT_SPECIFIC_VALUES_OPTIONS.WARNING,
+					},
+					{
+						name: NodeTranslationService.getMessage(QUESTIONS_CHOICES.ACCOUNT_SPECIFIC_VALUES.CANCEL),
+						value: ACCOUNT_SPECIFIC_VALUES_OPTIONS.ERROR,
+					},
+				],
+			},
+			{
+				when: this._projectInfoService.getProjectType() === PROJECT_SUITEAPP && this._projectInfoService.hasLockAndHideFiles(),
+				type: CommandUtils.INQUIRER_TYPES.LIST,
+				name: COMMAND_OPTIONS.APPLY_INSTALLATION_PREFERENCES,
+				message: NodeTranslationService.getMessage(QUESTIONS.APPLY_INSTALLATION_PREFERENCES),
+				default: false,
+				choices: [
+					{
+						name: NodeTranslationService.getMessage(NO),
+						value: false,
+					},
+					{
+						name: NodeTranslationService.getMessage(YES),
+						value: true,
+					},
+				],
+			},
+		]);
+		return { ...params, ...answers };
+	}
+};

package/src/commands/project/validate/ValidateOutputHandler.js

@@ -0,0 +1,74 @@
+/*
+ ** 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 BaseOutputHandler = require('../../base/BaseOutputHandler');
+const NodeTranslationService = require('../../../services/NodeTranslationService');
+const ActionResultUtils = require('../../../utils/ActionResultUtils');
+
+const { PROJECT_SUITEAPP } = require('../../../ApplicationConstants');
+const {
+	COMMAND_VALIDATE: { MESSAGES, OUTPUT },
+} = require('../../../services/TranslationKeys');
+
+module.exports = class ValidateOutputHandler extends BaseOutputHandler {
+	constructor(options) {
+		super(options);
+	}
+
+	parse(actionResult) {
+		if (actionResult.isServerValidation && Array.isArray(actionResult.data)) {
+			actionResult.data.forEach((resultLine) => {
+				this._log.result(resultLine);
+			});
+		} else if (!actionResult.isServerValidation) {
+			this._showApplyInstallationPreferencesOptionMessage(
+				actionResult.appliedInstallationPreferences,
+				actionResult.projectType,
+				actionResult.projectFolder
+			);
+			this._showLocalValidationResultData(actionResult.data);
+		}
+		ActionResultUtils.logResultMessage(actionResult, this._log);
+		return actionResult;
+	}
+
+	_showApplyInstallationPreferencesOptionMessage(isAppliedInstallationPreferences, projectType, projectFolder) {
+		if (projectType === PROJECT_SUITEAPP) {
+			if (isAppliedInstallationPreferences) {
+				this._log.info(NodeTranslationService.getMessage(MESSAGES.APPLYING_INSTALLATION_PREFERENCES, projectFolder));
+			} else {
+				this._log.info(NodeTranslationService.getMessage(MESSAGES.NOT_APPLYING_INSTALLATION_PREFERENCES, projectFolder));
+			}
+		}
+	}
+
+	_showLocalValidationResultData(data) {
+		this._logValidationEntries(data.warnings, NodeTranslationService.getMessage(OUTPUT.HEADING_LABEL_WARNING), this._log.warning.bind(this._log));
+		this._logValidationEntries(data.errors, NodeTranslationService.getMessage(OUTPUT.HEADING_LABEL_ERROR), this._log.error.bind(this._log));
+	}
+
+	_logValidationEntries(entries, headingLabel, log) {
+		const files = [];
+		entries.forEach((entry) => {
+			if (!files.includes(entry.filePath)) {
+				files.push(entry.filePath);
+			}
+		});
+
+		if (entries.length > 0) {
+			log(`${headingLabel}:`);
+		}
+
+		files.forEach((file) => {
+			const fileString = `    ${file}`;
+			log(fileString);
+			entries
+				.filter((entry) => entry.filePath === file)
+				.forEach((entry) => {
+					log(NodeTranslationService.getMessage(OUTPUT.VALIDATION_OUTPUT_MESSAGE, entry.lineNumber, entry.message));
+				});
+		});
+	}
+};

package/src/core/CommandActionExecutor.js

@@ -0,0 +1,347 @@
+/*
+ ** 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 fs = require('fs');
+const path = require('path');
+const NodeTranslationService = require('./../services/NodeTranslationService');
+const { ERRORS, CLI, COMMAND_REFRESH_AUTHORIZATION } = require('../services/TranslationKeys');
+const { ActionResult } = require('../services/actionresult/ActionResult');
+const { lineBreak } = require('../loggers/LoggerOsConstants');
+const ActionResultUtils = require('../utils/ActionResultUtils');
+const { unwrapExceptionMessage, unwrapInformationMessage } = require('../utils/ExceptionUtils');
+const { getProjectDefaultAuthId } = require('../utils/AuthenticationUtils');
+const ExecutionEnvironmentContext = require('../ExecutionEnvironmentContext');
+const { checkIfReauthorizationIsNeeded, refreshAuthorization } = require('../utils/AuthenticationUtils');
+const { AUTHORIZATION_PROPERTIES_KEYS, AUTHORIZATION_FORCE_PROMPTS, ENV_VARS } = require('../ApplicationConstants');
+const ManageAccountInputHandler = require('../commands/account/manageauth/ManageAccountInputHandler');
+
+/** @type {CommandActionExecutor} */
+module.exports = class CommandActionExecutor {
+	constructor(dependencies) {
+		assert(dependencies);
+		assert(dependencies.cliConfigurationService);
+		assert(dependencies.commandsMetadataService);
+		assert(dependencies.log);
+		assert(dependencies.sdkPath);
+
+		this._cliConfigurationService = dependencies.cliConfigurationService;
+		this._commandsMetadataService = dependencies.commandsMetadataService;
+		this._log = dependencies.log;
+		this._sdkPath = dependencies.sdkPath;
+
+		if (!dependencies.executionEnvironmentContext) {
+			this._executionEnvironmentContext = new ExecutionEnvironmentContext();
+		} else {
+			this._executionEnvironmentContext = dependencies.executionEnvironmentContext;
+		}
+	}
+	get _executionPath(){
+		return this._cliConfigurationService?._executionPath ?? process.cwd();
+	}
+
+	async executeAction(context) {
+		assert(context);
+		assert(context.arguments);
+		assert(context.commandName);
+		assert(typeof context.runInInteractiveMode === 'boolean');
+
+		let commandUserExtension;
+		const commandName = context.commandName;
+		const debugFilePath = this._getDebugFilePath(context.arguments.debug, commandName);
+		try {
+			const commandMetadata = this._commandsMetadataService.getCommandMetadataByName(commandName);
+			if (context.arguments.config) {
+				this._cliConfigurationService.initialize(context.arguments.config, true);
+			} else if (context.arguments.noconfig) {
+				//do nothing;
+				this._cliConfigurationService.initialize(undefined, true);
+			} else {
+				// location of suitecloud.config
+				this._cliConfigurationService.initialize(process.cwd());
+			}
+
+			commandUserExtension = this._cliConfigurationService.getCommandUserExtension(commandName);
+			const runInInteractiveMode = context.runInInteractiveMode;
+			const commandArguments = this._extractOptionValuesFromArguments(commandMetadata.options, context.arguments);
+
+			// need the
+			const projectFolder = this._cliConfigurationService.getProjectFolder(commandName, commandArguments?.project);
+			const projectPath = this._cliConfigurationService.getProjectPath(projectFolder);
+			let authId;
+			// allow an override via --authid
+			if (commandArguments?.authid) {
+				if (!runInInteractiveMode) {
+					// this might throw -- it could also be semi-interactive
+					try{
+						authId = this._cliConfigurationService.getAuthId(commandName, projectPath, commandArguments?.authid);
+					}catch(e){
+						if( commandMetadata.isSetupRequired ) throw e;
+					}
+
+				} else {
+					[authId] = [commandArguments?.authid, ...AUTHORIZATION_FORCE_PROMPTS].filter(Boolean);
+				}
+			}
+			const promptForInteractive = runInInteractiveMode &&
+				!commandMetadata.name.startsWith('account') &&
+				!authId
+
+			// in interactive mode we can prompt for the authid
+			if (promptForInteractive || AUTHORIZATION_FORCE_PROMPTS.includes(authId) ) {
+				const interactiveAuthIdHandler = new ManageAccountInputHandler({
+					projectFolder: projectPath,
+					commandMetadata,
+					log: this._log,
+					// force it
+					runInInteractiveMode: true,
+					executionEnvironmentContext: this._executionEnvironmentContext,
+					sdkPath: this._sdkPath,
+				});
+				const { selected_auth_id: chosenAuth } = await interactiveAuthIdHandler.getAuthId(authId);
+				if (chosenAuth?.authId) authId = chosenAuth.authId;
+			}
+
+			this._checkCanExecuteCommand({ runInInteractiveMode, commandMetadata, defaultAuthId: authId });
+
+			const commandArgumentsWithDefaultContext = this._applyDefaultContextParams(
+				commandArguments,
+				{
+					project: projectPath,
+					authid: authId,
+				},
+				commandMetadata,
+			);
+			const beforeExecutingOptions = {
+				commandName: commandName,
+				// the path of the config for teh service
+				projectFolder: projectFolder, // this._cliConfigurationService._executionPath,
+				projectPath: projectPath,
+				// probably cwd
+				executionPath: this._executionPath,
+				// do not pass reference
+				arguments: { ...commandArgumentsWithDefaultContext },
+			};
+			if (commandMetadata.isSetupRequired) {
+				// run beforeExecute(args) from suitecloud.config.js
+				beforeExecutingOptions.authId = authId;
+				beforeExecutingOptions.arguments = {
+					...commandArgumentsWithDefaultContext,
+					authid: authId,
+				};
+			}
+
+			if (context.runInInteractiveMode){
+				beforeExecutingOptions.arguments.interactive = true
+			}
+
+			// establish these prior to calling the hooks so they have the available in their environment as well
+			process.env[ENV_VARS.SUITECLOUD_PROJECT_FOLDER] = projectFolder;
+			process.env[ENV_VARS.SUITECLOUD_PROJECT_PATH] = projectPath;
+			process.env[ENV_VARS.SUITECLOUD_PROJECT_ROOT] = this._executionPath;
+			// this might modified but we need the user's hooks to take advantage of their current values
+			process.env[ENV_VARS.SUITECLOUD_AUTHID] = authId;
+			this._dumpDebugFile(debugFilePath, undefined, 'FIRST');
+			this._dumpDebugFile(debugFilePath, 'beforeExecuting', beforeExecutingOptions, runInInteractiveMode);
+			const beforeExecutingOutput = await commandUserExtension.beforeExecuting(beforeExecutingOptions);
+			const overriddenArguments = beforeExecutingOutput.arguments;
+
+			// do not allow this argument to be overwritten (i.e. change it back)
+			if (Reflect.has(commandArgumentsWithDefaultContext, 'project'))
+				overriddenArguments.project = commandArgumentsWithDefaultContext.project;
+
+			// update the authid as well (not recommended but possible) -- should this be in the isSetupRequired check?
+			// EXPERIMENTAL: ALLOW UPDATE OF THE AUTHID AT THIS TIME
+			if (commandMetadata.isSetupRequired)
+				authId = beforeExecutingOutput?.arguments?.authid || authId;
+
+			if (commandMetadata.isSetupRequired && !context.arguments[AUTHORIZATION_PROPERTIES_KEYS.SKIP_AUHTORIZATION_CHECK]) {
+				// check if reauthz is needed to show proper message before continuing with the execution
+				// check after the beforeExecute() has been performed because for instance some unit-test failed and we won't continue the execution
+				await this._refreshAuthorizationIfNeeded(authId);
+			}
+			// AT THIS POINT THE AUTHID IS NOW LOCKED IN SO WE CAN UPDATE THE (TEMP) ENVIRONMENT AGAIN
+			process.env[ENV_VARS.SUITECLOUD_AUTHID] = authId;
+
+			// command creation
+			// src/commands/{noun}/{verb}/{verb}{noun}Command.js => specific implementation creation for a given command
+			const command = this._getCommand(runInInteractiveMode, projectPath, commandMetadata, authId);
+
+			// command execution
+			// src/commands/Command.js, run(inputParams) => execution flow for all commands
+			const actionResult = await command.run(overriddenArguments);
+
+			if (context.runInInteractiveMode) {
+				// generate non-interactive equivalent
+				const notInteractiveCommand = ActionResultUtils.extractNotInteractiveCommand(commandName, commandMetadata, actionResult);
+				this._log.info(NodeTranslationService.getMessage(CLI.SHOW_NOT_INTERACTIVE_COMMAND_MESSAGE, notInteractiveCommand));
+			}
+
+			if (actionResult.isSuccess() && commandUserExtension.onCompleted) {
+				// run onCompleted(output) from suitecloud.config.js
+				this._dumpDebugFile(debugFilePath, 'onCompleted', actionResult, runInInteractiveMode);
+				commandUserExtension.onCompleted(actionResult);
+			} else if (!actionResult.isSuccess() && commandUserExtension.onError) {
+				// run onError(error) from suitecloud.config.js
+				const errorData = ActionResultUtils.getErrorMessagesString(actionResult);
+				this._dumpDebugFile(debugFilePath, 'onError', errorData, runInInteractiveMode);
+				commandUserExtension.onError(errorData);
+			}
+			return actionResult;
+
+		} catch (error) {
+			let errorMessage = this._logGenericError(error);
+			if (commandUserExtension && commandUserExtension.onError) {
+				// run onError(error) from suitecloud.config.js
+				this._dumpDebugFile(debugFilePath, 'onError', error, context.runInInteractiveMode);
+				commandUserExtension.onError(error);
+			}
+			return ActionResult.Builder.withErrors(Array.isArray(errorMessage) ? errorMessage : [errorMessage]).build();
+		}
+	}
+
+	async _refreshAuthorizationIfNeeded(defaultAuthId) {
+		const inspectAuthzOperationResult = await checkIfReauthorizationIsNeeded(defaultAuthId, this._sdkPath, this._executionEnvironmentContext);
+
+		if (!inspectAuthzOperationResult.isSuccess()) {
+			throw inspectAuthzOperationResult.errorMessages;
+		}
+		const inspectAuthzData = inspectAuthzOperationResult.data;
+		if (inspectAuthzData[AUTHORIZATION_PROPERTIES_KEYS.NEEDS_REAUTHORIZATION]) {
+			await this._log.info(NodeTranslationService.getMessage(COMMAND_REFRESH_AUTHORIZATION.MESSAGES.CREDENTIALS_NEED_TO_BE_REFRESHED, defaultAuthId));
+			const refreshAuthzOperationResult = await refreshAuthorization(defaultAuthId, this._sdkPath, this._executionEnvironmentContext);
+
+			if (!refreshAuthzOperationResult.isSuccess()) {
+				throw refreshAuthzOperationResult.errorMessages;
+			}
+			await this._log.info(NodeTranslationService.getMessage(COMMAND_REFRESH_AUTHORIZATION.MESSAGES.AUTHORIZATION_REFRESH_COMPLETED));
+		}
+	}
+
+	_logGenericError(error) {
+		let errorMessage = unwrapExceptionMessage(error);
+		this._log.error(errorMessage);
+		const informativeMessage = unwrapInformationMessage(error);
+
+		if (informativeMessage) {
+			this._log.info(`${lineBreak}${informativeMessage}`);
+			errorMessage += lineBreak + informativeMessage;
+		}
+		return errorMessage;
+	}
+
+	_checkCanExecuteCommand({ commandMetadata, defaultAuthId, runInInteractiveMode }) {
+		if (commandMetadata.isSetupRequired && !defaultAuthId) {
+			throw NodeTranslationService.getMessage(ERRORS.SETUP_REQUIRED);
+		}
+		if (runInInteractiveMode && !commandMetadata.supportsInteractiveMode) {
+			throw NodeTranslationService.getMessage(ERRORS.COMMAND_DOES_NOT_SUPPORT_INTERACTIVE_MODE, commandMetadata.name);
+		}
+	}
+
+	_extractOptionValuesFromArguments(options, args) {
+		const optionValues = {};
+		for (const optionId in options) {
+			if (options.hasOwnProperty(optionId) && args.hasOwnProperty(optionId)) {
+				optionValues[optionId] = args[optionId];
+			}
+		}
+
+		return optionValues;
+	}
+
+	/**
+	 *
+	 * @param runInInteractiveMode
+	 * @param projectFolder
+	 * @param commandMetadata
+	 * @param {string} authId
+	 * @returns {import('../commands/Command')}
+	 * @private
+	 */
+	_getCommand(runInInteractiveMode, projectFolder, commandMetadata, authId) {
+		const commandPath = commandMetadata.generator;
+		const commandGenerator = require(commandPath);
+		if (!commandGenerator) {
+			throw `Path ${commandPath} doesn't contain any command`;
+		}
+		return commandGenerator.create({
+			authId: authId,
+			commandMetadata: commandMetadata,
+			projectFolder: projectFolder,
+			executionPath: this._executionPath,
+			runInInteractiveMode: runInInteractiveMode,
+			log: this._log,
+			sdkPath: this._sdkPath,
+			executionEnvironmentContext: this._executionEnvironmentContext,
+		});
+	}
+
+	/**
+	 * Assign default context params IF they apply
+	 */
+	_applyDefaultContextParams(args, any, meta) {
+		return Object.keys(any)
+			.filter((k1) => Object.keys(meta).includes(k1))
+			.reduce((args, filteredKey) => {
+				return {
+					...args,
+					[filteredKey]: any[filteredKey],
+				};
+			}, args);
+	}
+
+	_getDebugFilePath(debugDir, commandName) {
+		if (!debugDir) return null;
+		const sanitizedCommandName = commandName.replace(/:/g, '-');
+		const datetime = new Date().toISOString().replace(/[:.]/g, '-');
+		const filename = `${sanitizedCommandName}.${datetime}.json`;
+		return path.join(debugDir, filename);
+	}
+
+	/**
+	 *
+	 * @param debugFilePath
+	 * @param hookName
+	 * @param {'FIRST'|'LAST'|*} data
+	 * @param {boolean} runInInteractiveMode
+	 * @private
+	 */
+	_dumpDebugFile(debugFilePath, hookName, data, runInInteractiveMode = false) {
+		if (!debugFilePath || !data ) return;
+		if (data === 'FIRST') {
+			fs.writeFileSync(debugFilePath, '[]');
+			return;
+		}
+
+		const envVars = {};
+		Object.keys(process.env)
+			.filter(key => key.startsWith('SUITECLOUD_'))
+			.forEach(key => { envVars[key] = process.env[key]; });
+		const entry = {
+			hook: hookName,
+			timestamp: new Date().toISOString(),
+			env: envVars,
+			data: data
+		};
+
+		// Print to console in interactive mode
+		if (runInInteractiveMode) {
+			this._log.info(`\n--- DEBUG [${hookName}] ---`);
+			this._log.info(JSON.stringify(entry, null, 2));
+		}
+
+		let entries = [];
+		try {
+			const contents = fs.readFileSync(debugFilePath, 'utf8');
+			entries = JSON.parse(contents);
+		} catch (e) {
+			// If file doesn't exist or can't be parsed, start with empty array
+		}
+		entries.push(entry);
+		fs.writeFileSync(debugFilePath, JSON.stringify(entries, null, 2));
+	}
+};

package/src/core/CommandAuthentication.js

@@ -0,0 +1,13 @@
+/*
+** 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 CommandAuthentication {
+
+};