@contentstack/cli-cm-clone 2.0.0-beta.2 → 2.0.0-beta.3

package/README.md

@@ -16,7 +16,7 @@ $ npm install -g @contentstack/cli-cm-clone
 $ csdx COMMAND
 running command...
 $ csdx (--version)
-@contentstack/cli-cm-clone/2.0.0-beta.1 darwin-arm64 node-v22.14.0
+@contentstack/cli-cm-clone/2.0.0-beta.2 darwin-arm64 node-v22.14.0
 $ csdx --help [COMMAND]
 USAGE
   $ csdx COMMAND

package/package.json

@@ -1,27 +1,24 @@
 {
   "name": "@contentstack/cli-cm-clone",
   "description": "Contentstack stack clone plugin",
-  "version": "2.0.0-beta.2",
+  "version": "2.0.0-beta.3",
   "author": "Contentstack",
   "bugs": "https://github.com/rohitmishra209/cli-cm-clone/issues",
   "dependencies": {
     "@colors/colors": "^1.6.0",
-    "@contentstack/cli-cm-export": "~2.0.0-beta.2",
-    "@contentstack/cli-cm-import": "~2.0.0-beta.2",
-    "@contentstack/cli-command": "~1.6.1",
+    "@contentstack/cli-cm-export": "~2.0.0-beta.3",
+    "@contentstack/cli-cm-import": "~2.0.0-beta.3",
+    "@contentstack/cli-command": "~1.7.0",
     "@contentstack/cli-utilities": "~1.15.0",
     "@oclif/core": "^4.3.0",
     "@oclif/plugin-help": "^6.2.28",
     "chalk": "^4.1.2",
-    "inquirer": "8.2.6",
-    "inquirer-search-checkbox": "^1.0.0",
-    "inquirer-search-list": "^1.2.6",
+    "inquirer": "8.2.7",
     "lodash": "^4.17.21",
     "merge": "^2.1.1",
     "ora": "^5.4.1",
     "prompt": "^1.3.0",
-    "rimraf": "^5.0.10",
-    "winston": "^3.17.0"
+    "rimraf": "^6.1.0"
   },
   "devDependencies": {
     "@oclif/test": "^4.1.13",

package/src/commands/cm/stacks/clone.js

@@ -1,5 +1,5 @@
 const { Command } = require('@contentstack/cli-command');
-const { configHandler, flags, isAuthenticated, managementSDKClient } = require('@contentstack/cli-utilities');
+const { configHandler, flags, isAuthenticated, managementSDKClient, log, handleAndLogError } = require('@contentstack/cli-utilities');
 const { CloneHandler } = require('../../../lib/util/clone-handler');
 const path = require('path');
 const { rimraf } = require('rimraf');
@@ -9,6 +9,44 @@ const { readdirSync, readFileSync } = require('fs');
 let config = {};
 
 class StackCloneCommand extends Command {
+  /**
+   * Determine authentication method based on user preference
+   */
+  determineAuthenticationMethod(sourceManagementTokenAlias, destinationManagementTokenAlias) {
+    // Track authentication method
+    let authenticationMethod = 'unknown';
+
+    // Determine authentication method based on user preference
+    if (sourceManagementTokenAlias || destinationManagementTokenAlias) {
+      authenticationMethod = 'Management Token';
+    } else if (isAuthenticated()) {
+      // Check if user is authenticated via OAuth
+      const isOAuthUser = configHandler.get('authorisationType') === 'OAUTH' || false;
+      if (isOAuthUser) {
+        authenticationMethod = 'OAuth';
+      } else {
+        authenticationMethod = 'Basic Auth';
+      }
+    } else {
+      authenticationMethod = 'Basic Auth';
+    }
+
+    return authenticationMethod;
+  }
+
+  /**
+   * Create clone context object for logging
+   */
+  createCloneContext(authenticationMethod) {
+    return {
+      command: this.context?.info?.command || 'cm:stacks:clone',
+      module: 'clone',
+      email: configHandler.get('email') || '',
+      sessionId: this.context?.sessionId || '',
+      authenticationMethod: authenticationMethod || 'Basic Auth',
+    };
+  }
+
   async run() {
     try {
       let self = this;
@@ -31,14 +69,27 @@ class StackCloneCommand extends Command {
 
       const handleClone = async () => {
         const listOfTokens = configHandler.get('tokens');
+        const authenticationMethod = this.determineAuthenticationMethod(
+          sourceManagementTokenAlias,
+          destinationManagementTokenAlias,
+        );
+        const cloneContext = this.createCloneContext(authenticationMethod);
+        log.debug('Starting clone operation setup', cloneContext);
 
         if (externalConfigPath) {
+          log.debug(`Loading external configuration from: ${externalConfigPath}`, cloneContext);
           let externalConfig = readFileSync(externalConfigPath, 'utf-8');
           externalConfig = JSON.parse(externalConfig);
           config = merge.recursive(config, externalConfig);
         }
         config.forceStopMarketplaceAppsPrompt = yes;
         config.skipAudit = cloneCommandFlags['skip-audit'];
+        log.debug('Clone configuration prepared', { 
+          ...cloneContext,
+          cloneType: config.cloneType, 
+          skipAudit: config.skipAudit,
+          forceStopMarketplaceAppsPrompt: config.forceStopMarketplaceAppsPrompt 
+        });
 
         if (cloneType) {
           config.cloneType = cloneType;
@@ -67,15 +118,18 @@ class StackCloneCommand extends Command {
         if (sourceManagementTokenAlias && listOfTokens[sourceManagementTokenAlias]) {
           config.source_alias = sourceManagementTokenAlias;
           config.source_stack = listOfTokens[sourceManagementTokenAlias].apiKey;
+          log.debug(`Using source token alias: ${sourceManagementTokenAlias}`, cloneContext);
         } else if (sourceManagementTokenAlias) {
-          console.log(`Provided source token alias (${sourceManagementTokenAlias}) not found in your config.!`);
+          log.warn(`Provided source token alias (${sourceManagementTokenAlias}) not found in your config.!`, cloneContext);
         }
         if (destinationManagementTokenAlias && listOfTokens[destinationManagementTokenAlias]) {
           config.destination_alias = destinationManagementTokenAlias;
           config.target_stack = listOfTokens[destinationManagementTokenAlias].apiKey;
+          log.debug(`Using destination token alias: ${destinationManagementTokenAlias}`, cloneContext);
         } else if (destinationManagementTokenAlias) {
-          console.log(
+          log.warn(
             `Provided destination token alias (${destinationManagementTokenAlias}) not found in your config.!`,
+            cloneContext,
           );
         }
         if (importWebhookStatus) {
@@ -83,18 +137,23 @@ class StackCloneCommand extends Command {
         }
 
         const managementAPIClient = await managementSDKClient(config);
+        log.debug('Management API client initialized successfully', cloneContext);
 
-        await this.removeContentDirIfNotEmptyBeforeClone(pathdir); // NOTE remove if folder not empty before clone
-        this.registerCleanupOnInterrupt(pathdir);
+        log.debug(`Content directory path: ${pathdir}`, cloneContext);
+        await this.removeContentDirIfNotEmptyBeforeClone(pathdir, cloneContext); // NOTE remove if folder not empty before clone
+        this.registerCleanupOnInterrupt(pathdir, cloneContext);
 
         config.auth_token = configHandler.get('authtoken');
         config.host = this.cmaHost;
         config.cdn = this.cdaHost;
         config.pathDir = pathdir;
+        config.cloneContext = cloneContext;
+        log.debug('Clone configuration finalized', cloneContext);
         const cloneHandler = new CloneHandler(config);
         cloneHandler.setClient(managementAPIClient);
+        log.debug('Starting clone operation', cloneContext);
         cloneHandler.execute().catch((error) => {
-          console.log(error);
+          handleAndLogError(error, cloneContext);
         });
       };
 
@@ -103,7 +162,7 @@ class StackCloneCommand extends Command {
           if (isAuthenticated()) {
             handleClone();
           } else {
-            console.log('Please login to execute this command, csdx auth:login');
+            log.error('Log in to execute this command,csdx auth:login', cloneContext);
             this.exit(1);
           }
         } else {
@@ -112,76 +171,76 @@ class StackCloneCommand extends Command {
       } else if (isAuthenticated()) {
         handleClone();
       } else {
-        console.log('Please login to execute this command, csdx auth:login');
+        log.error('Please login to execute this command, csdx auth:login', cloneContext);
         this.exit(1);
       }
     } catch (error) {
       if (error) {
-        await this.cleanUp(pathdir);
-        // eslint-disable-next-line no-console
-        console.log(error.message || error);
+        await this.cleanUp(pathdir, null, cloneContext);
+        log.error('Stack clone command failed', { ...cloneContext, error: error?.message || error });
       }
     }
   }
 
 
 
-  async removeContentDirIfNotEmptyBeforeClone(dir) {
+  async removeContentDirIfNotEmptyBeforeClone(dir, cloneContext) {
     try {
+      log.debug('Checking if content directory is empty', { ...cloneContext, dir });
       const dirNotEmpty = readdirSync(dir).length;
 
       if (dirNotEmpty) {
-        await this.cleanUp(dir);
+        log.debug('Content directory is not empty, cleaning up', { ...cloneContext, dir });
+        await this.cleanUp(dir, null, cloneContext);
       }
     } catch (error) {
       const omit = ['ENOENT']; // NOTE add emittable error codes in the array
 
       if (!omit.includes(error.code)) {
-        console.log(error.message);
+        log.error('Error checking content directory', { ...cloneContext, error: error?.message, code: error.code });
       }
     }
   }
 
-  async cleanUp(pathDir, message) {
+  async cleanUp(pathDir, message, cloneContext) {
     try {
+      log.debug('Starting cleanup', { ...cloneContext, pathDir });
       await rimraf(pathDir);
       if (message) {
-        // eslint-disable-next-line no-console
-        console.log(message);
+        log.info(message, cloneContext);
       }
+      log.debug('Cleanup completed', { ...cloneContext, pathDir });
     } catch (err) {
       if (err) {
-        console.log('\nCleaning up');
+        log.debug('Cleaning up', cloneContext);
         const skipCodeArr = ['ENOENT', 'EBUSY', 'EPERM', 'EMFILE', 'ENOTEMPTY'];
 
         if (skipCodeArr.includes(err.code)) {
+          log.debug('Cleanup error code is in skip list, exiting', { ...cloneContext, code: err?.code });
           process.exit();
         }
       }
     }
   }
 
-  registerCleanupOnInterrupt(pathDir) {
+  registerCleanupOnInterrupt(pathDir, cloneContext) {
     const interrupt = ['SIGINT', 'SIGQUIT', 'SIGTERM'];
     const exceptions = ['unhandledRejection', 'uncaughtException'];
 
     const cleanUp = async (exitOrError) => {
       if (exitOrError) {
-        // eslint-disable-next-line no-console
-        console.log('\nCleaning up');
-        await this.cleanUp(pathDir);
-        // eslint-disable-next-line no-console
-        console.log('done');
-        // eslint-disable-next-line no-process-exit
+        log.debug('Cleaning up on interrupt', cloneContext);
+        await this.cleanUp(pathDir, null, cloneContext);
+        log.info('Cleanup done', cloneContext);
 
         if (exitOrError instanceof Promise) {
           exitOrError.catch((error) => {
-            console.log((error && error.message) || '');
+            log.error('Error during cleanup', { ...cloneContext, error: (error && error?.message) || '' });
           });
         } else if (exitOrError.message) {
-          console.log(exitOrError.message);
+          log.error('Cleanup error', { ...cloneContext, error: exitOrError?.message });
         } else if (exitOrError.errorMessage) {
-          console.log(exitOrError.message);
+          log.error('Cleanup error', { ...cloneContext, error: exitOrError?.errorMessage });
         }
 
         if (exitOrError === true) process.exit();

package/src/lib/util/clone-handler.js

@@ -21,7 +21,7 @@ const {
   Clone,
   HandleBranchCommand,
 } = require('../helpers/command-helpers');
-const { configHandler, getBranchFromAlias } = require('@contentstack/cli-utilities');
+const { configHandler, getBranchFromAlias, log } = require('@contentstack/cli-utilities');
 
 let client = {};
 let config;
@@ -76,6 +76,7 @@ class CloneHandler {
     cloneCommand = new Clone();
     this.pathDir = opt.pathDir;
     process.stdin.setMaxListeners(50);
+    log.debug('Initializing CloneHandler', config.cloneContext, { pathDir: opt.pathDir, cloneType: opt.cloneType });
   }
   setClient(managementSDKClient) {
     client = managementSDKClient;
@@ -84,19 +85,24 @@ class CloneHandler {
   handleOrgSelection(options = {}) {
     return new Promise(async (resolve, reject) => {
       const { msg = '', isSource = true } = options || {};
+      log.debug('Handling organization selection', config.cloneContext);
       const orgList = await this.getOrganizationChoices(msg).catch(reject);
 
-      if (orgList) {
-        const orgSelected = await inquirer.prompt(orgList);
+        if (orgList) {
+          log.debug(`Found ${orgList.choices?.length || 0} organization(s) to choose from`, config.cloneContext);
+          const orgSelected = await inquirer.prompt(orgList);
+          log.debug(`Organization selected: ${orgSelected.Organization}`, config.cloneContext);
 
-        if (isSource) {
-          config.sourceOrg = orgUidList[orgSelected.Organization];
-        } else {
-          config.targetOrg = orgUidList[orgSelected.Organization];
-        }
+          if (isSource) {
+            config.sourceOrg = orgUidList[orgSelected.Organization];
+            log.debug(`Source organization UID: ${config.sourceOrg}`, config.cloneContext);
+          } else {
+            config.targetOrg = orgUidList[orgSelected.Organization];
+            log.debug(`Target organization UID: ${config.targetOrg}`, config.cloneContext);
+          }
 
-        resolve(orgSelected);
-      }
+          resolve(orgSelected);
+        }
     });
   }
 
@@ -104,13 +110,16 @@ class CloneHandler {
     return new Promise(async (resolve, reject) => {
       try {
         const { org = {}, msg = '', isSource = true } = options || {};
+        log.debug('Handling stack selection', config.cloneContext, { isSource, orgName: org.Organization, msg });
 
         const stackList = await this.getStack(org, msg, isSource).catch(reject);
 
         if (stackList) {
           this.displayBackOptionMessage();
 
+          log.debug(`Found ${stackList.choices?.length || 0} stack(s) to choose from`, config.cloneContext);
           const selectedStack = await inquirer.prompt(stackList);
+          log.debug(`Stack selected: ${selectedStack.stack}`, config.cloneContext);
           if (this.executingCommand != 1) {
             return reject();
           }
@@ -118,9 +127,11 @@ class CloneHandler {
             config.sourceStackName = selectedStack.stack;
             master_locale = masterLocaleList[selectedStack.stack];
             config.source_stack = stackUidList[selectedStack.stack];
+            log.debug(`Source stack configured`, config.cloneContext);
           } else {
             config.target_stack = stackUidList[selectedStack.stack];
             config.destinationStackName = selectedStack.stack;
+            log.debug(`Target stack configured`, config.cloneContext);
           }
 
           resolve(selectedStack);
@@ -136,6 +147,7 @@ class CloneHandler {
     return new Promise(async (resolve, reject) => {
       let spinner;
       try {
+        log.debug('Handling branch selection', config.cloneContext, { isSource, returnBranch, stackApiKey: isSource ? config.source_stack : config.target_stack });
         const stackAPIClient = client.stack({
           api_key: isSource ? config.source_stack : config.target_stack,
           management_token: config.management_token,
@@ -143,22 +155,27 @@ class CloneHandler {
 
         // NOTE validate if source branch is exist
         if (isSource && config.sourceStackBranch) {
+          log.debug('Validating source branch exists', { ...config.cloneContext, branch: config.sourceStackBranch });
           await this.validateIfBranchExist(stackAPIClient, true);
           return resolve();
         } else if(isSource && config.sourceStackBranchAlias) {
+          log.debug('Resolving source branch alias', { ...config.cloneContext, alias: config.sourceStackBranchAlias });
           await this.resolveBranchAliases(true);
           return resolve();
         }
 
         // NOTE Validate target branch is exist
         if (!isSource && config.targetStackBranch) {
+          log.debug('Validating target branch exists', { ...config.cloneContext, branch: config.targetStackBranch });
           await this.validateIfBranchExist(stackAPIClient, false);
           return resolve();
         } else if (!isSource && config.targetStackBranchAlias) {
+          log.debug('Resolving target branch alias', { ...config.cloneContext, alias: config.targetStackBranchAlias });
           await this.resolveBranchAliases();
           return resolve();
         }
         spinner = ora('Fetching Branches').start();
+        log.debug(`Querying branches for stack: ${isSource ? config.source_stack : config.target_stack}`, config.cloneContext);
         const result = await stackAPIClient
           .branch()
           .query()
@@ -167,6 +184,7 @@ class CloneHandler {
           .catch((_err) => {});
 
         const condition = result && Array.isArray(result) && result.length > 0;
+        log.debug(`Found ${result?.length || 0} branch(es)`, config.cloneContext);
 
         // NOTE if want to get only list of branches (Pass param -> returnBranch = true )
         if (returnBranch) {
@@ -185,8 +203,10 @@ class CloneHandler {
             }
             if (isSource) {
               config.sourceStackBranch = branch;
+              log.debug(`Source branch selected: ${branch}`, config.cloneContext);
             } else {
               config.targetStackBranch = branch;
+              log.debug(`Target branch selected: ${branch}`, config.cloneContext);
             }
           } else {
             spinner.succeed('No branches found.!');
@@ -196,7 +216,6 @@ class CloneHandler {
         }
       } catch (e) {
         if (spinner) spinner.fail();
-        console.error(e && e.message);
         return reject(e);
       }
     });
@@ -210,6 +229,7 @@ class CloneHandler {
     };
     try {
       const branch = isSource ? config.sourceStackBranch : config.targetStackBranch;
+      log.debug('Validating branch existence', config.cloneContext);
       spinner = ora(`Validation if ${isSource ? 'source' : 'target'} branch exist.!`).start();
       const isBranchExist = await stackAPIClient
         .branch(branch)
@@ -217,8 +237,10 @@ class CloneHandler {
         .then((data) => data);
 
       if (isBranchExist && typeof isBranchExist === 'object') {
+        log.debug('Branch validation successful', config.cloneContext);
         completeSpinner(`${isSource ? 'Source' : 'Target'} branch verified.!`);
       } else {
+        log.error('Branch not found', config.cloneContext);
         completeSpinner(`${isSource ? 'Source' : 'Target'} branch not found.!`, 'fail');
         process.exit();
       }
@@ -247,8 +269,10 @@ class CloneHandler {
     return new Promise(async (resolve, reject) => {
       let keyPressHandler;
       try {
+        log.debug('Starting clone execution', { ...config.cloneContext, sourceStack: config.source_stack, targetStack: config.target_stack });
         if (!config.source_stack) {
           const orgMsg = 'Choose an organization where your source stack exists:';
+          log.debug('Source stack not provided, prompting for organization', config.cloneContext);
           this.setExectingCommand(0);
           this.removeBackKeyPressHandler();
           const org = await cloneCommand.execute(new HandleOrgCommand({ msg: orgMsg, isSource: true }, this));
@@ -278,17 +302,21 @@ class CloneHandler {
             return reject('Org not found.');
           }
         } else {
+          log.debug('Source stack provided, proceeding with branch selection and export', config.cloneContext);
           this.setExectingCommand(2);
           await this.handleBranchSelection({ api_key: config.sourceStack });
+          log.debug('Starting export operation', config.cloneContext);
           const exportRes = await cloneCommand.execute(new HandleExportCommand(null, this));
           await cloneCommand.execute(new SetBranchCommand(null, this));
 
           if (exportRes) {
+            log.debug('Export completed, proceeding with destination setup', config.cloneContext);
             this.executeDestination().catch((error) => {
               return reject(error);
             });
           }
         }
+        log.debug('Clone execution completed successfully', config.cloneContext);
         return resolve();
       } catch (error) {
         return reject(error);
@@ -327,10 +355,12 @@ class CloneHandler {
 
   async executeExport() {
     try {
+      log.debug('Executing export operation', config.cloneContext);
       const exportRes = await cloneCommand.execute(new HandleExportCommand(null, this));
       await cloneCommand.execute(new SetBranchCommand(null, this));
 
       if (exportRes) {
+        log.debug('Export operation completed, proceeding with destination', config.cloneContext);
         this.executeDestination().catch(() => {
           throw '';
         });
@@ -346,8 +376,10 @@ class CloneHandler {
     return new Promise(async (resolve, reject) => {
       let keyPressHandler;
       try {
+        log.debug('Executing destination setup', config.cloneContext);
         let canCreateStack = false;
         if (!config.target_stack) {
+          log.debug('Target stack not provided, prompting for stack creation', config.cloneContext);
           canCreateStack = await inquirer.prompt(stackCreationConfirmation);
         }
 
@@ -397,6 +429,7 @@ class CloneHandler {
           await this.executeBranchDestinationPrompt(params);
         }
 
+        log.debug('Destination setup completed successfully', config.cloneContext);
         return resolve();
       } catch (error) {
         reject(error);
@@ -469,10 +502,12 @@ class CloneHandler {
       choices: [],
     };
     return new Promise(async (resolve, reject) => {
+      log.debug('Fetching organization choices', config.cloneContext);
       const spinner = ora('Fetching Organization').start();
       try {
         let organizations;
         const configOrgUid = configHandler.get('oauthOrgUid');
+        log.debug('Getting organizations', config.cloneContext, { hasConfigOrgUid: !!configOrgUid });
 
         if (configOrgUid) {
           organizations = await client.organization(configOrgUid).fetch();
@@ -481,6 +516,7 @@ class CloneHandler {
         }
 
         spinner.succeed('Fetched Organization');
+        log.debug('Fetched organizations', config.cloneContext);
         for (const element of organizations.items || [organizations]) {
           orgUidList[element.name] = element.uid;
           orgChoice.choices.push(element.name);
@@ -501,12 +537,15 @@ class CloneHandler {
         message: stkMessage !== undefined ? stkMessage : 'Select the stack',
         choices: [],
       };
+      log.debug('Fetching stacks', config.cloneContext);
       const spinner = ora('Fetching stacks').start();
       try {
         const organization_uid = orgUidList[answer.Organization];
+        log.debug('Querying stacks for organization', config.cloneContext, { organizationUid: organization_uid });
         const stackList = client.stack().query({ organization_uid }).find();
         stackList
           .then((stacklist) => {
+            log.debug('Fetched stacks', config.cloneContext, { count: stacklist.items ? stacklist.items.length : 0 });
             for (const element of stacklist.items) {
               stackUidList[element.name] = element.api_key;
               masterLocaleList[element.name] = element.master_locale;
@@ -530,9 +569,11 @@ class CloneHandler {
     return new Promise(async (resolve, reject) => {
       try {
         const { orgUid } = options;
+        log.debug('Creating new stack', config.cloneContext, { orgUid, masterLocale: master_locale, stackName: config.stackName });
         this.displayBackOptionMessage();
         let inputvalue;
         if (!config.stackName) {
+          log.debug('Stack name not provided, prompting user', config.cloneContext);
           prompt.start();
           prompt.message = '';
           this.setCreateNewStackPrompt(prompt);
@@ -542,17 +583,24 @@ class CloneHandler {
           inputvalue = { stack: config.stackName };
         }
         if (this.executingCommand === 0 || !inputvalue) {
+          log.debug('Stack creation cancelled or invalid input', config.cloneContext);
           return reject();
         }
 
         let stack = { name: inputvalue.stack, master_locale: master_locale };
+        log.debug('Creating stack with configuration', config.cloneContext);
         const spinner = ora('Creating New stack').start();
+        log.debug('Sending stack creation API request', config.cloneContext);
         let newStack = client.stack().create({ stack }, { organization_uid: orgUid });
         newStack
           .then((result) => {
+            log.debug('Stack created successfully', config.cloneContext, { 
+              stackName: result.name,
+            });
             spinner.succeed('New Stack created Successfully name as ' + result.name);
             config.target_stack = result.api_key;
             config.destinationStackName = result.name;
+            log.debug('Target stack configuration updated', config.cloneContext);
             return resolve(result);
           })
           .catch((error) => {
@@ -589,12 +637,15 @@ class CloneHandler {
 
   async resolveBranchAliases(isSource = false) {
     try {
+      log.debug('Resolving branch aliases', { ...config.cloneContext, isSource, alias: isSource ? config.sourceStackBranchAlias : config.targetStackBranchAlias });
       if (isSource) {
         const sourceStack = client.stack({ api_key: config.source_stack });
         config.sourceStackBranch = await getBranchFromAlias(sourceStack, config.sourceStackBranchAlias);
+        log.debug('Source branch alias resolved', { ...config.cloneContext, alias: config.sourceStackBranchAlias, branch: config.sourceStackBranch });
       } else {
         const targetStack = client.stack({ api_key: config.target_stack });
         config.targetStackBranch = await getBranchFromAlias(targetStack, config.targetStackBranchAlias);
+        log.debug('Target branch alias resolved', { ...config.cloneContext, alias: config.targetStackBranchAlias, branch: config.targetStackBranch });
       }
     } catch (error) {
       throw error;
@@ -604,6 +655,7 @@ class CloneHandler {
   async cloneTypeSelection() {
     console.clear();
     return new Promise(async (resolve, reject) => {
+      log.debug('Starting clone type selection', config.cloneContext);
       const choices = [
         'Structure (all modules except entries & assets)',
         'Structure with content (all modules including entries & assets)',
@@ -619,83 +671,139 @@ class CloneHandler {
       let successMsg;
       let selectedValue = {};
       config['data'] = path.join(__dirname.split('src')[0], 'contents', config.sourceStackBranch || '');
+      log.debug(`Clone data directory: ${config['data']}`, config.cloneContext);
 
       if (!config.cloneType) {
+        log.debug('Clone type not specified, prompting user for selection', config.cloneContext);
         selectedValue = await inquirer.prompt(cloneTypeSelection);
+      } else {
+        log.debug(`Using pre-configured clone type: ${config.cloneType}`, config.cloneContext);
       }
 
       if (config.cloneType === 'a' || selectedValue.type === 'Structure (all modules except entries & assets)') {
         config['modules'] = structureList;
         successMsg = 'Stack clone Structure completed';
+        log.debug(`Clone type: Structure only. Modules to clone: ${structureList.join(', ')}`, config.cloneContext);
       } else {
         successMsg = 'Stack clone completed with structure and content';
+        log.debug('Clone type: Structure with content (all modules)', config.cloneContext);
       }
 
       this.cmdImport()
-        .then(() => resolve(successMsg))
+        .then(() => {
+          log.debug('Clone type selection and import completed successfully', config.cloneContext);
+          resolve(successMsg);
+        })
         .catch(reject);
     });
   }
 
   async cmdExport() {
     return new Promise((resolve, reject) => {
+      log.debug('Preparing export command', { ...config.cloneContext, sourceStack: config.source_stack, cloneType: config.cloneType });
       // Creating export specific config by merging external configurations
       let exportConfig = Object.assign({}, cloneDeep(config), { ...config?.export });
       delete exportConfig.import;
       delete exportConfig.export;
 
-      const cmd = ['-k', exportConfig.source_stack, '-d', __dirname.split('src')[0] + 'contents'];
+      const exportDir = __dirname.split('src')[0] + 'contents';
+      log.debug(`Export directory: ${exportDir}`, config.cloneContext);
+      const cmd = ['-k', exportConfig.source_stack, '-d', exportDir];
+      
       if (exportConfig.cloneType === 'a') {
         exportConfig.filteredModules = ['stack'].concat(structureList);
+        log.debug(`Filtered modules for structure-only export: ${exportConfig.filteredModules.join(', ')}`, config.cloneContext);
       }
 
       if (exportConfig.source_alias) {
         cmd.push('-a', exportConfig.source_alias);
+        log.debug(`Using source alias: ${exportConfig.source_alias}`, config.cloneContext);
       }
       if (exportConfig.sourceStackBranch) {
         cmd.push('--branch', exportConfig.sourceStackBranch);
+        log.debug(`Using source branch: ${exportConfig.sourceStackBranch}`, config.cloneContext);
       }
 
-      if (exportConfig.forceStopMarketplaceAppsPrompt) cmd.push('-y');
+      if (exportConfig.forceStopMarketplaceAppsPrompt) {
+        cmd.push('-y');
+        log.debug('Force stop marketplace apps prompt enabled', config.cloneContext);
+      }
 
+      const configFilePath = path.join(__dirname, 'dummyConfig.json');
       cmd.push('-c');
-      cmd.push(path.join(__dirname, 'dummyConfig.json'));
-
-      fs.writeFileSync(path.join(__dirname, 'dummyConfig.json'), JSON.stringify(exportConfig));
+      cmd.push(configFilePath);
+      log.debug(`Writing export config to: ${configFilePath}`, config.cloneContext);
+
+      fs.writeFileSync(configFilePath, JSON.stringify(exportConfig));
+      log.debug('Export command prepared', config.cloneContext, { 
+        cmd: cmd.join(' '),
+        exportDir,
+        sourceStack: exportConfig.source_stack,
+        branch: exportConfig.sourceStackBranch 
+      });
+      log.debug('Running export command', config.cloneContext, { cmd });
       let exportData = exportCmd.run(cmd);
-      exportData.then(() => resolve(true)).catch(reject);
+      exportData.then(() => {
+        log.debug('Export command completed successfully', config.cloneContext);
+        resolve(true);
+      }).catch((error) => {
+        reject(error);
+      });
     });
   }
 
   async cmdImport() {
     return new Promise(async (resolve, _reject) => {
+      log.debug('Preparing import command', { ...config.cloneContext, targetStack: config.target_stack, targetBranch: config.targetStackBranch });
       // Creating export specific config by merging external configurations
       let importConfig = Object.assign({}, cloneDeep(config), { ...config?.import });
       delete importConfig.import;
       delete importConfig.export;
 
-      const cmd = ['-c', path.join(__dirname, 'dummyConfig.json')];
+      const configFilePath = path.join(__dirname, 'dummyConfig.json');
+      const cmd = ['-c', configFilePath];
 
       if (importConfig.destination_alias) {
         cmd.push('-a', importConfig.destination_alias);
+        log.debug(`Using destination alias: ${importConfig.destination_alias}`, config.cloneContext);
       }
       if (!importConfig.data && importConfig.sourceStackBranch) {
-        cmd.push('-d', path.join(importConfig.pathDir, importConfig.sourceStackBranch));
+        const dataPath = path.join(importConfig.pathDir, importConfig.sourceStackBranch);
+        cmd.push('-d', dataPath);
+        log.debug(`Import data path: ${dataPath}`, config.cloneContext);
       }
       if (importConfig.targetStackBranch) {
         cmd.push('--branch', importConfig.targetStackBranch);
+        log.debug(`Using target branch: ${importConfig.targetStackBranch}`, config.cloneContext);
       }
       if (importConfig.importWebhookStatus) {
         cmd.push('--import-webhook-status', importConfig.importWebhookStatus);
+        log.debug(`Import webhook status: ${importConfig.importWebhookStatus}`, config.cloneContext);
       }
 
-      if (importConfig.skipAudit) cmd.push('--skip-audit');
+      if (importConfig.skipAudit) {
+        cmd.push('--skip-audit');
+        log.debug('Skip audit flag enabled', config.cloneContext);
+      }
 
-      if (importConfig.forceStopMarketplaceAppsPrompt) cmd.push('-y');
+      if (importConfig.forceStopMarketplaceAppsPrompt) {
+        cmd.push('-y');
+        log.debug('Force stop marketplace apps prompt enabled', config.cloneContext);
+      }
 
-      fs.writeFileSync(path.join(__dirname, 'dummyConfig.json'), JSON.stringify(importConfig));
+      log.debug(`Writing import config to: ${configFilePath}`, config.cloneContext);
+      fs.writeFileSync(configFilePath, JSON.stringify(importConfig));
+      log.debug('Import command prepared', config.cloneContext, { 
+        cmd: cmd.join(' '),
+        targetStack: importConfig.target_stack,
+        targetBranch: importConfig.targetStackBranch,
+        dataPath: importConfig.data || path.join(importConfig.pathDir, importConfig.sourceStackBranch)
+      });
+      log.debug('Running import command', config.cloneContext, { cmd });
       await importCmd.run(cmd);
-      fs.writeFileSync(path.join(__dirname, 'dummyConfig.json'), JSON.stringify({}));
+      log.debug('Import command completed successfully', config.cloneContext);
+      log.debug('Clearing import config file', config.cloneContext);
+      fs.writeFileSync(configFilePath, JSON.stringify({}));
       return resolve();
     });
   }

package/src/lib/util/log.js

@@ -1,105 +0,0 @@
-/*!
- * Contentstack Import
- * Copyright (c) 2024 Contentstack LLC
- * MIT Licensed
- */
-
-var winston = require('winston');
-var path = require('path');
-var mkdirp = require('mkdirp');
-const { pathValidator, sanitizePath } = require('@contentstack/cli-utilities');
-var slice = Array.prototype.slice;
-
-function returnString(args) {
-  var returnStr = '';
-  if (args && args.length) {
-    returnStr = args
-      .map(function (item) {
-        if (item && typeof item === 'object') {
-          return JSON.stringify(item);
-        }
-        return item;
-      })
-      .join('  ')
-      .trim();
-  }
-  return returnStr;
-}
-
-var myCustomLevels = {
-  levels: {
-    error: 0,
-    warn: 1,
-    info: 2,
-    debug: 3,
-  },
-  colors: {
-    info: 'blue',
-    debug: 'green',
-    warn: 'yellow',
-    error: 'red',
-  },
-};
-
-function init(_logPath, logfileName) {
-  var logsDir = pathValidator(path.resolve(sanitizePath(_logPath), 'logs', 'import'));
-  // Create dir if doesn't already exist
-  mkdirp.sync(logsDir);
-  var logPath = path.join(sanitizePath(logsDir), pathValidator(sanitizePath(logfileName)) + '.log');
-
-  var transports = [
-    new winston.transports.File({
-      filename: logPath,
-      maxFiles: 20,
-      maxsize: 1000000,
-      tailable: true,
-      json: true,
-    }),
-  ];
-
-  transports.push(new winston.transports.Console());
-
-  var logger = winston.createLogger({
-    transports: transports,
-    levels: myCustomLevels.levels,
-  });
-
-  return {
-    log: function () {
-      var args = slice.call(arguments);
-      var logString = returnString(args);
-      if (logString) {
-        logger.log('info', logString);
-      }
-    },
-    warn: function () {
-      var args = slice.call(arguments);
-      var logString = returnString(args);
-      if (logString) {
-        logger.log('warn', logString);
-      }
-    },
-    error: function () {
-      var args = slice.call(arguments);
-      var logString = returnString(args);
-      if (logString) {
-        logger.log('error', logString);
-      }
-    },
-    debug: function () {
-      var args = slice.call(arguments);
-      var logString = returnString(args);
-      if (logString) {
-        logger.log('debug', logString);
-      }
-    },
-  };
-}
-
-exports.addlogs = async (config, message, type) => {
-  if (type !== 'error') {
-    init(config.oldPath, type).log(message);
-  } else {
-    init(config.oldPath, type).error(message);
-  }
-};