@contentstack/cli-variants 1.3.2 → 2.0.0-beta

package/src/export/events.ts

@@ -1,73 +1,97 @@
 import omit from 'lodash/omit';
 import { resolve as pResolve } from 'node:path';
-import { log, handleAndLogError } from '@contentstack/cli-utilities';
-
+import { sanitizePath, log, handleAndLogError } from '@contentstack/cli-utilities';
+import { PersonalizeConfig, ExportConfig, EventsConfig, EventStruct } from '../types';
 import { fsUtil, PersonalizationAdapter } from '../utils';
-import { PersonalizeConfig, ExportConfig, EventStruct, EventsConfig } from '../types';
+import { PROCESS_NAMES, MODULE_CONTEXTS, EXPORT_PROCESS_STATUS } from '../utils/constants';
 
 export default class ExportEvents extends PersonalizationAdapter<ExportConfig> {
   private eventsConfig: EventsConfig;
   private eventsFolderPath: string;
   private events: Record<string, unknown>[];
+  public exportConfig: ExportConfig;
   public personalizeConfig: PersonalizeConfig;
 
-  constructor(readonly exportConfig: ExportConfig) {
+  constructor(exportConfig: ExportConfig) {
     super({
       config: exportConfig,
       baseURL: exportConfig.modules.personalize.baseURL[exportConfig.region.name],
       headers: { 'X-Project-Uid': exportConfig.project_id },
     });
+    this.exportConfig = exportConfig;
     this.personalizeConfig = exportConfig.modules.personalize;
     this.eventsConfig = exportConfig.modules.events;
     this.eventsFolderPath = pResolve(
-      exportConfig.data,
-      exportConfig.branchName || '',
-      this.personalizeConfig.dirName,
-      this.eventsConfig.dirName,
+      sanitizePath(exportConfig.data),
+      sanitizePath(exportConfig.branchName || ''),
+      sanitizePath(this.personalizeConfig.dirName),
+      sanitizePath(this.eventsConfig.dirName),
     );
     this.events = [];
-    this.exportConfig.context.module = 'events';
+    this.exportConfig.context.module = MODULE_CONTEXTS.EVENTS;
   }
 
   async start() {
     try {
       log.debug('Starting events export process...', this.exportConfig.context);
       log.info('Starting events export', this.exportConfig.context);
-      
-      log.debug('Initializing personalization adapter...', this.exportConfig.context);
-      await this.init();
-      log.debug('Personalization adapter initialized successfully', this.exportConfig.context);
-      
-      log.debug(`Creating events directory at: ${this.eventsFolderPath}`, this.exportConfig.context);
-      await fsUtil.makeDirectory(this.eventsFolderPath);
-      log.debug('Events directory created successfully', this.exportConfig.context);
-      
-      log.debug('Fetching events from personalization API...', this.exportConfig.context);
-      this.events = (await this.getEvents()) as EventStruct[];
-      log.debug(`Fetched ${this.events?.length || 0} events`, this.exportConfig.context);
+
+      await this.withLoadingSpinner('EVENTS: Initializing export and fetching data...', async () => {
+        log.debug('Initializing personalization adapter...', this.exportConfig.context);
+        await this.init();
+        log.debug('Personalization adapter initialized successfully', this.exportConfig.context);
+
+        log.debug(`Creating events directory at: ${this.eventsFolderPath}`, this.exportConfig.context);
+        await fsUtil.makeDirectory(this.eventsFolderPath);
+        log.debug('Events directory created successfully', this.exportConfig.context);
+
+        log.debug('Fetching events from personalization API...', this.exportConfig.context);
+        this.events = (await this.getEvents()) as EventStruct[];
+        log.debug(`Fetched ${this.events?.length || 0} events`, this.exportConfig.context);
+      });
 
       if (!this.events?.length) {
         log.debug('No events found, completing export', this.exportConfig.context);
         log.info('No Events found with the given project!', this.exportConfig.context);
         return;
+      }
+
+      let progress: any;
+
+      if (this.parentProgressManager) {
+        progress = this.parentProgressManager;
+        this.progressManager = this.parentProgressManager;
+        progress.updateProcessTotal(PROCESS_NAMES.EVENTS, this.events.length);
       } else {
-        log.debug(`Processing ${this.events.length} events`, this.exportConfig.context);
-        this.sanitizeAttribs();
-        log.debug('Events sanitization completed', this.exportConfig.context);
-        
-        const eventsFilePath = pResolve(this.eventsFolderPath, this.eventsConfig.fileName);
-        log.debug(`Writing events to: ${eventsFilePath}`, this.exportConfig.context);
-        fsUtil.writeFile(eventsFilePath, this.events);
-        
-        log.debug('Events export completed successfully', this.exportConfig.context);
-        log.success(
-          `Events exported successfully! Total events: ${this.events.length}`,
-          this.exportConfig.context,
-        );
-        return;
+        progress = this.createSimpleProgress(PROCESS_NAMES.EVENTS, this.events.length);
       }
-    } catch (error) {
+
+      log.debug(`Processing ${this.events.length} events`, this.exportConfig.context);
+      progress.updateStatus(EXPORT_PROCESS_STATUS[PROCESS_NAMES.EVENTS].EXPORTING, PROCESS_NAMES.EVENTS);
+
+      this.sanitizeAttribs();
+      log.debug('Events sanitization completed', this.exportConfig.context);
+
+      progress.updateStatus(EXPORT_PROCESS_STATUS[PROCESS_NAMES.EVENTS].EXPORTING, PROCESS_NAMES.EVENTS);
+      const eventsFilePath = pResolve(sanitizePath(this.eventsFolderPath), sanitizePath(this.eventsConfig.fileName));
+      log.debug(`Writing events to: ${eventsFilePath}`, this.exportConfig.context);
+      fsUtil.writeFile(eventsFilePath, this.events);
+
+      // Final progress update
+      if (this.progressManager) {
+        //this.updateProgress(true, `${this.events.length} events exported`, undefined, processName);
+      }
+
+      // Complete progress only if we're managing our own progress
+      if (!this.parentProgressManager) {
+        this.completeProgress(true);
+      }
+
+      log.debug('Events export completed successfully', this.exportConfig.context);
+      log.success(`Events exported successfully! Total events: ${this.events.length}`, this.exportConfig.context);
+    } catch (error: any) {
       log.debug(`Error occurred during events export: ${error}`, this.exportConfig.context);
+      this.completeProgress(false, error?.message || 'Events export failed');
       handleAndLogError(error, { ...this.exportConfig.context });
     }
   }
@@ -77,10 +101,29 @@ export default class ExportEvents extends PersonalizationAdapter<ExportConfig> {
    */
   sanitizeAttribs() {
     log.debug(`Sanitizing ${this.events?.length || 0} events`, this.exportConfig.context);
-    log.debug(`Invalid keys to remove: ${JSON.stringify(this.eventsConfig.invalidKeys)}`, this.exportConfig.context);
-    
-    this.events = this.events?.map((event) => omit(event, this.eventsConfig.invalidKeys)) || [];
-    
-    log.debug(`Sanitization complete. Total events after sanitization: ${this.events.length}`, this.exportConfig.context);
+
+    this.events =
+      this.events?.map((event, index) => {
+        const sanitizedEvent = omit(event, this.eventsConfig.invalidKeys);
+
+        if (this.progressManager) {
+          const processName = this.parentProgressManager ? PROCESS_NAMES.EVENTS : undefined;
+          this.updateProgress(
+            true,
+            `event ${index + 1}/${this.events.length}: ${
+              (event as any).key || (event as any).name || (event as any).uid || 'unknown'
+            }`,
+            undefined,
+            processName,
+          );
+        }
+
+        return sanitizedEvent;
+      }) || [];
+
+    log.debug(
+      `Sanitization complete. Total events after sanitization: ${this.events.length}`,
+      this.exportConfig.context,
+    );
   }
 }

package/src/export/experiences.ts

@@ -2,11 +2,13 @@ import * as path from 'path';
 import { sanitizePath, log, handleAndLogError } from '@contentstack/cli-utilities';
 import { PersonalizeConfig, ExportConfig, ExperienceStruct } from '../types';
 import { fsUtil, PersonalizationAdapter } from '../utils';
+import { PROCESS_NAMES, MODULE_CONTEXTS, EXPORT_PROCESS_STATUS } from '../utils/constants';
 
 export default class ExportExperiences extends PersonalizationAdapter<ExportConfig> {
   private experiencesFolderPath: string;
   public exportConfig: ExportConfig;
   public personalizeConfig: PersonalizeConfig;
+
   constructor(exportConfig: ExportConfig) {
     super({
       config: exportConfig,
@@ -25,123 +27,193 @@ export default class ExportExperiences extends PersonalizationAdapter<ExportConf
       sanitizePath(this.personalizeConfig.dirName),
       'experiences',
     );
-    this.exportConfig.context.module = 'experiences';
+    this.exportConfig.context.module = MODULE_CONTEXTS.EXPERIENCES;
   }
 
   async start() {
     try {
-      // get all experiences
-      // loop through experiences and get content types attached to it
-      // write experiences in to a file
       log.debug('Starting experiences export process...', this.exportConfig.context);
       log.info('Starting experiences export', this.exportConfig.context);
-      
-      log.debug('Initializing personalization adapter...', this.exportConfig.context);
-      await this.init();
-      log.debug('Personalization adapter initialized successfully', this.exportConfig.context);
-      
-      log.debug(`Creating experiences directory at: ${this.experiencesFolderPath}`, this.exportConfig.context);
-      await fsUtil.makeDirectory(this.experiencesFolderPath);
-      log.debug('Experiences directory created successfully', this.exportConfig.context);
-      
-      const versionsDirPath = path.resolve(sanitizePath(this.experiencesFolderPath), 'versions');
-      log.debug(`Creating versions directory at: ${versionsDirPath}`, this.exportConfig.context);
-      await fsUtil.makeDirectory(versionsDirPath);
-      log.debug('Versions directory created successfully', this.exportConfig.context);
-      
-      log.debug('Fetching experiences from personalization API...', this.exportConfig.context);
-      const experiences: Array<ExperienceStruct> = (await this.getExperiences()) || [];
-      log.debug(`Fetched ${experiences?.length || 0} experiences`, this.exportConfig.context);
-      
+
+      const { experiences } = await this.withLoadingSpinner(
+        'EXPERIENCES: Initializing export and fetching data...',
+        async () => {
+          log.debug('Initializing personalization adapter...', this.exportConfig.context);
+          await this.init();
+          log.debug('Personalization adapter initialized successfully', this.exportConfig.context);
+
+          log.debug(`Creating experiences directory at: ${this.experiencesFolderPath}`, this.exportConfig.context);
+          await fsUtil.makeDirectory(this.experiencesFolderPath);
+          log.debug('Experiences directory created successfully', this.exportConfig.context);
+
+          const versionsDirPath = path.resolve(sanitizePath(this.experiencesFolderPath), 'versions');
+          log.debug(`Creating versions directory at: ${versionsDirPath}`, this.exportConfig.context);
+          await fsUtil.makeDirectory(versionsDirPath);
+          log.debug('Versions directory created successfully', this.exportConfig.context);
+
+          log.debug('Fetching experiences from personalization API...', this.exportConfig.context);
+          const experiences: Array<ExperienceStruct> = (await this.getExperiences()) || [];
+          log.debug(`Fetched ${experiences?.length || 0} experiences`, this.exportConfig.context);
+
+          return { experiences };
+        },
+      );
+
       if (!experiences || experiences?.length < 1) {
         log.debug('No experiences found, completing export', this.exportConfig.context);
         log.info('No Experiences found with the given project!', this.exportConfig.context);
         return;
       }
-      
+
+      let progress: any;
+      const processName = PROCESS_NAMES.EXPERIENCES;
+
+      if (this.parentProgressManager) {
+        progress = this.parentProgressManager;
+        this.progressManager = this.parentProgressManager;
+        progress.updateProcessTotal(processName, experiences.length);
+      } else {
+        // Create our own progress for standalone execution
+        progress = this.createSimpleProgress(PROCESS_NAMES.EXPERIENCES, experiences.length);
+      }
+
+      log.debug(`Processing ${experiences.length} experiences`, this.exportConfig.context);
+      progress.updateStatus(EXPORT_PROCESS_STATUS[PROCESS_NAMES.EXPERIENCES].EXPORTING, processName);
+
       const experiencesFilePath = path.resolve(sanitizePath(this.experiencesFolderPath), 'experiences.json');
       log.debug(`Writing experiences to: ${experiencesFilePath}`, this.exportConfig.context);
       fsUtil.writeFile(experiencesFilePath, experiences);
 
       const experienceToVariantsStrList: Array<string> = [];
       const experienceToContentTypesMap: Record<string, string[]> = {};
-      
-      log.debug(`Processing ${experiences.length} experiences for variants and content types`, this.exportConfig.context);
-      
-      for (let experience of experiences) {
-        log.debug(`Processing experience: ${experience.name} (${experience.uid})`, this.exportConfig.context);
-        
-        // create id mapper for experience to variants
-        let variants = experience?._cms?.variants ?? {};
-        log.debug(`Found ${Object.keys(variants).length} variants for experience: ${experience.name}`, this.exportConfig.context);
-        
-        Object.keys(variants).forEach((variantShortId: string) => {
-          const experienceToVariantsStr = `${experience.uid}-${variantShortId}-${variants[variantShortId]}`;
-          experienceToVariantsStrList.push(experienceToVariantsStr);
-          log.debug(`Added variant mapping: ${experienceToVariantsStr}`, this.exportConfig.context);
-        });
 
+      log.debug(
+        `Processing ${experiences.length} experiences for variants and content types`,
+        this.exportConfig.context,
+      );
+
+      progress.updateStatus(EXPORT_PROCESS_STATUS[PROCESS_NAMES.EXPERIENCES].EXPORTING, processName);
+
+      for (let experienceIndex = 0; experienceIndex < experiences.length; experienceIndex++) {
+        const experience = experiences[experienceIndex];
         try {
-          // fetch versions of experience
-          log.debug(`Fetching versions for experience: ${experience.name}`, this.exportConfig.context);
-          const experienceVersions = (await this.getExperienceVersions(experience.uid)) || [];
-          log.debug(`Fetched ${experienceVersions.length} versions for experience: ${experience.name}`, this.exportConfig.context);
-          
-          if (experienceVersions.length > 0) {
-            const versionsFilePath = path.resolve(sanitizePath(this.experiencesFolderPath), 'versions', `${experience.uid}.json`);
-            log.debug(`Writing experience versions to: ${versionsFilePath}`, this.exportConfig.context);
-            fsUtil.writeFile(versionsFilePath, experienceVersions);
-          } else {
-            log.debug(`No versions found for experience: ${experience.name}`, this.exportConfig.context);
-            log.info(
-              `No versions found for experience '${experience.name}'`,
+          log.debug(
+            `Processing experience: ${experience.name} (${experience.uid}) - ${experienceIndex + 1}/${
+              experiences.length
+            }`,
+            this.exportConfig.context,
+          );
+
+          // create id mapper for experience to variants
+          let variants = experience?._cms?.variants ?? {};
+          // talisman-ignore-start
+          log.debug(
+            `Found ${Object.keys(variants).length} variants for experience: ${experience.name}`,
+            this.exportConfig.context,
+          );
+          // talisman-ignore-end
+
+          // talisman-ignore-start
+          Object.keys(variants).forEach((variantShortId: string) => {
+            const experienceToVariantsStr = `${experience.uid}-${variantShortId}-${variants[variantShortId]}`;
+            experienceToVariantsStrList.push(experienceToVariantsStr);
+            log.debug(`Added variant mapping: ${experienceToVariantsStr}`, this.exportConfig.context);
+          });
+          // talisman-ignore-end
+
+          // Fetch versions of experience
+          try {
+            log.debug(`Fetching versions for experience: ${experience.name}`, this.exportConfig.context);
+            const experienceVersions = (await this.getExperienceVersions(experience.uid)) || [];
+            log.debug(
+              `Fetched ${experienceVersions.length} versions for experience: ${experience.name}`,
               this.exportConfig.context,
             );
+
+            if (experienceVersions.length > 0) {
+              const versionsFilePath = path.resolve(
+                sanitizePath(this.experiencesFolderPath),
+                'versions',
+                `${experience.uid}.json`,
+              );
+              log.debug(`Writing experience versions to: ${versionsFilePath}`, this.exportConfig.context);
+              fsUtil.writeFile(versionsFilePath, experienceVersions);
+            } else {
+              log.debug(`No versions found for experience: ${experience.name}`, this.exportConfig.context);
+              log.info(`No versions found for experience '${experience.name}'`, this.exportConfig.context);
+            }
+          } catch (error: any) {
+            log.debug(
+              `Error occurred while fetching versions for experience: ${experience.name}`,
+              this.exportConfig.context,
+            );
+            handleAndLogError(
+              error,
+              { ...this.exportConfig.context },
+              `Failed to fetch versions of experience ${experience.name}`,
+            );
           }
-        } catch (error) {
-          log.debug(`Error occurred while fetching versions for experience: ${experience.name}`, this.exportConfig.context);
-          handleAndLogError(
-            error,
-            {...this.exportConfig.context},
-            `Failed to fetch versions of experience ${experience.name}`
-          );
-        }
 
-        try {
-          // fetch content of experience
-          log.debug(`Fetching variant group for experience: ${experience.name}`, this.exportConfig.context);
-          const { variant_groups: [variantGroup] = [] } =
-            (await this.getVariantGroup({ experienceUid: experience.uid })) || {};
-          
-          if (variantGroup?.content_types?.length) {
-            log.debug(`Found ${variantGroup.content_types.length} content types for experience: ${experience.name}`, this.exportConfig.context);
-            experienceToContentTypesMap[experience.uid] = variantGroup.content_types;
-          } else {
-            log.debug(`No content types found for experience: ${experience.name}`, this.exportConfig.context);
+          // Fetch content types of experience
+          try {
+            log.debug(`Fetching variant group for experience: ${experience.name}`, this.exportConfig.context);
+            const { variant_groups: [variantGroup] = [] } =
+              (await this.getVariantGroup({ experienceUid: experience.uid })) || {};
+
+            if (variantGroup?.content_types?.length) {
+              log.debug(
+                `Found ${variantGroup.content_types.length} content types for experience: ${experience.name}`,
+                this.exportConfig.context,
+              );
+              experienceToContentTypesMap[experience.uid] = variantGroup.content_types;
+            } else {
+              log.debug(`No content types found for experience: ${experience.name}`, this.exportConfig.context);
+            }
+          } catch (error: any) {
+            log.debug(
+              `Error occurred while fetching content types for experience: ${experience.name}`,
+              this.exportConfig.context,
+            );
+            handleAndLogError(
+              error,
+              { ...this.exportConfig.context },
+              `Failed to fetch content types of experience ${experience.name}`,
+            );
           }
-        } catch (error) {
-          log.debug(`Error occurred while fetching content types for experience: ${experience.name}`, this.exportConfig.context);
-          handleAndLogError(
-            error,
-            {...this.exportConfig.context},
-            `Failed to fetch content types of experience ${experience.name}`
-          );
+        } catch (error: any) {
+          log.debug(`Error occurred while processing experience: ${experience.name}`, this.exportConfig.context);
+          handleAndLogError(error, { ...this.exportConfig.context }, `Failed to process experience ${experience.name}`);
         }
       }
-      
-      const variantsIdsFilePath = path.resolve(sanitizePath(this.experiencesFolderPath), 'experiences-variants-ids.json');
+
+      progress.updateStatus(EXPORT_PROCESS_STATUS[PROCESS_NAMES.EXPERIENCES].EXPORTING, processName);
+
+      // Write final mapping files
+      const variantsIdsFilePath = path.resolve(
+        sanitizePath(this.experiencesFolderPath),
+        'experiences-variants-ids.json',
+      );
       log.debug(`Writing experience variants mapping to: ${variantsIdsFilePath}`, this.exportConfig.context);
       fsUtil.writeFile(variantsIdsFilePath, experienceToVariantsStrList);
 
-      const contentTypesFilePath = path.resolve(sanitizePath(this.experiencesFolderPath), 'experiences-content-types.json');
+      const contentTypesFilePath = path.resolve(
+        sanitizePath(this.experiencesFolderPath),
+        'experiences-content-types.json',
+      );
       log.debug(`Writing experience content types mapping to: ${contentTypesFilePath}`, this.exportConfig.context);
       fsUtil.writeFile(contentTypesFilePath, experienceToContentTypesMap);
-      
+
+      // Complete progress only if we're managing our own progress
+      if (!this.parentProgressManager) {
+        this.completeProgress(true);
+      }
+
       log.debug('Experiences export completed successfully', this.exportConfig.context);
       log.success('Experiences exported successfully!', this.exportConfig.context);
-    } catch (error) {
+    } catch (error: any) {
       log.debug(`Error occurred during experiences export: ${error}`, this.exportConfig.context);
-      handleAndLogError(error, {...this.exportConfig.context});
+      this.completeProgress(false, error?.message || 'Experiences export failed');
+      handleAndLogError(error, { ...this.exportConfig.context });
     }
   }
 }

package/src/export/projects.ts

@@ -1,12 +1,15 @@
-import * as path from 'path';
-import { sanitizePath, log } from '@contentstack/cli-utilities';
-import { ExportConfig, PersonalizeConfig } from '../types';
-import { PersonalizationAdapter, fsUtil, } from '../utils';
+import { resolve as pResolve } from 'node:path';
+import { sanitizePath, log, handleAndLogError } from '@contentstack/cli-utilities';
+import { PersonalizeConfig, ExportConfig, ProjectStruct } from '../types';
+import { fsUtil, PersonalizationAdapter } from '../utils';
+import { PROCESS_NAMES, MODULE_CONTEXTS, EXPORT_PROCESS_STATUS } from '../utils/constants';
 
 export default class ExportProjects extends PersonalizationAdapter<ExportConfig> {
-  private projectFolderPath: string;
+  private projectsFolderPath: string;
+  private projectsData: ProjectStruct[];
   public exportConfig: ExportConfig;
   public personalizeConfig: PersonalizeConfig;
+
   constructor(exportConfig: ExportConfig) {
     super({
       config: exportConfig,
@@ -15,57 +18,86 @@ export default class ExportProjects extends PersonalizationAdapter<ExportConfig>
     });
     this.exportConfig = exportConfig;
     this.personalizeConfig = exportConfig.modules.personalize;
-    this.projectFolderPath = path.resolve(
+    this.projectsFolderPath = pResolve(
       sanitizePath(exportConfig.data),
       sanitizePath(exportConfig.branchName || ''),
       sanitizePath(this.personalizeConfig.dirName),
       'projects',
     );
-    this.exportConfig.context.module = 'projects';
+    this.projectsData = [];
+    this.exportConfig.context.module = MODULE_CONTEXTS.PROJECTS;
   }
 
   async start() {
     try {
       log.debug('Starting projects export process...', this.exportConfig.context);
-      log.info(`Starting projects export`, this.exportConfig.context);
-      
-      log.debug('Initializing personalization adapter...', this.exportConfig.context);
-      await this.init();
-      log.debug('Personalization adapter initialized successfully', this.exportConfig.context);
-      
-      log.debug(`Creating projects directory at: ${this.projectFolderPath}`, this.exportConfig.context);
-      await fsUtil.makeDirectory(this.projectFolderPath);
-      log.debug('Projects directory created successfully', this.exportConfig.context);
-      
-      log.debug(`Fetching projects for stack API key: ${this.exportConfig.apiKey}`, this.exportConfig.context);
-      const project = await this.projects({ connectedStackApiKey: this.exportConfig.apiKey });
-      log.debug(`Fetched ${project?.length || 0} projects`, this.exportConfig.context);
-      
-      if (!project || project?.length < 1) {
+      log.info('Starting projects export', this.exportConfig.context);
+
+      // Initial setup with loading spinner
+      await this.withLoadingSpinner('PROJECTS: Initializing export and fetching data...', async () => {
+        log.debug('Initializing personalization adapter...', this.exportConfig.context);
+        await this.init();
+        log.debug('Personalization adapter initialized successfully', this.exportConfig.context);
+
+        log.debug(`Creating projects directory at: ${this.projectsFolderPath}`, this.exportConfig.context);
+        await fsUtil.makeDirectory(this.projectsFolderPath);
+        log.debug('Projects directory created successfully', this.exportConfig.context);
+
+        log.debug('Fetching projects from personalization API...', this.exportConfig.context);
+        // talisman-ignore-line
+        this.projectsData = (await this.projects({ connectedStackApiKey: this.exportConfig.apiKey })) || [];
+        log.debug(`Fetched ${this.projectsData?.length || 0} projects`, this.exportConfig.context);
+      });
+
+      if (!this.projectsData?.length) {
         log.debug('No projects found, disabling personalization', this.exportConfig.context);
-        log.info(`No Personalize Project connected with the given stack`, this.exportConfig.context);
+        log.info('No Personalize Project connected with the given stack', this.exportConfig.context);
         this.exportConfig.personalizationEnabled = false;
         return;
       }
-      
-      log.debug(`Found ${project.length} projects, enabling personalization`, this.exportConfig.context);
+
+      // Enable personalization and set project config
+      log.debug(`Found ${this.projectsData.length} projects, enabling personalization`, this.exportConfig.context);
       this.exportConfig.personalizationEnabled = true;
-      this.exportConfig.project_id = project[0]?.uid;
-      log.debug(`Set project ID: ${project[0]?.uid}`, this.exportConfig.context);
-      
-      const projectsFilePath = path.resolve(sanitizePath(this.projectFolderPath), 'projects.json');
-      log.debug(`Writing projects data to: ${projectsFilePath}`, this.exportConfig.context);
-      fsUtil.writeFile(projectsFilePath, project);
-      
-      log.debug('Projects export completed successfully', this.exportConfig.context);
-      log.success(`Projects exported successfully!`, this.exportConfig.context);
-    } catch (error) {
-      if (error !== 'Forbidden') {
-        log.debug(`Error occurred during projects export: ${error}`, this.exportConfig.context);
-        log.error('Failed to export projects!', this.exportConfig.context);
+      this.exportConfig.project_id = this.projectsData[0]?.uid;
+      log.debug(`Set project ID: ${this.projectsData[0]?.uid}`, this.exportConfig.context);
+
+      let progress: any;
+      if (this.parentProgressManager) {
+        progress = this.parentProgressManager;
+        this.progressManager = this.parentProgressManager;
+        // Parent already has correct count, just update status
+        progress.updateStatus(EXPORT_PROCESS_STATUS[PROCESS_NAMES.PROJECTS].EXPORTING, PROCESS_NAMES.PROJECTS);
       } else {
-        log.debug('Projects export forbidden, likely due to permissions', this.exportConfig.context);
+        progress = this.createNestedProgress(PROCESS_NAMES.PROJECTS);
+        progress.addProcess(PROCESS_NAMES.PROJECTS, this.projectsData?.length);
+        progress
+          .startProcess(PROCESS_NAMES.PROJECTS)
+          .updateStatus(EXPORT_PROCESS_STATUS[PROCESS_NAMES.PROJECTS].EXPORTING, PROCESS_NAMES.PROJECTS);
       }
+
+      const projectsFilePath = pResolve(sanitizePath(this.projectsFolderPath), 'projects.json');
+      log.debug(`Writing projects to: ${projectsFilePath}`, this.exportConfig.context);
+      fsUtil.writeFile(projectsFilePath, this.projectsData);
+      log.debug('Projects export completed successfully', this.exportConfig.context);
+
+      const processName = PROCESS_NAMES.PROJECTS;
+      this.updateProgress(true, 'project export', undefined, processName);
+
+      // Complete process only if we're managing our own progress
+      if (!this.parentProgressManager) {
+        progress.completeProcess(PROCESS_NAMES.PROJECTS, true);
+        this.completeProgress(true);
+      }
+
+      log.success(
+        `Projects exported successfully! Total projects: ${this.projectsData.length} - personalization enabled`,
+        this.exportConfig.context,
+      );
+    } catch (error: any) {
+      log.debug(`Error occurred during projects export: ${error}`, this.exportConfig.context);
+      this.completeProgress(false, error?.message || 'Projects export failed');
+      handleAndLogError(error, { ...this.exportConfig.context });
       throw error;
     }
   }