@suitegeezus/suitecloud-cli 3.1.4

package/src/commands/account/manageauth/ManageAccountAction.js

@@ -0,0 +1,126 @@
+/*
+ ** 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 BaseAction = require('../../base/BaseAction');
+const SdkExecutionContext = require('../../../SdkExecutionContext');
+const { executeWithSpinner } = require('../../../ui/CliSpinner');
+const SdkOperationResultUtils = require('../../../utils/SdkOperationResultUtils');
+const CommandUtils = require('../../../utils/CommandUtils');
+const NodeTranslationService = require('../../../services/NodeTranslationService');
+const { ManageAccountActionResult, MANAGE_ACTION } = require('../../../services/actionresult/ManageAccountActionResult');
+const { throwValidationException } = require('../../../utils/ExceptionUtils');
+const {
+	COMMAND_MANAGE_ACCOUNT: { MESSAGES, ERRORS },
+} = require('../../../services/TranslationKeys');
+
+const COMMAND = {
+	OPTIONS: {
+		INFO: 'info',
+		LIST: 'list',
+		REMOVE: 'remove',
+		RENAME: 'rename',
+		RENAMETO: 'renameto',
+	},
+	FLAGS: {
+		NO_PREVIEW: 'no_preview',
+		SKIP_WARNING: 'skip_warning',
+		VALIDATE: 'validate',
+	},
+};
+
+const DATA_PROPERTIES = {
+	INFO: 'info',
+	ACCOUNT_INFO: 'accountInfo',
+	HOST_INFO: 'hostInfo',
+};
+
+const DOMAIN = 'domain';
+
+module.exports = class ManageAccountAction extends BaseAction {
+	constructor(options) {
+		super(options);
+	}
+
+	async execute(params) {
+		const sdkParams = CommandUtils.extractCommandOptions(params, this._commandMetadata);
+
+		const flags = [];
+		if (params[COMMAND.OPTIONS.LIST]) {
+			flags.push(COMMAND.OPTIONS.LIST);
+			delete sdkParams[COMMAND.OPTIONS.LIST];
+		}
+
+		const executionContext = SdkExecutionContext.Builder.forCommand(this._commandMetadata.sdkCommand)
+			.integration()
+			.addParams(sdkParams)
+			.addFlags(flags)
+			.build();
+
+		const selectedOptions = this._extractSelectedOptions(params);
+		const message = this._getSpinnerMessage(selectedOptions);
+		const operationResult = await executeWithSpinner({
+			action: this._sdkExecutor.execute(executionContext),
+			message: message,
+		});
+		return operationResult.status === SdkOperationResultUtils.STATUS.SUCCESS
+			? ManageAccountActionResult.Builder.withData(this._prepareData(selectedOptions, operationResult.data))
+					.withResultMessage(operationResult.resultMessage)
+					.withExecutedAction(selectedOptions.action)
+					.withCommandParameters(sdkParams)
+					.build()
+			: ManageAccountActionResult.Builder.withErrors(operationResult.errorMessages).withCommandParameters(sdkParams).build();
+	}
+
+	_extractSelectedOptions(answers) {
+		let action;
+		let authId;
+		if (answers.hasOwnProperty(COMMAND.OPTIONS.INFO)) {
+			action = MANAGE_ACTION.INFO;
+			authId = answers[COMMAND.OPTIONS.INFO];
+		} else if (answers.hasOwnProperty(COMMAND.OPTIONS.LIST)) {
+			action = MANAGE_ACTION.LIST;
+		} else if (answers.hasOwnProperty(COMMAND.OPTIONS.REMOVE)) {
+			action = MANAGE_ACTION.REMOVE;
+			authId = answers[COMMAND.OPTIONS.REMOVE];
+		} else if (answers.hasOwnProperty(COMMAND.OPTIONS.RENAME)) {
+			action = MANAGE_ACTION.RENAME;
+			authId = answers[COMMAND.OPTIONS.RENAME];
+		} else {
+			throwValidationException([NodeTranslationService.getMessage(ERRORS.OPTION_NOT_SPECIFIED)], this._runInInteractiveMode, this._commandMetadata);
+		}
+		return {
+			action: action,
+			...(authId && { authId: authId }),
+		};
+	}
+
+	_getSpinnerMessage(selectedOptions) {
+		switch (selectedOptions.action) {
+			case MANAGE_ACTION.REMOVE:
+				return NodeTranslationService.getMessage(MESSAGES.REMOVING);
+			case MANAGE_ACTION.RENAME:
+				return NodeTranslationService.getMessage(MESSAGES.RENAMING);
+			case MANAGE_ACTION.LIST:
+				return NodeTranslationService.getMessage(MESSAGES.LISTING);
+			case MANAGE_ACTION.INFO:
+				return NodeTranslationService.getMessage(MESSAGES.INFO, selectedOptions.authId);
+		}
+		assert.fail(NodeTranslationService.getMessage(ERRORS.UNKNOWN_ACTION));
+	}
+	_prepareData(selectedOptions, data) {
+		if (selectedOptions.action !== MANAGE_ACTION.INFO) {
+			return data;
+		}
+		assert(selectedOptions.authId);
+		assert(data.hasOwnProperty(DATA_PROPERTIES.ACCOUNT_INFO));
+		let actionResultData = { authId: selectedOptions.authId, accountInfo: data.accountInfo };
+		if (data.hasOwnProperty(DATA_PROPERTIES.HOST_INFO)) {
+			actionResultData[DOMAIN] = data.hostInfo.hostName;
+		}
+		return actionResultData;
+	}
+};

package/src/commands/account/manageauth/ManageAccountCommand.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 ManageAccountAction = require('./ManageAccountAction');
+const ManageAccountInputHandler = require('./ManageAccountInputHandler');
+const ManageAccountOutputHandler = require('./ManageAccountOutputHandler');
+
+module.exports = {
+	create(options) {
+		return Command.Builder.withOptions(options)
+			.withAction(ManageAccountAction)
+			.withInput(ManageAccountInputHandler)
+			.withOutput(ManageAccountOutputHandler)
+			.build();
+	}
+};

package/src/commands/account/manageauth/ManageAccountInputHandler.js

@@ -0,0 +1,215 @@
+/*
+ ** 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 BaseInputHandler = require('../../base/BaseInputHandler');
+const CommandUtils = require('../../../utils/CommandUtils');
+const NodeTranslationService = require('../../../services/NodeTranslationService');
+const AccountCredentialsFormatter = require('../../../utils/AccountCredentialsFormatter');
+const { getAuthIds } = require('../../../utils/AuthenticationUtils');
+const { MANAGE_ACTION } = require('../../../services/actionresult/ManageAccountActionResult');
+const { DOMAIN } = require('../../../ApplicationConstants');
+const { default : { prompt, Separator } } = require('inquirer');
+const {
+	showValidationResults,
+	validateAuthIDNotInList,
+	validateAlphanumericHyphenUnderscore,
+	validateFieldHasNoSpaces,
+	validateFieldIsNotEmpty,
+	validateMaximumLength,
+	validateSameAuthID,
+} = require('../../../validation/InteractiveAnswersValidator');
+
+const {
+	COMMAND_MANAGE_ACCOUNT: { QUESTIONS, QUESTIONS_CHOICES, MESSAGES, ERRORS },
+	YES,
+	NO,
+} = require('../../../services/TranslationKeys');
+
+const COMMAND = {
+	OPTIONS: {
+		INFO: 'info',
+		LIST: 'list',
+		REMOVE: 'remove',
+		RENAME: 'rename',
+		RENAMETO: 'renameto',
+	},
+};
+
+const ANSWERS_NAMES = {
+	SELECTED_AUTH_ID: 'selected_auth_id',
+	ACTION: 'action',
+	AUTHID: 'authId',
+	RENAMETO: 'renameto',
+	REMOVE: 'remove',
+};
+
+module.exports = class ManageAccountInputHandler extends BaseInputHandler {
+	constructor(options) {
+		super(options);
+	}
+
+	async getParameters(params) {
+		if (!this._runInInteractiveMode) {
+			return params;
+		}
+		let answers = await this.getAuthId(params)
+		this._log.info(AccountCredentialsFormatter.getInfoString(answers[ANSWERS_NAMES.SELECTED_AUTH_ID]));
+		const selectedAuthID = answers[ANSWERS_NAMES.SELECTED_AUTH_ID].authId;
+		answers[ANSWERS_NAMES.ACTION] = await this._selectAction(prompt);
+		if (answers[ANSWERS_NAMES.ACTION] === MANAGE_ACTION.RENAME) {
+			answers[ANSWERS_NAMES.RENAMETO] = await this._introduceNewName(prompt, authIDActionResult.data, selectedAuthID);
+		} else if (answers[ANSWERS_NAMES.ACTION] === MANAGE_ACTION.REMOVE) {
+			answers[ANSWERS_NAMES.REMOVE] = await this._confirmRemove(prompt);
+		}
+
+		return this._extractAnswers(answers);
+	}
+
+	async getAuthId(params){
+		if (!this._runInInteractiveMode) {
+			return params;
+		}
+
+		const authIDActionResult = await getAuthIds(this._sdkPath);
+		if (!authIDActionResult.isSuccess()) {
+			throw authIDActionResult.errorMessages;
+		}
+		return await this._selectAuthID(authIDActionResult.data, prompt);
+	}
+
+	_logAccountInfo(selectedAuthId) {
+		const accountInfo = selectedAuthId.accountInfo;
+		this._log.info(NodeTranslationService.getMessage(MESSAGES.ACCOUNT_INFO.AUTHID, selectedAuthId.authId));
+		this._log.info(NodeTranslationService.getMessage(MESSAGES.ACCOUNT_INFO.ACCOUNT_NAME, accountInfo.companyName));
+		this._log.info(NodeTranslationService.getMessage(MESSAGES.ACCOUNT_INFO.ACCOUNT_ID, accountInfo.companyId));
+		this._log.info(NodeTranslationService.getMessage(MESSAGES.ACCOUNT_INFO.ROLE, accountInfo.roleName));
+		this._log.info(NodeTranslationService.getMessage(MESSAGES.ACCOUNT_INFO.DOMAIN, accountInfo.roleName));
+		this._log.info(NodeTranslationService.getMessage(MESSAGES.ACCOUNT_INFO.ACCOUNT_TYPE, accountInfo.roleName));
+	}
+
+	_accountCredentialToString(authID, accountCredential) {
+		const urlInfo =
+			accountCredential.hostInfo.hostName &&
+			!accountCredential.hostInfo.hostName.match(DOMAIN.PRODUCTION.PRODUCTION_DOMAIN_REGEX) &&
+			!accountCredential.hostInfo.hostName.match(DOMAIN.PRODUCTION.PRODUCTION_ACCOUNT_SPECIFIC_DOMAIN_REGEX)
+				? NodeTranslationService.getMessage(QUESTIONS_CHOICES.SELECT_AUTHID.EXISTING_AUTH_ID_URL_NOT_PRODUCTION, accountCredential.hostInfo.hostName)
+				: '';
+		const accountInfo = `${accountCredential.accountInfo.roleName} @ ${accountCredential.accountInfo.companyName}`;
+		return NodeTranslationService.getMessage(
+			QUESTIONS_CHOICES.SELECT_AUTHID.EXISTING_AUTH_ID,
+			authID,
+			accountInfo,
+			urlInfo
+		);
+	}
+
+	async _selectAuthID(authIDList, prompt) {
+		var authIDs = Object.entries(authIDList).sort();
+		if (authIDs.length <= 0) {
+			throw NodeTranslationService.getMessage(ERRORS.CREDENTIALS_EMPTY);
+		}
+		const choices = [];
+		authIDs.forEach((authIDArray) => {
+			const authID = authIDArray[0];
+			const accountCredential = authIDArray[1];
+			const accountCredentialString = this._accountCredentialToString(authID, accountCredential);
+			choices.push({
+				name: accountCredentialString,
+				value: { authId: authID, accountInfo: accountCredential.accountInfo, domain: accountCredential.hostInfo.hostName },
+			});
+		});
+		choices.push(new Separator());
+		return await prompt([
+			{
+				type: CommandUtils.INQUIRER_TYPES.LIST,
+				name: ANSWERS_NAMES.SELECTED_AUTH_ID,
+				message: NodeTranslationService.getMessage(QUESTIONS.SELECT_CREDENTIALS),
+				choices: choices,
+			},
+		]);
+	}
+
+	async _selectAction(prompt) {
+		let answer = await prompt({
+			type: CommandUtils.INQUIRER_TYPES.LIST,
+			name: ANSWERS_NAMES.ACTION,
+			message: NodeTranslationService.getMessage(QUESTIONS.SELECT_ACTION),
+			choices: [
+				{
+					name: NodeTranslationService.getMessage(QUESTIONS_CHOICES.ACTIONS.RENAME),
+					value: MANAGE_ACTION.RENAME,
+				},
+				{
+					name: NodeTranslationService.getMessage(QUESTIONS_CHOICES.ACTIONS.REMOVE),
+					value: MANAGE_ACTION.REMOVE,
+				},
+				{
+					name: NodeTranslationService.getMessage(QUESTIONS_CHOICES.ACTIONS.EXIT),
+					value: MANAGE_ACTION.EXIT,
+				},
+			],
+		});
+
+		if (answer[ANSWERS_NAMES.ACTION] === MANAGE_ACTION.EXIT) {
+			throw NodeTranslationService.getMessage(MESSAGES.CANCEL);
+		}
+
+		return answer[ANSWERS_NAMES.ACTION];
+	}
+
+	async _introduceNewName(prompt, authIDMap, originalAuthId) {
+		let answer = await prompt({
+			type: CommandUtils.INQUIRER_TYPES.INPUT,
+			name: ANSWERS_NAMES.RENAMETO,
+			message: NodeTranslationService.getMessage(QUESTIONS.NEW_NAME),
+			filter: (fieldValue) => fieldValue.trim(),
+			//fieldValue needs the trim because filter is executed AFTER validate
+			validate: (fieldValue) =>
+				showValidationResults(
+					fieldValue.trim(),
+					validateFieldIsNotEmpty,
+					validateFieldHasNoSpaces,
+					(fieldValue) => validateSameAuthID(fieldValue.trim(), originalAuthId),
+					(fieldValue) => validateAuthIDNotInList(fieldValue.trim(), Object.keys(authIDMap)),
+					validateAlphanumericHyphenUnderscore,
+					validateMaximumLength
+				),
+		});
+		return answer[ANSWERS_NAMES.RENAMETO];
+	}
+
+	async _confirmRemove(prompt) {
+		let answer = await prompt([
+			{
+				type: CommandUtils.INQUIRER_TYPES.LIST,
+				name: ANSWERS_NAMES.REMOVE,
+				message: NodeTranslationService.getMessage(QUESTIONS.VERIFY_REMOVE),
+				default: false,
+				choices: [
+					{ name: NodeTranslationService.getMessage(YES), value: true },
+					{ name: NodeTranslationService.getMessage(NO), value: false },
+				],
+			},
+		]);
+		if (!answer[ANSWERS_NAMES.REMOVE]) {
+			throw NodeTranslationService.getMessage(MESSAGES.CANCEL);
+		}
+		return answer[ANSWERS_NAMES.REMOVE];
+	}
+
+	_extractAnswers(answers) {
+		if (answers[ANSWERS_NAMES.ACTION] === MANAGE_ACTION.RENAME) {
+			return {
+				[COMMAND.OPTIONS.RENAME]: answers[ANSWERS_NAMES.SELECTED_AUTH_ID].authId,
+				[COMMAND.OPTIONS.RENAMETO]: answers[ANSWERS_NAMES.RENAMETO],
+			};
+		} else if (answers[ANSWERS_NAMES.ACTION] === MANAGE_ACTION.REMOVE) {
+			return {
+				[COMMAND.OPTIONS.REMOVE]: answers[ANSWERS_NAMES.SELECTED_AUTH_ID].authId,
+			};
+		}
+	}
+};

package/src/commands/account/manageauth/ManageAccountOutputHandler.js

@@ -0,0 +1,30 @@
+/*
+ ** 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 ActionResultUtils = require('../../../utils/ActionResultUtils');
+const AccountCredentialsFormatter = require('../../../utils/AccountCredentialsFormatter');
+const { MANAGE_ACTION } = require('../../../services/actionresult/ManageAccountActionResult');
+
+module.exports = class ManageAccountOutputFormatter extends BaseOutputHandler {
+	constructor(consoleLogger) {
+		super(consoleLogger);
+	}
+
+	parse(actionResult) {
+		if (actionResult.resultMessage) {
+			ActionResultUtils.logResultMessage(actionResult, this._log);
+		}
+
+		if (actionResult.actionExecuted === MANAGE_ACTION.INFO) {
+			this._log.result(AccountCredentialsFormatter.getInfoString(actionResult.data));
+		} else if (actionResult.actionExecuted === MANAGE_ACTION.LIST) {
+			Object.keys(actionResult.data).forEach((authId) =>
+				this._log.result(AccountCredentialsFormatter.getListItemString(authId, actionResult.data[authId]))
+			);
+		}
+		return actionResult;
+	}
+};

package/src/commands/account/setup/SetupAction.js

@@ -0,0 +1,39 @@
+/*
+ ** 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 AuthenticateActionResult = require('../../../services/actionresult/AuthenticateActionResult');
+const { setDefaultAuthentication, authenticateWithOauth } = require('../../../utils/AuthenticationUtils');
+
+const AUTH_MODE = {
+	OAUTH: 'OAUTH',
+	REUSE: 'REUSE',
+};
+
+module.exports = class SetupAction extends BaseAction {
+	constructor(options) {
+		super(options);
+	}
+
+	async execute(params) {
+		try {
+			if (params.mode === AUTH_MODE.OAUTH) {
+				return await authenticateWithOauth(params, this._sdkPath, this._executionPath, this._executionEnvironmentContext);
+			} else if (params.mode === AUTH_MODE.REUSE) {
+				const authId = params.authentication.authId;
+				const accountInfo = params.authentication.accountInfo;
+				setDefaultAuthentication(this._executionPath, authId);
+				return AuthenticateActionResult.Builder.success()
+					.withMode(AUTH_MODE.REUSE)
+					.withAuthId(authId)
+					.withAccountInfo(accountInfo)
+					.build();
+			}
+		} catch (error) {
+			return AuthenticateActionResult.Builder.withErrors([error]).build();
+		}
+	}
+};

package/src/commands/account/setup/SetupCommand.js

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

package/src/commands/account/setup/SetupInputHandler.js

@@ -0,0 +1,169 @@
+/*
+ ** 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 loadLoggerFontFormatter = async () => {
+	const { COLORS, BOLD } = await import('../../../loggers/LoggerFontFormatter.mjs');
+	return { COLORS, BOLD };
+};
+const fontFormatterPromise = loadLoggerFontFormatter();
+const { default : { prompt, Separator } } = require('inquirer');
+const BaseInputHandler = require('../../base/BaseInputHandler');
+const CommandUtils = require('../../../utils/CommandUtils');
+const NodeTranslationService = require('../../../services/NodeTranslationService');
+const { getAuthIds } = require('../../../utils/AuthenticationUtils');
+const { validateBrowserBasedAuthIsAllowed } = require('../../../services/ExecutionContextService');
+const {
+	DOMAIN
+} = require('../../../ApplicationConstants');
+const ProjectInfoService = require('../../../services/ProjectInfoService');
+
+const {
+	COMMAND_SETUPACCOUNT: { QUESTIONS, QUESTIONS_CHOICES, MESSAGES }
+} = require('../../../services/TranslationKeys');
+
+const {
+	validateFieldHasNoSpaces,
+	validateFieldIsNotEmpty,
+	validateAuthIDNotInList,
+	validateAlphanumericHyphenUnderscore,
+	validateMaximumLength,
+	showValidationResults,
+} = require('../../../validation/InteractiveAnswersValidator');
+
+const ANSWERS = {
+	SELECTED_AUTH_ID: 'selected_auth_id',
+	AUTH_MODE: 'AUTH_MODE',
+	NEW_AUTH_ID: 'NEW_AUTH_ID',
+	URL: 'url',
+};
+
+const AUTH_MODE = {
+	OAUTH: 'OAUTH',
+	REUSE: 'REUSE',
+};
+
+const CREATE_NEW_AUTH = '******CREATE_NEW_AUTH*******!£$%&*';
+
+module.exports = class SetupInputHandler extends BaseInputHandler {
+	constructor(options) {
+		super(options);
+		this._projectInfoService = new ProjectInfoService(this._projectFolder);
+	}
+
+	async getParameters(params) {
+		this._projectInfoService.checkWorkingDirectoryContainsValidProject(this._commandMetadata.name);
+		validateBrowserBasedAuthIsAllowed();
+		const authIDActionResult = await getAuthIds(this._sdkPath);
+		if (!authIDActionResult.isSuccess()) {
+			throw authIDActionResult.errorMessages;
+		}
+		const selectedAuth = await this.selectAuthIdOption(authIDActionResult);
+
+		if (selectedAuth !== CREATE_NEW_AUTH) {
+			return {
+				createNewAuthentication: false,
+				authentication: selectedAuth,
+				mode: AUTH_MODE.REUSE,
+			};
+		}
+
+		// creating a new authID
+		return await this.getParamsCreateNewAuthId(params, authIDActionResult);
+	}
+
+	async selectAuthIdOption(authIDActionResult) {
+		const choices = [];
+		let authIdAnswer;
+		let authIDs = Object.keys(authIDActionResult.data);
+		if (authIDs.length > 0) {
+		choices.push({
+				name: (await fontFormatterPromise).BOLD(NodeTranslationService.getMessage(QUESTIONS_CHOICES.SELECT_AUTHID.NEW_AUTH_ID)),
+				value: CREATE_NEW_AUTH,
+			});
+			choices.push(new Separator());
+			choices.push(new Separator(NodeTranslationService.getMessage(MESSAGES.SELECT_CONFIGURED_AUTHID)));
+			authIDs.forEach((authID) => {
+				const accountCredentials = authIDActionResult.data[authID];
+				// just fixed the isNotProductionUrl because of new credentials format, but the previous version was always false
+				// TODO: review if we want to show non-production urls on the list of selectable authIds
+				const isNotProductionUrl =
+					accountCredentials.hostInfo &&
+					accountCredentials.hostInfo.hostName &&
+					!accountCredentials.hostInfo.hostName.match(DOMAIN.PRODUCTION.PRODUCTION_DOMAIN_REGEX) &&
+					!accountCredentials.hostInfo.hostName.match(DOMAIN.PRODUCTION.PRODUCTION_ACCOUNT_SPECIFIC_DOMAIN_REGEX);
+				const notProductionLabel = isNotProductionUrl
+					? NodeTranslationService.getMessage(
+						QUESTIONS_CHOICES.SELECT_AUTHID.EXISTING_AUTH_ID_URL_NOT_PRODUCTION,
+						accountCredentials.hostInfo.hostName
+					)
+					: '';
+				const accountInfo = `${accountCredentials.accountInfo.companyName} [${accountCredentials.accountInfo.roleName}]`;
+				choices.push({
+					name: NodeTranslationService.getMessage(
+						QUESTIONS_CHOICES.SELECT_AUTHID.EXISTING_AUTH_ID,
+						authID,
+						accountInfo,
+						notProductionLabel
+					),
+					value: { authId: authID, accountInfo: accountCredentials.accountInfo },
+				});
+			});
+			choices.push(new Separator());
+			authIdAnswer = await prompt([
+				{
+					type: CommandUtils.INQUIRER_TYPES.LIST,
+					name: ANSWERS.SELECTED_AUTH_ID,
+					message: NodeTranslationService.getMessage(QUESTIONS.SELECT_AUTHID),
+					choices: choices,
+				},
+			]);
+		} else {
+			// There was no previous authIDs
+			authIdAnswer = {
+				[ANSWERS.SELECTED_AUTH_ID]: CREATE_NEW_AUTH,
+			};
+		}
+		return authIdAnswer[ANSWERS.SELECTED_AUTH_ID];
+	}
+
+	async getParamsCreateNewAuthId(params, authIDActionResult) {
+		const newAuthenticationAnswers = await prompt([
+			{
+				when: params && params.dev !== undefined && params.dev,
+				type: CommandUtils.INQUIRER_TYPES.INPUT,
+				name: ANSWERS.URL,
+				message: NodeTranslationService.getMessage(QUESTIONS.URL),
+				filter: (fieldValue) => fieldValue.trim(),
+				validate: (fieldValue) => showValidationResults(fieldValue.trim(), validateFieldIsNotEmpty, validateFieldHasNoSpaces),
+
+			},
+			{
+				type: CommandUtils.INQUIRER_TYPES.INPUT,
+				name: ANSWERS.NEW_AUTH_ID,
+				message: NodeTranslationService.getMessage(QUESTIONS.NEW_AUTH_ID),
+				filter: (answer) => answer.trim(),
+				validate: (fieldValue) =>
+					showValidationResults(
+						fieldValue.trim(),
+						validateFieldIsNotEmpty,
+						validateFieldHasNoSpaces,
+						(fieldValue) => validateAuthIDNotInList(fieldValue.trim(), Object.keys(authIDActionResult.data)),
+						validateAlphanumericHyphenUnderscore,
+						validateMaximumLength
+					),
+			},
+		]);
+
+		const executeActionContext = {
+			createNewAuthentication: true,
+			authid: newAuthenticationAnswers[ANSWERS.NEW_AUTH_ID],
+			mode: AUTH_MODE.OAUTH,
+			...(newAuthenticationAnswers[ANSWERS.URL] && { url: newAuthenticationAnswers[ANSWERS.URL] })
+		};
+
+		return executeActionContext;
+	}
+};

package/src/commands/account/setup/SetupOutputHandler.js

@@ -0,0 +1,65 @@
+/*
+ ** 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 {
+	COMMAND_SETUPACCOUNT: { MESSAGES, OUTPUT },
+	UTILS: { AUTHENTICATION },
+} = require('../../../services/TranslationKeys');
+
+const {
+	LINKS: {
+		ERRORS: {
+			AUTHENTICATION_FALLBACK_INFO,
+		},
+	}
+} = require('../../../ApplicationConstants');
+
+const AUTH_MODE = {
+	OAUTH: 'OAUTH',
+	SAVE_TOKEN: 'SAVE_TOKEN',
+	REUSE: 'REUSE',
+};
+
+module.exports = class SetupOutputHandler extends BaseOutputHandler {
+	constructor(options) {
+		super(options);
+	}
+
+	parse(actionResult) {
+		let resultMessage;
+		switch (actionResult.mode) {
+			case AUTH_MODE.OAUTH:
+				resultMessage = NodeTranslationService.getMessage(
+					OUTPUT.NEW_OAUTH,
+					actionResult.accountInfo.companyName,
+					actionResult.accountInfo.roleName,
+					actionResult.authId
+				);
+				break;
+			case AUTH_MODE.REUSE:
+				resultMessage = NodeTranslationService.getMessage(
+					OUTPUT.REUSED_AUTH_ID,
+					actionResult.authId,
+					actionResult.accountInfo.companyName,
+					actionResult.accountInfo.roleName
+				);
+				break;
+			default:
+				break;
+		}
+
+		this._log.result(resultMessage);
+		this._log.result(NodeTranslationService.getMessage(AUTHENTICATION.SUCCESS_SETUP));
+
+		if (actionResult.isSuccess() && process.env.SUITECLOUD_FALLBACK_PASSKEY) {
+			this._log.warning(NodeTranslationService.getMessage(MESSAGES.ROTATE_PASSWORD_WARNING, AUTHENTICATION_FALLBACK_INFO));
+		}
+
+		return actionResult;
+	}
+};