@suitegeezus/suitecloud-cli 3.1.4

package/src/commands/file/create/CreateFileAction.js

@@ -0,0 +1,89 @@
+/*
+ ** 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 { executeWithSpinner } = require('../../../ui/CliSpinner');
+const { ActionResult } = require('../../../services/actionresult/ActionResult');
+const { FOLDERS } = require('../../../ApplicationConstants');
+const BaseAction = require('../../base/BaseAction');
+const CommandUtils = require('../../../utils/CommandUtils');
+const NodeTranslationService = require('../../../services/NodeTranslationService');
+const SdkExecutionContext = require('../../../SdkExecutionContext');
+const SdkOperationResultUtils = require('../../../utils/SdkOperationResultUtils');
+
+const {
+	COMMAND_CREATEFILE: { MESSAGES },
+} = require('../../../services/TranslationKeys');
+
+const COMMAND_OPTIONS = {
+	MODULE: 'module',
+	PATH: 'path',
+	PROJECT: 'project',
+	TYPE: 'type',
+};
+const JS_EXTENSION = '.js';
+
+module.exports = class CreateFileAction extends BaseAction {
+	preExecute(params) {
+		params[COMMAND_OPTIONS.PROJECT] = CommandUtils.quoteString(this._projectFolder);
+
+		if (this._runInInteractiveMode) {
+			params[COMMAND_OPTIONS.PATH] = params.parentPath + params.name;
+		}
+		if (params.hasOwnProperty(COMMAND_OPTIONS.PATH)) {
+			if (!params[COMMAND_OPTIONS.PATH].endsWith(JS_EXTENSION)) {
+				params[COMMAND_OPTIONS.PATH] = params[COMMAND_OPTIONS.PATH] + JS_EXTENSION;
+			}
+			params[COMMAND_OPTIONS.PATH] = CommandUtils.quoteString(params[COMMAND_OPTIONS.PATH]);
+		}
+
+		if (params.hasOwnProperty(COMMAND_OPTIONS.MODULE)) {
+			if (Array.isArray(params[COMMAND_OPTIONS.MODULE])) {
+				params[COMMAND_OPTIONS.MODULE] = params[COMMAND_OPTIONS.MODULE].map(CommandUtils.quoteString).join(' ');
+			} else {
+				params[COMMAND_OPTIONS.MODULE] = CommandUtils.quoteString(params[COMMAND_OPTIONS.MODULE]);
+			}
+		}
+
+		delete params.parentPath;
+		delete params.name;
+
+		return params;
+	}
+
+	async execute(params) {
+		const executionContextCreateFile = SdkExecutionContext.Builder.forCommand(this._commandMetadata.sdkCommand)
+			.integration()
+			.addParams(params)
+			.build();
+
+		const operationResult = await executeWithSpinner({
+			action: this._sdkExecutor.execute(executionContextCreateFile),
+			message: NodeTranslationService.getMessage(MESSAGES.CREATING_FILE),
+		});
+
+		if (operationResult.status === SdkOperationResultUtils.STATUS.SUCCESS) {
+			const suiteScriptFileAbsolutePath = path.join(
+				this._projectFolder,
+				FOLDERS.FILE_CABINET,
+				CommandUtils.unquoteString(params[COMMAND_OPTIONS.PATH])
+			);
+
+			let resultMessage = NodeTranslationService.getMessage(MESSAGES.SUITESCRIPT_FILE_CREATED, suiteScriptFileAbsolutePath);
+			if (params.hasOwnProperty(COMMAND_OPTIONS.MODULE)) {
+				resultMessage = NodeTranslationService.getMessage(
+					MESSAGES.SUITESCRIPT_FILE_CREATED_WITH_MODULES,
+					suiteScriptFileAbsolutePath,
+					params[COMMAND_OPTIONS.MODULE].split(' ').join(', ')
+				);
+			}
+
+			return ActionResult.Builder.withData(operationResult.data).withResultMessage(resultMessage).withCommandParameters(params).build();
+		} else {
+			return ActionResult.Builder.withErrors(operationResult.errorMessages).withCommandParameters(params).build();
+		}
+	}
+};

package/src/commands/file/create/CreateFileCommand.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 CreateFileAction = require('./CreateFileAction');
+const CreateFileInputHandler = require('./CreateFileInputHandler');
+const CreateFileOutputHandler = require('./CreateFileOutputHandler');
+
+module.exports = {
+    create(options) {
+        return Command.Builder.withOptions(options)
+            .withAction(CreateFileAction)
+            .withInput(CreateFileInputHandler)
+            .withOutput(CreateFileOutputHandler)
+            .build();
+    }
+};

package/src/commands/file/create/CreateFileInputHandler.js

@@ -0,0 +1,175 @@
+/*
+ ** 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, Separator } } = require('inquirer');
+const path = require('path');
+const { FOLDERS } = require('../../../ApplicationConstants');
+const {
+    showValidationResults,
+    validateArrayIsNotEmpty,
+    validateFieldIsNotEmpty,
+    validateSuiteScriptFileDoesNotExist,
+    validateFileName
+} = require('../../../validation/InteractiveAnswersValidator');
+const {
+    COMMAND_CREATEFILE: { QUESTIONS },
+    YES,
+    NO,
+} = require('../../../services/TranslationKeys');
+const ApplicationConstants = require('../../../ApplicationConstants');
+const BaseInputHandler = require('../../base/BaseInputHandler');
+const CommandUtils = require('../../../utils/CommandUtils');
+const FileSystemService = require('../../../services/FileSystemService');
+const FileCabinetService = require('../../../services/FileCabinetService');
+const NodeTranslationService = require('../../../services/NodeTranslationService');
+const ProjectInfoService = require('../../../services/ProjectInfoService');
+const SUITESCRIPT_MODULES = require('../../../metadata/SuiteScriptModulesMetadata');
+const SUITESCRIPT_TYPES = require('../../../metadata/SuiteScriptTypesMetadata');
+
+const ANSWER_NAMES = {
+    ADD_SUITESCRIPT_MODULES: 'addSuiteScriptModules',
+    NAME: 'name',
+    MODULE: 'module',
+    PARENT_PATH: 'parentPath',
+    TYPE: 'type',
+};
+const SUITEAPPS_PATH = '/SuiteApps';
+const SUITESCRIPTS_PATH = '/SuiteScripts';
+const WEB_HOSTING_SUBFOLDER_PATH = '/Web Site Hosting Files/.*/';
+
+module.exports = class CreateFileInputHandler extends BaseInputHandler {
+
+    constructor(options) {
+        super(options);
+
+        this._fileSystemService = new FileSystemService();
+        this._fileCabinetService = new FileCabinetService(path.join(this._projectFolder, FOLDERS.FILE_CABINET));
+        this._projectInfoService = new ProjectInfoService(this._projectFolder);
+
+        this._accountCustomizationProject = this._projectInfoService.isAccountCustomizationProject();
+    }
+
+    async getParameters(params) {
+        const answers = await prompt([
+            this._questionSelectSuiteScriptType(),
+            this._questionAddSuiteScriptModules(),
+            this._questionSelectSuiteScriptModules(),
+            this._questionSelectDestinationFolder(),
+
+        ]);
+
+        const nameAnswer = await prompt(this._questionEnterName(answers[ANSWER_NAMES.PARENT_PATH]));
+        answers[ANSWER_NAMES.NAME] = nameAnswer[ANSWER_NAMES.NAME];
+
+        delete answers[ANSWER_NAMES.ADD_SUITESCRIPT_MODULES];
+
+        return answers;
+    }
+
+    _questionSelectSuiteScriptType() {
+        return {
+            type: CommandUtils.INQUIRER_TYPES.LIST,
+            name: ANSWER_NAMES.TYPE,
+            message: NodeTranslationService.getMessage(QUESTIONS.CHOOSE_SUITESCRIPT_TYPE),
+            pageSize: 15,
+            choices: [
+                ...SUITESCRIPT_TYPES.map(( suiteScriptType) => ({
+                    name: suiteScriptType.name,
+                    value: suiteScriptType.id,
+                })),
+                new Separator(),
+            ],
+        };
+    }
+
+    _questionAddSuiteScriptModules() {
+        return {
+            type: CommandUtils.INQUIRER_TYPES.LIST,
+            name: ANSWER_NAMES.ADD_SUITESCRIPT_MODULES,
+            message: NodeTranslationService.getMessage(QUESTIONS.ADD_SUITESCRIPT_MODULES),
+            default: true,
+            choices: [
+                { name: NodeTranslationService.getMessage(YES), value: true },
+                { name: NodeTranslationService.getMessage(NO), value: false },
+            ],
+        };
+    }
+
+    _questionSelectSuiteScriptModules() {
+        return {
+            when: function(response) {
+                return response[ANSWER_NAMES.ADD_SUITESCRIPT_MODULES];
+            },
+            type: CommandUtils.INQUIRER_TYPES.CHECKBOX,
+            name: ANSWER_NAMES.MODULE,
+            message: NodeTranslationService.getMessage(QUESTIONS.SELECT_SUITESCRIPT_MODULES),
+            pageSize: 15,
+            choices: [
+                ...SUITESCRIPT_MODULES.map((suiteScriptModule) => ({
+                    name: suiteScriptModule.id,
+                    value: suiteScriptModule.id,
+                })),
+                new Separator(),
+            ],
+            validate: (fieldValue) => showValidationResults(fieldValue, validateArrayIsNotEmpty),
+        };
+    }
+
+    _questionSelectDestinationFolder() {
+        return {
+            type: CommandUtils.INQUIRER_TYPES.LIST,
+            name: ANSWER_NAMES.PARENT_PATH,
+            message: NodeTranslationService.getMessage(QUESTIONS.SELECT_FOLDER),
+            pageSize: 15,
+            choices: this._getFolderChoices(),
+        };
+    }
+
+    _questionEnterName(parentRelativePath) {
+        const parentAbsolutePath = path.join(this._projectFolder, ApplicationConstants.FOLDERS.FILE_CABINET, parentRelativePath);
+
+        return {
+            type: CommandUtils.INQUIRER_TYPES.INPUT,
+            name: ANSWER_NAMES.NAME,
+            message: NodeTranslationService.getMessage(QUESTIONS.ENTER_NAME),
+            filter: (fieldValue) => fieldValue.trim(),
+            validate: (fieldValue) => showValidationResults(
+                fieldValue.trim(),
+                validateFieldIsNotEmpty,
+                validateFileName,
+                (fieldValue) => validateSuiteScriptFileDoesNotExist(parentAbsolutePath, fieldValue.trim())
+            ),
+        };
+    }
+
+    _getFolderChoices() {
+        const transformFolderToChoicesObjectFuntion = (folder) => {
+            let folderRestricted;
+
+            const folderRelativePath = this._fileCabinetService.getFileCabinetRelativePath(folder) + '/';
+
+            if (this._accountCustomizationProject) {
+                folderRestricted = !(folderRelativePath.startsWith(SUITESCRIPTS_PATH) || folderRelativePath.match(WEB_HOSTING_SUBFOLDER_PATH));
+            } else {
+                const applicationId = this._projectInfoService.getApplicationId();
+                const applicationSuiteAppFolderAbsolutePath = path.join(this._projectFolder, FOLDERS.FILE_CABINET, SUITEAPPS_PATH, '/', applicationId, '/');
+                const applicationSuiteAppFolderRelativePath = this._fileCabinetService.getFileCabinetRelativePath(applicationSuiteAppFolderAbsolutePath);
+                folderRestricted = !folderRelativePath.startsWith(applicationSuiteAppFolderRelativePath);
+            }
+
+            return {
+                name: FOLDERS.FILE_CABINET + folderRelativePath,
+                value: folderRelativePath,
+                disabled: folderRestricted,
+            };
+        }
+
+        return this._fileSystemService
+            .getFoldersFromDirectoryRecursively(path.join(this._projectFolder, FOLDERS.FILE_CABINET))
+            .map(transformFolderToChoicesObjectFuntion);
+    }
+
+};

package/src/commands/file/create/CreateFileOutputHandler.js

@@ -0,0 +1,22 @@
+/*
+ ** 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 ActionResultUtils = require('../../../utils/ActionResultUtils');
+const BaseOutputHandler = require('../../base/BaseOutputHandler');
+
+module.exports = class CreateProjectOutputHandler extends BaseOutputHandler {
+
+    constructor(options) {
+        super(options);
+    }
+
+    parse(actionResult) {
+        ActionResultUtils.logResultMessage(actionResult, this._log);
+
+        return actionResult;
+    }
+
+};

package/src/commands/file/import/ImportFilesAction.js

@@ -0,0 +1,112 @@
+/*
+ ** 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 { ActionResult } = require('../../../services/actionresult/ActionResult');
+const CommandUtils = require('../../../utils/CommandUtils');
+const NodeTranslationService = require('../../../services/NodeTranslationService');
+const { executeWithSpinner } = require('../../../ui/CliSpinner');
+const SdkOperationResultUtils = require('../../../utils/SdkOperationResultUtils');
+const SdkExecutionContext = require('../../../SdkExecutionContext');
+const ProjectInfoService = require('../../../services/ProjectInfoService');
+const { PROJECT_SUITEAPP } = require('../../../ApplicationConstants');
+const { getProjectDefaultAuthId } = require('../../../utils/AuthenticationUtils');
+const BaseAction = require('../../base/BaseAction');
+const {
+	COMMAND_IMPORTFILES: { ERRORS, MESSAGES, WARNINGS },
+} = require('../../../services/TranslationKeys');
+const CLIException = require('../../../CLIException');
+
+const COMMAND_OPTIONS = {
+	ALLOW_FOR_SUITEAPPS: 'allowforsuiteapps',
+	AUTH_ID: 'authid',
+	CALLED_FROM_COMPARE_FILES: 'calledfromcomparefiles',
+	CALLED_FROM_UPDATE: 'calledfromupdate',
+	FOLDER: 'folder',
+	PATHS: 'paths',
+	EXCLUDE_PROPERTIES: 'excludeproperties',
+	PROJECT: 'project',
+};
+
+module.exports = class ImportFilesAction extends BaseAction {
+	constructor(options) {
+		super(options);
+
+		this._projectInfoService = new ProjectInfoService(this._projectFolder);
+		this._calledFromCompareFiles = false;
+		this._calledFromUpdate = false;
+	}
+
+	preExecute(params) {
+		const { PROJECT, PATHS, EXCLUDE_PROPERTIES, AUTH_ID } = COMMAND_OPTIONS;
+		params[PROJECT] = CommandUtils.quoteString(this._projectFolder);
+		if (params.hasOwnProperty(PATHS)) {
+			if (Array.isArray(params[PATHS])) {
+				params[PATHS] = params[PATHS].map(CommandUtils.quoteString).join(' ');
+			} else {
+				params[PATHS] = CommandUtils.quoteString(params[PATHS]);
+			}
+		}
+		if (params[EXCLUDE_PROPERTIES]) {
+			params[EXCLUDE_PROPERTIES] = '';
+		} else {
+			delete params[EXCLUDE_PROPERTIES];
+		}
+
+		if (params[COMMAND_OPTIONS.CALLED_FROM_COMPARE_FILES]) {
+			this._calledFromCompareFiles = true;
+			delete params[COMMAND_OPTIONS.CALLED_FROM_COMPARE_FILES];
+		}
+		if (params[COMMAND_OPTIONS.CALLED_FROM_UPDATE]) {
+			this._calledFromUpdate = true;
+			delete params[COMMAND_OPTIONS.CALLED_FROM_UPDATE];
+		}
+
+		return params;
+	}
+
+	async execute(params) {
+		try {
+			if (!this._calledFromCompareFiles && this._projectInfoService.getProjectType() === PROJECT_SUITEAPP) {
+				return ActionResult.Builder.withErrors([NodeTranslationService.getMessage(ERRORS.IS_SUITEAPP)]).build();
+			}
+
+			if (!this._calledFromCompareFiles && !this._calledFromUpdate && this._runInInteractiveMode === false) {
+				await this._log.info(NodeTranslationService.getMessage(WARNINGS.OVERRIDE));
+			}
+
+			if (this._calledFromCompareFiles) {
+				params[COMMAND_OPTIONS.ALLOW_FOR_SUITEAPPS] = '';
+			}
+
+			const executionContextImportObjects = SdkExecutionContext.Builder.forCommand(this._commandMetadata.sdkCommand)
+				.integration()
+				.addParams(params)
+				.build();
+
+			const operationResult = await executeWithSpinner({
+				action: this._sdkExecutor.execute(executionContextImportObjects),
+				message:  NodeTranslationService.getMessage(MESSAGES.IMPORTING_FILES),
+			});
+
+			if (this._calledFromCompareFiles) {
+				params[COMMAND_OPTIONS.CALLED_FROM_COMPARE_FILES] = true;
+			}
+			if (this._calledFromUpdate) {
+				params[COMMAND_OPTIONS.CALLED_FROM_UPDATE] = true;
+			}
+
+			return operationResult.status === SdkOperationResultUtils.STATUS.SUCCESS
+				? ActionResult.Builder.withData(operationResult.data)
+						.withResultMessage(operationResult.resultMessage)
+						.withCommandParameters(params)
+						.build()
+				: ActionResult.Builder.withErrors(operationResult.errorMessages).withCommandParameters(params).build();
+		} catch (error) {
+			const errorMessage = error instanceof CLIException ? error.getErrorMessage() : error;
+			return ActionResult.Builder.withErrors([errorMessage]).build();
+		}
+	}
+};

package/src/commands/file/import/ImportFilesCommand.js

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

package/src/commands/file/import/ImportFilesInputHandler.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 CommandUtils = require('../../../utils/CommandUtils');
+const { default: { prompt} } = require('inquirer');
+const NodeTranslationService = require('../../../services/NodeTranslationService');
+const SdkOperationResultUtils = require('../../../utils/SdkOperationResultUtils');
+const AccountFileCabinetService = require('../../../services/AccountFileCabinetService');
+const ProjectInfoService = require('../../../services/ProjectInfoService');
+const { PROJECT_SUITEAPP } = require('../../../ApplicationConstants');
+const { getProjectDefaultAuthId } = require('../../../utils/AuthenticationUtils');
+const BaseInputHandler = require('../../base/BaseInputHandler');
+const SdkExecutor = require('../../../SdkExecutor');
+const { showValidationResults, validateArrayIsNotEmpty } = require('../../../validation/InteractiveAnswersValidator');
+const {
+	COMMAND_IMPORTFILES: { ERRORS, QUESTIONS, MESSAGES },
+	NO,
+	YES,
+} = require('../../../services/TranslationKeys');
+
+const SUITE_SCRIPTS_FOLDER = '/SuiteScripts';
+const COMMAND_OPTIONS = {
+	AUTH_ID: 'authid',
+	FOLDER: 'folder',
+	PATHS: 'paths',
+	EXCLUDE_PROPERTIES: 'excludeproperties',
+	PROJECT: 'project',
+};
+
+const COMMAND_ANSWERS = {
+	OVERWRITE_FILES: 'overwrite',
+};
+
+module.exports = class ImportFilesInputHandler extends BaseInputHandler {
+	constructor(options) {
+		super(options);
+		// TODO input handlers shouldn't execute actions. rework this
+		this._sdkExecutor = new SdkExecutor(this._sdkPath, this._executionEnvironmentContext);
+
+		this._projectInfoService = new ProjectInfoService(this._projectFolder);
+	}
+
+	async getParameters(params) {
+		if (this._projectInfoService.getProjectType() === PROJECT_SUITEAPP) {
+			throw NodeTranslationService.getMessage(ERRORS.IS_SUITEAPP);
+		}
+
+		const accountFileCabinetService = new AccountFileCabinetService(this._sdkPath, this._executionEnvironmentContext, this._authId);
+		
+		const listFoldersResult = await accountFileCabinetService.getAccountFileCabinetFolders();
+		if (listFoldersResult.length === 0) {
+			throw NodeTranslationService.getMessage(ERRORS.NO_FOLDERS_FOUND);
+		}
+
+		const selectFolderQuestion = this._generateSelectFolderQuestion(listFoldersResult);
+		const selectFolderAnswer = await prompt([selectFolderQuestion]);
+		const listFilesResult = await accountFileCabinetService.listFiles(selectFolderAnswer.folder);
+
+		if (listFilesResult.status === SdkOperationResultUtils.STATUS.ERROR) {
+			throw listFilesResult.errorMessages;
+		}
+		if (Array.isArray(listFilesResult.data) && listFilesResult.data.length === 0) {
+			throw SdkOperationResultUtils.getResultMessage(listFilesResult);
+		}
+
+		const selectFilesQuestions = this._generateSelectFilesQuestions(listFilesResult);
+		const selectFilesAnswer = await prompt(selectFilesQuestions);
+
+		const overwriteAnswer = await prompt([this._generateOverwriteQuestion()]);
+		if (overwriteAnswer[COMMAND_ANSWERS.OVERWRITE_FILES] === false) {
+			throw NodeTranslationService.getMessage(MESSAGES.CANCEL_IMPORT);
+		}
+
+		return selectFilesAnswer;
+	}
+
+	_generateSelectFolderQuestion(listFoldersResult) {
+		return {
+			type: CommandUtils.INQUIRER_TYPES.LIST,
+			name: COMMAND_OPTIONS.FOLDER,
+			message: NodeTranslationService.getMessage(QUESTIONS.SELECT_FOLDER),
+			default: SUITE_SCRIPTS_FOLDER,
+			choices: this._getFileCabinetFolders(listFoldersResult),
+		};
+	}
+
+	_getFileCabinetFolders(listFoldersResponse) {
+		return listFoldersResponse.map((folderPath) => ({
+			name: folderPath,
+			value: folderPath,
+		}));
+	}
+
+	_generateSelectFilesQuestions(listFilesResult) {
+		return [
+			{
+				type: CommandUtils.INQUIRER_TYPES.CHECKBOX,
+				name: COMMAND_OPTIONS.PATHS,
+				message: NodeTranslationService.getMessage(QUESTIONS.SELECT_FILES),
+				choices: listFilesResult.data.map((path) => ({ name: path, value: path })),
+				validate: (fieldValue) => showValidationResults(fieldValue, validateArrayIsNotEmpty),
+			},
+			{
+				type: CommandUtils.INQUIRER_TYPES.LIST,
+				name: COMMAND_OPTIONS.EXCLUDE_PROPERTIES,
+				message: NodeTranslationService.getMessage(QUESTIONS.EXCLUDE_PROPERTIES),
+				choices: [
+					{ name: NodeTranslationService.getMessage(YES), value: true },
+					{ name: NodeTranslationService.getMessage(NO), value: false },
+				],
+			},
+		];
+	}
+
+	_generateOverwriteQuestion() {
+		return {
+			type: CommandUtils.INQUIRER_TYPES.LIST,
+			name: COMMAND_ANSWERS.OVERWRITE_FILES,
+			message: NodeTranslationService.getMessage(QUESTIONS.OVERWRITE_FILES),
+			default: true,
+			choices: [
+				{ name: NodeTranslationService.getMessage(YES), value: true },
+				{ name: NodeTranslationService.getMessage(NO), value: false },
+			],
+		};
+	}
+};

package/src/commands/file/import/ImportFilesOutputHandler.js

@@ -0,0 +1,53 @@
+/*
+ ** 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_IMPORTFILES: { OUTPUT },
+} = require('../../../services/TranslationKeys');
+
+const COMMAND_OPTIONS_CALLED_FROM_COMPARE_FILES = 'calledfromcomparefiles';
+const COMMAND_OPTIONS_CALLED_FROM_UPDATE = 'calledfromupdate';
+
+module.exports = class ImportFilesOutputHandler extends BaseOutputHandler {
+	constructor(options) {
+		super(options);
+	}
+
+	parse(actionResult) {
+		if (Array.isArray(actionResult.data.results)) {
+			const successful = actionResult.data.results.filter((result) => result.loaded === true);
+			const unsuccessful = actionResult.data.results.filter((result) => result.loaded !== true);
+			if (successful.length) {
+				if (actionResult.commandParameters[COMMAND_OPTIONS_CALLED_FROM_COMPARE_FILES]) {
+					return actionResult;
+				}
+				if (actionResult.commandParameters[COMMAND_OPTIONS_CALLED_FROM_UPDATE]) {
+					this._log.result(NodeTranslationService.getMessage(OUTPUT.FILE_UPDATED));
+				} else {
+					this._log.result(NodeTranslationService.getMessage(OUTPUT.FILES_IMPORTED));
+				}
+				successful.forEach((result) => {
+					this._log.result(result.path);
+				});
+			}
+			if (unsuccessful.length) {
+				if (actionResult.commandParameters[COMMAND_OPTIONS_CALLED_FROM_COMPARE_FILES]) {
+					this._log.warning(NodeTranslationService.getMessage(OUTPUT.FILES_NOT_COMPARED));
+				} else if (actionResult.commandParameters[COMMAND_OPTIONS_CALLED_FROM_UPDATE]) {
+					this._log.warning(NodeTranslationService.getMessage(OUTPUT.FILE_NOT_UPDATED));
+				} else {
+					this._log.warning(NodeTranslationService.getMessage(OUTPUT.FILES_NOT_IMPORTED));
+				}
+				unsuccessful.forEach((result) => {
+					this._log.warning(`${result.path}, ${result.message}`);
+				});
+			}
+		}
+		return actionResult;
+	}
+};

package/src/commands/file/list/ListFilesAction.js

@@ -0,0 +1,55 @@
+/*
+ ** 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 { ActionResult } = require('../../../services/actionresult/ActionResult');
+const SdkExecutionContext = require('../../../SdkExecutionContext');
+const NodeTranslationService = require('../../../services/NodeTranslationService');
+const executeWithSpinner = require('../../../ui/CliSpinner').executeWithSpinner;
+const SdkOperationResultUtils = require('../../../utils/SdkOperationResultUtils');
+const { getProjectDefaultAuthId } = require('../../../utils/AuthenticationUtils');
+const BaseAction = require('../../base/BaseAction');
+const {
+	COMMAND_LISTFILES: { LOADING_FILES },
+} = require('../../../services/TranslationKeys');
+
+const COMMAND_OPTIONS = {
+	AUTH_ID: 'authid'
+}
+
+module.exports = class ListFilesAction extends BaseAction {
+	constructor(options) {
+		super(options);
+	}
+
+	preExecute(args) {
+		return args;
+	}
+
+	async execute(params) {
+		try {
+			// quote folder path to preserve spaces
+			params.folder = `\"${params.folder}\"`;
+			const executionContext = SdkExecutionContext.Builder.forCommand(this._commandMetadata.sdkCommand)
+				.integration()
+				.addParams(params)
+				.build();
+
+			const operationResult = await executeWithSpinner({
+				action: this._sdkExecutor.execute(executionContext),
+				message: NodeTranslationService.getMessage(LOADING_FILES),
+			});
+
+			return operationResult.status === SdkOperationResultUtils.STATUS.SUCCESS
+				? ActionResult.Builder.withData(operationResult.data)
+					.withResultMessage(operationResult.resultMessage)
+					.withCommandParameters(params)
+					.build()
+				: ActionResult.Builder.withErrors(operationResult.errorMessages).withCommandParameters(params).build();
+		} catch (error) {
+			return ActionResult.Builder.withErrors([error]).build();
+		}
+	}
+};