@rockcarver/frodo-lib 2.0.0-2 → 2.0.0-4

package/esm/ops/JourneyOps.mjs

@@ -16,7 +16,6 @@ import { decode, encode, encodeBase64Url, isBase64Encoded } from '../api/utils/B
 import { getSocialIdentityProviders, putProviderByTypeAndId } from '../api/SocialIdentityProvidersApi';
 import { getThemes, putThemes } from './ThemeOps';
 import { putScript } from './ScriptOps';
-import { JourneyClassification } from './OpsTypes';
 export default class JourneyOps {
   constructor(state) {
     this.state = state;
@@ -237,7 +236,7 @@ export default class JourneyOps {
    * - premium: utilizes nodes, which come at a premium
    * - custom: utilizes nodes not included in the ForgeRock platform release
    * @param {SingleTreeExportInterface} journey journey export data
-   * @returns {JourneyClassification[]} an array of one or multiple classifications
+   * @returns {JourneyClassificationType[]} an array of one or multiple classifications
    */
   getJourneyClassification(journey) {
     return getJourneyClassification({
@@ -294,6 +293,13 @@ export default class JourneyOps {
     });
   }
 }
+export let JourneyClassification = /*#__PURE__*/function (JourneyClassification) {
+  JourneyClassification["STANDARD"] = "standard";
+  JourneyClassification["CUSTOM"] = "custom";
+  JourneyClassification["CLOUD"] = "cloud";
+  JourneyClassification["PREMIUM"] = "premium";
+  return JourneyClassification;
+}({});
 const containerNodes = ['PageNode', 'CustomPageNode'];
 const scriptedNodes = ['ConfigProviderNode', 'ScriptedDecisionNode', 'ClientScriptNode', 'SocialProviderHandlerNode', 'CustomScriptNode'];
 const emailTemplateNodes = ['EmailSuspendNode', 'EmailTemplateNode'];
@@ -377,7 +383,11 @@ async function getSaml2NodeDependencies(nodeObject, allProviders, allCirclesOfTr
         }
         saml2EntityPromises.push(providerResponse);
       } catch (error) {
-        printMessage(error.message, 'error');
+        printMessage({
+          message: error.message,
+          type: 'error',
+          state
+        });
       }
     }
   }
@@ -405,7 +415,11 @@ async function getSaml2NodeDependencies(nodeObject, allProviders, allCirclesOfTr
     };
     return saml2NodeDependencies;
   } catch (error) {
-    printMessage(error.message, 'error');
+    printMessage({
+      message: error.message,
+      type: 'error',
+      state
+    });
     const saml2NodeDependencies = {
       saml2Entities: [],
       circlesOfTrust: []
@@ -441,13 +455,29 @@ export async function exportJourney({
       deps
     } = options;
     const verbose = state.getDebug();
-    if (verbose) printMessage(`\n- ${treeObject._id}\n`, 'info', false);
+    if (verbose) printMessage({
+      message: `\n- ${treeObject._id}\n`,
+      type: 'info',
+      newline: false,
+      state
+    });
 
     // Process tree
-    if (verbose) printMessage('  - Flow');
+    if (verbose) printMessage({
+      message: '  - Flow',
+      state
+    });
     exportData.tree = treeObject;
-    if (verbose && treeObject.identityResource) printMessage(`    - identityResource: ${treeObject.identityResource}`, 'info');
-    if (verbose) printMessage(`    - Done`, 'info');
+    if (verbose && treeObject.identityResource) printMessage({
+      message: `    - identityResource: ${treeObject.identityResource}`,
+      state,
+      type: 'info'
+    });
+    if (verbose) printMessage({
+      message: `    - Done`,
+      type: 'info',
+      state
+    });
     const nodePromises = [];
     const scriptPromises = [];
     const emailTemplatePromises = [];
@@ -461,7 +491,11 @@ export async function exportJourney({
           state
         });
       } catch (error) {
-        printMessage(error, 'error');
+        printMessage({
+          message: error,
+          type: 'error',
+          state
+        });
       }
     }
     let allSaml2Providers = null;
@@ -477,14 +511,22 @@ export async function exportJourney({
         state
       }));
     }
-    if (verbose && nodePromises.length > 0) printMessage('  - Nodes:');
+    if (verbose && nodePromises.length > 0) printMessage({
+      message: '  - Nodes:',
+      state
+    });
     const nodeObjects = await Promise.all(nodePromises);
 
     // iterate over every node in tree
     for (const nodeObject of nodeObjects) {
       const nodeId = nodeObject._id;
       const nodeType = nodeObject._type._id;
-      if (verbose) printMessage(`    - ${nodeId} (${nodeType})`, 'info', true);
+      if (verbose) printMessage({
+        message: `    - ${nodeId} (${nodeType})`,
+        type: 'info',
+        newline: true,
+        state
+      });
       exportData.nodes[nodeObject._id] = nodeObject;
 
       // handle script node types
@@ -509,7 +551,11 @@ export async function exportJourney({
             if (error.isAxiosError && error.response.status) {
               message = error.response.statusText;
             }
-            printMessage(`\n${message}: Email Template "${nodeObject.emailTemplateName}"`, 'error');
+            printMessage({
+              message: `\n${message}: Email Template "${nodeObject.emailTemplateName}"`,
+              type: 'error',
+              state
+            });
           }
         }
       }
@@ -581,12 +627,20 @@ export async function exportJourney({
     }
 
     // Process inner nodes
-    if (verbose && innerNodePromises.length > 0) printMessage('  - Inner nodes:');
+    if (verbose && innerNodePromises.length > 0) printMessage({
+      message: '  - Inner nodes:',
+      state
+    });
     const innerNodeDataResults = await Promise.all(innerNodePromises);
     for (const innerNodeObject of innerNodeDataResults) {
       const innerNodeId = innerNodeObject._id;
       const innerNodeType = innerNodeObject._type._id;
-      if (verbose) printMessage(`    - ${innerNodeId} (${innerNodeType})`, 'info', true);
+      if (verbose) printMessage({
+        message: `    - ${innerNodeId} (${innerNodeType})`,
+        type: 'info',
+        newline: true,
+        state
+      });
       exportData.innerNodes[innerNodeId] = innerNodeObject;
 
       // handle script node types
@@ -611,14 +665,22 @@ export async function exportJourney({
             if (error.isAxiosError && error.response.status) {
               message = error.response.statusText;
             }
-            printMessage(`\n${message}: Email Template "${innerNodeObject.emailTemplateName}"`, 'error');
+            printMessage({
+              message: `\n${message}: Email Template "${innerNodeObject.emailTemplateName}"`,
+              type: 'error',
+              state
+            });
           }
         }
       }
 
       // handle SAML2 node dependencies
       if (deps && innerNodeType === 'product-Saml2Node') {
-        printMessage('SAML2 inner node', 'error');
+        printMessage({
+          message: 'SAML2 inner node',
+          type: 'error',
+          state
+        });
         if (!allSaml2Providers) {
           // eslint-disable-next-line no-await-in-loop
           allSaml2Providers = (await getProviders({
@@ -653,11 +715,19 @@ export async function exportJourney({
     }
 
     // Process email templates
-    if (verbose && emailTemplatePromises.length > 0) printMessage('  - Email templates:');
+    if (verbose && emailTemplatePromises.length > 0) printMessage({
+      message: '  - Email templates:',
+      state
+    });
     const settledEmailTemplatePromises = await Promise.allSettled(emailTemplatePromises);
     for (const settledPromise of settledEmailTemplatePromises) {
       if (settledPromise.status === 'fulfilled' && settledPromise.value) {
-        if (verbose) printMessage(`    - ${settledPromise.value._id.split('/')[1]}${settledPromise.value.displayName ? ` (${settledPromise.value.displayName})` : ''}`, 'info', true);
+        if (verbose) printMessage({
+          message: `    - ${settledPromise.value._id.split('/')[1]}${settledPromise.value.displayName ? ` (${settledPromise.value.displayName})` : ''}`,
+          type: 'info',
+          newline: true,
+          state
+        });
         exportData.emailTemplates[settledPromise.value._id.split('/')[1]] = settledPromise.value;
       }
     }
@@ -666,14 +736,28 @@ export async function exportJourney({
     const saml2NodeDependencies = await Promise.all(saml2ConfigPromises);
     for (const saml2NodeDependency of saml2NodeDependencies) {
       if (saml2NodeDependency) {
-        if (verbose) printMessage('  - SAML2 entity providers:');
+        if (verbose) printMessage({
+          message: '  - SAML2 entity providers:',
+          state
+        });
         for (const saml2Entity of saml2NodeDependency.saml2Entities) {
-          if (verbose) printMessage(`    - ${saml2Entity.entityLocation} ${saml2Entity.entityId}`, 'info');
+          if (verbose) printMessage({
+            message: `    - ${saml2Entity.entityLocation} ${saml2Entity.entityId}`,
+            type: 'info',
+            state
+          });
           exportData.saml2Entities[saml2Entity._id] = saml2Entity;
         }
-        if (verbose) printMessage('  - SAML2 circles of trust:');
+        if (verbose) printMessage({
+          message: '  - SAML2 circles of trust:',
+          state
+        });
         for (const circleOfTrust of saml2NodeDependency.circlesOfTrust) {
-          if (verbose) printMessage(`    - ${circleOfTrust._id}`, 'info');
+          if (verbose) printMessage({
+            message: `    - ${circleOfTrust._id}`,
+            type: 'info',
+            state
+          });
           exportData.circlesOfTrust[circleOfTrust._id] = circleOfTrust;
         }
       }
@@ -682,12 +766,19 @@ export async function exportJourney({
     // Process socialIdentityProviders
     const socialProviders = await Promise.resolve(socialProviderPromise);
     if (socialProviders) {
-      if (verbose) printMessage('  - OAuth2/OIDC (social) identity providers:');
+      if (verbose) printMessage({
+        message: '  - OAuth2/OIDC (social) identity providers:',
+        state
+      });
       for (const socialProvider of socialProviders.result) {
         // If the list of socialIdentityProviders needs to be filtered based on the
         // filteredProviders property of a SelectIdPNode do it here.
         if (socialProvider && (!filteredSocialProviders || filteredSocialProviders.length === 0 || filteredSocialProviders.includes(socialProvider._id))) {
-          if (verbose) printMessage(`    - ${socialProvider._id}`, 'info');
+          if (verbose) printMessage({
+            message: `    - ${socialProvider._id}`,
+            type: 'info',
+            state
+          });
           scriptPromises.push(getScript({
             scriptId: socialProvider.transform,
             state
@@ -698,11 +789,19 @@ export async function exportJourney({
     }
 
     // Process scripts
-    if (verbose && scriptPromises.length > 0) printMessage('  - Scripts:');
+    if (verbose && scriptPromises.length > 0) printMessage({
+      message: '  - Scripts:',
+      state
+    });
     const scriptObjects = await Promise.all(scriptPromises);
     for (const scriptObject of scriptObjects) {
       if (scriptObject) {
-        if (verbose) printMessage(`    - ${scriptObject._id} (${scriptObject.name})`, 'info', true);
+        if (verbose) printMessage({
+          message: `    - ${scriptObject._id} (${scriptObject.name})`,
+          type: 'info',
+          newline: true,
+          state
+        });
         scriptObject.script = useStringArrays ? convertBase64TextToArray(scriptObject.script) : JSON.stringify(decode(scriptObject.script));
         exportData.scripts[scriptObject._id] = scriptObject;
       }
@@ -710,7 +809,10 @@ export async function exportJourney({
 
     // Process themes
     if (themePromise) {
-      if (verbose) printMessage('  - Themes:');
+      if (verbose) printMessage({
+        message: '  - Themes:',
+        state
+      });
       try {
         const themePromiseResults = await Promise.resolve(themePromise);
         for (const themeObject of themePromiseResults) {
@@ -719,18 +821,38 @@ export async function exportJourney({
           // has the theme been specified by id or name in a page node?
           themes.includes(themeObject._id) || themes.includes(themeObject.name) || // has this journey been linked to a theme?
           (_themeObject$linkedTr = themeObject.linkedTrees) !== null && _themeObject$linkedTr !== void 0 && _themeObject$linkedTr.includes(treeObject._id))) {
-            if (verbose) printMessage(`    - ${themeObject._id} (${themeObject.name})`, 'info');
+            if (verbose) printMessage({
+              message: `    - ${themeObject._id} (${themeObject.name})`,
+              type: 'info',
+              state
+            });
             exportData.themes.push(themeObject);
           }
         }
       } catch (error) {
-        printMessage(error.response.data, 'error');
-        printMessage('Error handling themes: ' + error.message, 'error');
+        printMessage({
+          message: error.response.data,
+          type: 'error',
+          state
+        });
+        printMessage({
+          message: 'Error handling themes: ' + error.message,
+          type: 'error',
+          state
+        });
       }
     }
   } catch (error) {
-    printMessage(error.response.data, 'error');
-    printMessage('Error exporting tree: ' + treeId + ' - ' + error.message, 'error');
+    printMessage({
+      message: error.response.data,
+      type: 'error',
+      state
+    });
+    printMessage({
+      message: 'Error exporting tree: ' + treeId + ' - ' + error.message,
+      type: 'error',
+      state
+    });
   }
   return exportData;
 }
@@ -783,16 +905,29 @@ export async function importJourney({
     deps
   } = options;
   const verbose = state.getDebug();
-  if (verbose) printMessage(`\n- ${treeObject.tree._id}\n`, 'info', false);
+  if (verbose) printMessage({
+    message: `\n- ${treeObject.tree._id}\n`,
+    type: 'info',
+    newline: false,
+    state
+  });
   let newUuid = '';
   const uuidMap = {};
   const treeId = treeObject.tree._id;
 
   // Process scripts
   if (deps && treeObject.scripts && Object.entries(treeObject.scripts).length > 0) {
-    if (verbose) printMessage('  - Scripts:');
+    if (verbose) printMessage({
+      message: '  - Scripts:',
+      state
+    });
     for (const [scriptId, scriptObject] of Object.entries(treeObject.scripts)) {
-      if (verbose) printMessage(`    - ${scriptId} (${scriptObject['name']})`, 'info', false);
+      if (verbose) printMessage({
+        message: `    - ${scriptId} (${scriptObject['name']})`,
+        type: 'info',
+        newline: false,
+        state
+      });
       // is the script stored as an array of strings or just b64 blob?
       if (Array.isArray(scriptObject['script'])) {
         scriptObject['script'] = convertTextArrayToBase64(scriptObject['script']);
@@ -808,15 +943,26 @@ export async function importJourney({
       } catch (error) {
         throw new Error(`Error importing script ${scriptObject['name']} (${scriptId}) in journey ${treeId}: ${error.message}`);
       }
-      if (verbose) printMessage('');
+      if (verbose) printMessage({
+        message: '',
+        state
+      });
     }
   }
 
   // Process email templates
   if (deps && treeObject.emailTemplates && Object.entries(treeObject.emailTemplates).length > 0) {
-    if (verbose) printMessage('  - Email templates:');
+    if (verbose) printMessage({
+      message: '  - Email templates:',
+      state
+    });
     for (const [templateId, templateData] of Object.entries(treeObject.emailTemplates)) {
-      if (verbose) printMessage(`    - ${templateId}`, 'info', false);
+      if (verbose) printMessage({
+        message: `    - ${templateId}`,
+        type: 'info',
+        newline: false,
+        state
+      });
       try {
         await putEmailTemplate({
           templateId,
@@ -824,19 +970,33 @@ export async function importJourney({
           state
         });
       } catch (error) {
-        printMessage(error.response.data, 'error');
+        printMessage({
+          message: error.response.data,
+          type: 'error',
+          state
+        });
         throw new Error(`Error importing email templates: ${error.message}`);
       }
-      if (verbose) printMessage('');
+      if (verbose) printMessage({
+        message: '',
+        state
+      });
     }
   }
 
   // Process themes
   if (deps && treeObject.themes && treeObject.themes.length > 0) {
-    if (verbose) printMessage('  - Themes:');
+    if (verbose) printMessage({
+      message: '  - Themes:',
+      state
+    });
     const themes = new Map();
     for (const theme of treeObject.themes) {
-      if (verbose) printMessage(`    - ${theme['_id']} (${theme['name']})`, 'info');
+      if (verbose) printMessage({
+        message: `    - ${theme['_id']} (${theme['name']})`,
+        type: 'info',
+        state
+      });
       themes[theme['_id']] = theme;
     }
     try {
@@ -851,9 +1011,16 @@ export async function importJourney({
 
   // Process social providers
   if (deps && treeObject.socialIdentityProviders && Object.entries(treeObject.socialIdentityProviders).length > 0) {
-    if (verbose) printMessage('  - OAuth2/OIDC (social) identity providers:');
+    if (verbose) printMessage({
+      message: '  - OAuth2/OIDC (social) identity providers:',
+      state
+    });
     for (const [providerId, providerData] of Object.entries(treeObject.socialIdentityProviders)) {
-      if (verbose) printMessage(`    - ${providerId}`, 'info');
+      if (verbose) printMessage({
+        message: `    - ${providerId}`,
+        type: 'info',
+        state
+      });
       try {
         await putProviderByTypeAndId({
           type: providerData['_type']['_id'],
@@ -874,12 +1041,20 @@ export async function importJourney({
             });
           } catch (importError2) {
             var _importError$response4;
-            printMessage(((_importError$response4 = importError.response) === null || _importError$response4 === void 0 ? void 0 : _importError$response4.data) || importError, 'error');
+            printMessage({
+              message: ((_importError$response4 = importError.response) === null || _importError$response4 === void 0 ? void 0 : _importError$response4.data) || importError,
+              type: 'error',
+              state
+            });
             throw new Error(`Error importing provider ${providerId} in journey ${treeId}: ${importError}`);
           }
         } else {
           var _importError$response5;
-          printMessage(((_importError$response5 = importError.response) === null || _importError$response5 === void 0 ? void 0 : _importError$response5.data) || importError, 'error');
+          printMessage({
+            message: ((_importError$response5 = importError.response) === null || _importError$response5 === void 0 ? void 0 : _importError$response5.data) || importError,
+            type: 'error',
+            state
+          });
           throw new Error(`\nError importing provider ${providerId} in journey ${treeId}: ${importError}`);
         }
       }
@@ -888,12 +1063,19 @@ export async function importJourney({
 
   // Process saml providers
   if (deps && treeObject.saml2Entities && Object.entries(treeObject.saml2Entities).length > 0) {
-    if (verbose) printMessage('  - SAML2 entity providers:');
+    if (verbose) printMessage({
+      message: '  - SAML2 entity providers:',
+      state
+    });
     for (const [, providerData] of Object.entries(treeObject.saml2Entities)) {
       delete providerData['_rev'];
       const entityId = providerData['entityId'];
       const entityLocation = providerData['entityLocation'];
-      if (verbose) printMessage(`    - ${entityLocation} ${entityId}`, 'info');
+      if (verbose) printMessage({
+        message: `    - ${entityLocation} ${entityId}`,
+        type: 'info',
+        state
+      });
       let metaData = null;
       if (entityLocation === 'remote') {
         if (Array.isArray(providerData['base64EntityXML'])) {
@@ -917,7 +1099,11 @@ export async function importJourney({
           state
         }).catch(createProviderErr => {
           var _createProviderErr$re;
-          printMessage(((_createProviderErr$re = createProviderErr.response) === null || _createProviderErr$re === void 0 ? void 0 : _createProviderErr$re.data) || createProviderErr, 'error');
+          printMessage({
+            message: ((_createProviderErr$re = createProviderErr.response) === null || _createProviderErr$re === void 0 ? void 0 : _createProviderErr$re.data) || createProviderErr,
+            type: 'error',
+            state
+          });
           throw new Error(`Error creating provider ${entityId}`);
         });
       } else {
@@ -927,7 +1113,11 @@ export async function importJourney({
           state
         }).catch(updateProviderErr => {
           var _updateProviderErr$re;
-          printMessage(((_updateProviderErr$re = updateProviderErr.response) === null || _updateProviderErr$re === void 0 ? void 0 : _updateProviderErr$re.data) || updateProviderErr, 'error');
+          printMessage({
+            message: ((_updateProviderErr$re = updateProviderErr.response) === null || _updateProviderErr$re === void 0 ? void 0 : _updateProviderErr$re.data) || updateProviderErr,
+            type: 'error',
+            state
+          });
           throw new Error(`Error updating provider ${entityId}`);
         });
       }
@@ -936,10 +1126,17 @@ export async function importJourney({
 
   // Process circles of trust
   if (deps && treeObject.circlesOfTrust && Object.entries(treeObject.circlesOfTrust).length > 0) {
-    if (verbose) printMessage('  - SAML2 circles of trust:');
+    if (verbose) printMessage({
+      message: '  - SAML2 circles of trust:',
+      state
+    });
     for (const [cotId, cotData] of Object.entries(treeObject.circlesOfTrust)) {
       delete cotData['_rev'];
-      if (verbose) printMessage(`    - ${cotId}`, 'info');
+      if (verbose) printMessage({
+        message: `    - ${cotId}`,
+        type: 'info',
+        state
+      });
       try {
         await createCircleOfTrust({
           cotData,
@@ -956,13 +1153,25 @@ export async function importJourney({
             });
           } catch (updateCotErr) {
             var _createCotErr$respons3, _updateCotErr$respons;
-            printMessage(((_createCotErr$respons3 = createCotErr.response) === null || _createCotErr$respons3 === void 0 ? void 0 : _createCotErr$respons3.data) || createCotErr, 'error');
-            printMessage(((_updateCotErr$respons = updateCotErr.response) === null || _updateCotErr$respons === void 0 ? void 0 : _updateCotErr$respons.data) || updateCotErr, 'error');
+            printMessage({
+              message: ((_createCotErr$respons3 = createCotErr.response) === null || _createCotErr$respons3 === void 0 ? void 0 : _createCotErr$respons3.data) || createCotErr,
+              type: 'error',
+              state
+            });
+            printMessage({
+              message: ((_updateCotErr$respons = updateCotErr.response) === null || _updateCotErr$respons === void 0 ? void 0 : _updateCotErr$respons.data) || updateCotErr,
+              type: 'error',
+              state
+            });
             throw new Error(`Error creating/updating circle of trust ${cotId}`);
           }
         } else {
           var _createCotErr$respons4;
-          printMessage(((_createCotErr$respons4 = createCotErr.response) === null || _createCotErr$respons4 === void 0 ? void 0 : _createCotErr$respons4.data) || createCotErr, 'error');
+          printMessage({
+            message: ((_createCotErr$respons4 = createCotErr.response) === null || _createCotErr$respons4 === void 0 ? void 0 : _createCotErr$respons4.data) || createCotErr,
+            type: 'error',
+            state
+          });
           throw new Error(`Error creating circle of trust ${cotId}`);
         }
       }
@@ -979,7 +1188,12 @@ export async function importJourney({
     innerNodes = treeObject.innernodes;
   }
   if (Object.entries(innerNodes).length > 0) {
-    if (verbose) printMessage('  - Inner nodes:', 'text', true);
+    if (verbose) printMessage({
+      message: '  - Inner nodes:',
+      type: 'text',
+      newline: true,
+      state
+    });
     for (const [innerNodeId, innerNodeData] of Object.entries(innerNodes)) {
       delete innerNodeData['_rev'];
       const nodeType = innerNodeData['_type']['_id'];
@@ -990,7 +1204,12 @@ export async function importJourney({
         uuidMap[innerNodeId] = newUuid;
       }
       innerNodeData['_id'] = newUuid;
-      if (verbose) printMessage(`    - ${newUuid}${reUuid ? '*' : ''} (${nodeType})`, 'info', false);
+      if (verbose) printMessage({
+        message: `    - ${newUuid}${reUuid ? '*' : ''} (${nodeType})`,
+        type: 'info',
+        newline: false,
+        state
+      });
 
       // If the node has an identityResource config setting
       // and the identityResource ends in 'user'
@@ -1000,7 +1219,12 @@ export async function importJourney({
         innerNodeData['identityResource'] = `managed/${getRealmManagedUser({
           state
         })}`;
-        if (verbose) printMessage(`\n      - identityResource: ${innerNodeData['identityResource']}`, 'info', false);
+        if (verbose) printMessage({
+          message: `\n      - identityResource: ${innerNodeData['identityResource']}`,
+          type: 'info',
+          newline: false,
+          state
+        });
       }
       try {
         await putNode({
@@ -1020,7 +1244,12 @@ export async function importJourney({
           validAttributes.push('_id');
           for (const attribute of Object.keys(innerNodeData)) {
             if (!validAttributes.includes(attribute)) {
-              if (verbose) printMessage(`\n      - Removing invalid attribute: ${attribute}`, 'warn', false);
+              if (verbose) printMessage({
+                message: `\n      - Removing invalid attribute: ${attribute}`,
+                type: 'warn',
+                newline: false,
+                state
+              });
               delete innerNodeData[attribute];
             }
           }
@@ -1032,21 +1261,35 @@ export async function importJourney({
               state
             });
           } catch (nodeImportError2) {
-            printMessage(nodeImportError2.response.data, 'error');
+            printMessage({
+              message: nodeImportError2.response.data,
+              type: 'error',
+              state
+            });
             throw new Error(`Error importing node ${innerNodeId}${innerNodeId === newUuid ? '' : ` [${newUuid}]`} in journey ${treeId}`);
           }
         } else {
-          printMessage(nodeImportError.response.data, 'error');
+          printMessage({
+            message: nodeImportError.response.data,
+            type: 'error',
+            state
+          });
           throw new Error(`Error importing inner node ${innerNodeId}${innerNodeId === newUuid ? '' : ` [${newUuid}]`} in journey ${treeId}`);
         }
       }
-      if (verbose) printMessage('');
+      if (verbose) printMessage({
+        message: '',
+        state
+      });
     }
   }
 
   // Process nodes
   if (treeObject.nodes && Object.entries(treeObject.nodes).length > 0) {
-    if (verbose) printMessage('  - Nodes:');
+    if (verbose) printMessage({
+      message: '  - Nodes:',
+      state
+    });
     // eslint-disable-next-line prefer-const
     for (let [nodeId, nodeData] of Object.entries(treeObject.nodes)) {
       delete nodeData['_rev'];
@@ -1064,7 +1307,12 @@ export async function importJourney({
           nodeData = JSON.parse(replaceAll(JSON.stringify(nodeData), currentId, uuidMap[currentId]));
         }
       }
-      if (verbose) printMessage(`    - ${newUuid}${reUuid ? '*' : ''} (${nodeType})`, 'info', false);
+      if (verbose) printMessage({
+        message: `    - ${newUuid}${reUuid ? '*' : ''} (${nodeType})`,
+        type: 'info',
+        newline: false,
+        state
+      });
 
       // If the node has an identityResource config setting
       // and the identityResource ends in 'user'
@@ -1074,7 +1322,12 @@ export async function importJourney({
         nodeData['identityResource'] = `managed/${getRealmManagedUser({
           state
         })}`;
-        if (verbose) printMessage(`\n      - identityResource: ${nodeData['identityResource']}`, 'info', false);
+        if (verbose) printMessage({
+          message: `\n      - identityResource: ${nodeData['identityResource']}`,
+          type: 'info',
+          newline: false,
+          state
+        });
       }
       try {
         await putNode({
@@ -1094,7 +1347,12 @@ export async function importJourney({
           validAttributes.push('_id');
           for (const attribute of Object.keys(nodeData)) {
             if (!validAttributes.includes(attribute)) {
-              if (verbose) printMessage(`\n      - Removing invalid attribute: ${attribute}`, 'warn', false);
+              if (verbose) printMessage({
+                message: `\n      - Removing invalid attribute: ${attribute}`,
+                type: 'warn',
+                newline: false,
+                state
+              });
               delete nodeData[attribute];
             }
           }
@@ -1106,20 +1364,34 @@ export async function importJourney({
               state
             });
           } catch (nodeImportError2) {
-            printMessage(nodeImportError2.response.data, 'error');
+            printMessage({
+              message: nodeImportError2.response.data,
+              type: 'error',
+              state
+            });
             throw new Error(`Error importing node ${nodeId}${nodeId === newUuid ? '' : ` [${newUuid}]`} in journey ${treeId}`);
           }
         } else {
-          printMessage(nodeImportError.response.data, 'error');
+          printMessage({
+            message: nodeImportError.response.data,
+            type: 'error',
+            state
+          });
           throw new Error(`Error importing node ${nodeId}${nodeId === newUuid ? '' : ` [${newUuid}]`} in journey ${treeId}`);
         }
       }
-      if (verbose) printMessage('');
+      if (verbose) printMessage({
+        message: '',
+        state
+      });
     }
   }
 
   // Process tree
-  if (verbose) printMessage('  - Flow');
+  if (verbose) printMessage({
+    message: '  - Flow',
+    state
+  });
   if (reUuid) {
     let journeyText = JSON.stringify(treeObject.tree, null, 2);
     for (const [oldId, newId] of Object.entries(uuidMap)) {
@@ -1135,7 +1407,12 @@ export async function importJourney({
     treeObject.tree.identityResource = `managed/${getRealmManagedUser({
       state
     })}`;
-    if (verbose) printMessage(`    - identityResource: ${treeObject.tree.identityResource}`, 'info', false);
+    if (verbose) printMessage({
+      message: `    - identityResource: ${treeObject.tree.identityResource}`,
+      type: 'info',
+      newline: false,
+      state
+    });
   }
   delete treeObject.tree._rev;
   try {
@@ -1144,7 +1421,12 @@ export async function importJourney({
       treeData: treeObject.tree,
       state
     });
-    if (verbose) printMessage(`\n    - Done`, 'info', true);
+    if (verbose) printMessage({
+      message: `\n    - Done`,
+      type: 'info',
+      newline: true,
+      state
+    });
   } catch (importError) {
     var _importError$response6, _importError$response7, _importError$response8;
     if (((_importError$response6 = importError.response) === null || _importError$response6 === void 0 ? void 0 : _importError$response6.status) === 400 && ((_importError$response7 = importError.response) === null || _importError$response7 === void 0 ? void 0 : (_importError$response8 = _importError$response7.data) === null || _importError$response8 === void 0 ? void 0 : _importError$response8.message) === 'Invalid attribute specified.') {
@@ -1154,7 +1436,12 @@ export async function importJourney({
       validAttributes.push('_id');
       for (const attribute of Object.keys(treeObject.tree)) {
         if (!validAttributes.includes(attribute)) {
-          if (verbose) printMessage(`\n    - Removing invalid attribute: ${attribute}`, 'warn', false);
+          if (verbose) printMessage({
+            message: `\n    - Removing invalid attribute: ${attribute}`,
+            type: 'warn',
+            newline: false,
+            state
+          });
           delete treeObject.tree[attribute];
         }
       }
@@ -1164,15 +1451,31 @@ export async function importJourney({
           treeData: treeObject.tree,
           state
         });
-        if (verbose) printMessage(`\n    - Done`, 'info', true);
+        if (verbose) printMessage({
+          message: `\n    - Done`,
+          type: 'info',
+          newline: true,
+          state
+        });
       } catch (importError2) {
-        printMessage(importError2.response.data, 'error');
+        printMessage({
+          message: importError2.response.data,
+          type: 'error',
+          state
+        });
         throw new Error(`Error importing journey flow ${treeId}`);
       }
     } else {
       var _importError$response9, _importError$response10;
-      printMessage(((_importError$response9 = importError.response) === null || _importError$response9 === void 0 ? void 0 : _importError$response9.data) || importError, 'error');
-      debugMessage(((_importError$response10 = importError.response) === null || _importError$response10 === void 0 ? void 0 : _importError$response10.data) || importError);
+      printMessage({
+        message: ((_importError$response9 = importError.response) === null || _importError$response9 === void 0 ? void 0 : _importError$response9.data) || importError,
+        type: 'error',
+        state
+      });
+      debugMessage({
+        message: ((_importError$response10 = importError.response) === null || _importError$response10 === void 0 ? void 0 : _importError$response10.data) || importError,
+        state
+      });
       throw new Error(`\nError importing journey flow ${treeId}`);
     }
   }
@@ -1251,17 +1554,38 @@ export async function importAllJourneys({
   })).result.map(x => x._id);
   const unresolvedJourneys = {};
   const resolvedJourneys = [];
-  createProgressIndicator(undefined, 'Resolving dependencies', 'indeterminate');
+  createProgressIndicator({
+    total: undefined,
+    message: 'Resolving dependencies',
+    type: 'indeterminate',
+    state
+  });
   await resolveDependencies(installedJourneys, treesMap, unresolvedJourneys, resolvedJourneys);
   if (Object.keys(unresolvedJourneys).length === 0) {
-    stopProgressIndicator(`Resolved all dependencies.`, 'success');
+    stopProgressIndicator({
+      message: `Resolved all dependencies.`,
+      status: 'success',
+      state
+    });
   } else {
-    stopProgressIndicator(`${Object.keys(unresolvedJourneys).length} journeys with unresolved dependencies:`, 'fail');
+    stopProgressIndicator({
+      message: `${Object.keys(unresolvedJourneys).length} journeys with unresolved dependencies:`,
+      status: 'fail',
+      state
+    });
     for (const journey of Object.keys(unresolvedJourneys)) {
-      printMessage(`  - ${journey} requires ${unresolvedJourneys[journey]}`, 'info');
+      printMessage({
+        message: `  - ${journey} requires ${unresolvedJourneys[journey]}`,
+        type: 'info',
+        state
+      });
     }
   }
-  createProgressIndicator(resolvedJourneys.length, 'Importing');
+  createProgressIndicator({
+    total: resolvedJourneys.length,
+    message: 'Importing',
+    state
+  });
   for (const tree of resolvedJourneys) {
     try {
       // eslint-disable-next-line no-await-in-loop
@@ -1270,12 +1594,22 @@ export async function importAllJourneys({
         options,
         state
       });
-      updateProgressIndicator(`${tree}`);
+      updateProgressIndicator({
+        message: `${tree}`,
+        state
+      });
     } catch (error) {
-      printMessage(`\n${error.message}`, 'error');
+      printMessage({
+        message: `\n${error.message}`,
+        type: 'error',
+        state
+      });
     }
   }
-  stopProgressIndicator('Done');
+  stopProgressIndicator({
+    message: 'Done',
+    state
+  });
 }
 
 /**
@@ -1314,7 +1648,10 @@ export function getNodeRef(nodeObj, singleTreeExport) {
  * @returns {TreeExportResolverInterface} tree export
  */
 export const onlineTreeExportResolver = async function (treeId, state) {
-  debugMessage(`onlineTreeExportResolver(${treeId})`);
+  debugMessage({
+    message: `onlineTreeExportResolver(${treeId})`,
+    state
+  });
   return await exportJourney({
     treeId,
     options: {
@@ -1332,7 +1669,10 @@ export const onlineTreeExportResolver = async function (treeId, state) {
  * @returns {TreeExportResolverInterface} tree export
  */
 export const fileByIdTreeExportResolver = async function (treeId, state) {
-  debugMessage(`fileByIdTreeExportResolver(${treeId})`);
+  debugMessage({
+    message: `fileByIdTreeExportResolver(${treeId})`,
+    state
+  });
   let treeExport = createSingleTreeExportTemplate({
     state
   });
@@ -1341,7 +1681,10 @@ export const fileByIdTreeExportResolver = async function (treeId, state) {
     var _jsonData$tree;
     const file = files.pop();
     const jsonData = JSON.parse(fs.readFileSync(file, 'utf8'));
-    debugMessage(`fileByIdTreeExportResolver: resolved '${treeId}' to ${file}`);
+    debugMessage({
+      message: `fileByIdTreeExportResolver: resolved '${treeId}' to ${file}`,
+      state
+    });
     // did we resolve the tree we were asked to resolved?
     if (((_jsonData$tree = jsonData.tree) === null || _jsonData$tree === void 0 ? void 0 : _jsonData$tree._id) === treeId) {
       treeExport = jsonData;
@@ -1351,7 +1694,10 @@ export const fileByIdTreeExportResolver = async function (treeId, state) {
       treeExport = jsonData.trees[treeId];
     }
   } catch (error) {
-    debugMessage(`fileByIdTreeExportResolver: unable to resolve '${treeId}' to a file.`);
+    debugMessage({
+      message: `fileByIdTreeExportResolver: unable to resolve '${treeId}' to a file.`,
+      state
+    });
   }
   return treeExport;
 };
@@ -1364,7 +1710,10 @@ export const fileByIdTreeExportResolver = async function (treeId, state) {
  */
 export function createFileParamTreeExportResolver(file, state) {
   const fileParamTreeExportResolver = async function (treeId) {
-    debugMessage(`fileParamTreeExportResolver(${treeId})`);
+    debugMessage({
+      message: `fileParamTreeExportResolver(${treeId})`,
+      state
+    });
     let treeExport = createSingleTreeExportTemplate({
       state
     });
@@ -1388,7 +1737,10 @@ export function createFileParamTreeExportResolver(file, state) {
     }
     return treeExport;
   };
-  debugMessage(`fileParamTreeExportResolver: file=${file}`);
+  debugMessage({
+    message: `fileParamTreeExportResolver: file=${file}`,
+    state
+  });
   return fileParamTreeExportResolver;
 }
 
@@ -1405,7 +1757,10 @@ export async function getTreeDescendents({
   resolvedTreeIds = [],
   state
 }) {
-  debugMessage(`getTreeDependencies(${treeExport.tree._id}, [${resolvedTreeIds.join(', ')}])`);
+  debugMessage({
+    message: `getTreeDependencies(${treeExport.tree._id}, [${resolvedTreeIds.join(', ')}])`,
+    state
+  });
   if (!resolvedTreeIds.includes(treeExport.tree._id)) {
     resolvedTreeIds.push(treeExport.tree._id);
   }
@@ -1417,7 +1772,10 @@ export async function getTreeDescendents({
     const innerTreeId = treeExport.nodes[nodeId].tree;
     if (node.nodeType === 'InnerTreeEvaluatorNode' && !resolvedTreeIds.includes(innerTreeId)) {
       const innerTreeExport = await resolveTreeExport(innerTreeId, state);
-      debugMessage(`resolved inner tree: ${innerTreeExport.tree._id}`);
+      debugMessage({
+        message: `resolved inner tree: ${innerTreeExport.tree._id}`,
+        state
+      });
       // resolvedTreeIds.push(innerTreeId);
       dependencies.push(await getTreeDescendents({
         treeExport: innerTreeExport,
@@ -1446,14 +1804,27 @@ export async function findOrphanedNodes({
   })).result;
   let errorMessage = '';
   const errorTypes = [];
-  createProgressIndicator(undefined, `Counting total nodes...`, 'indeterminate');
+  createProgressIndicator({
+    total: undefined,
+    message: `Counting total nodes...`,
+    type: 'indeterminate',
+    state
+  });
   try {
     types = (await getNodeTypes({
       state
     })).result;
   } catch (error) {
-    printMessage('Error retrieving all available node types:', 'error');
-    printMessage(error.response.data, 'error');
+    printMessage({
+      message: 'Error retrieving all available node types:',
+      type: 'error',
+      state
+    });
+    printMessage({
+      message: error.response.data,
+      type: 'error',
+      state
+    });
     return [];
   }
   for (const type of types) {
@@ -1465,26 +1836,48 @@ export async function findOrphanedNodes({
       })).result;
       for (const node of nodes) {
         allNodes.push(node);
-        updateProgressIndicator(`${allNodes.length} total nodes${errorMessage}`);
+        updateProgressIndicator({
+          message: `${allNodes.length} total nodes${errorMessage}`,
+          state
+        });
       }
     } catch (error) {
       errorTypes.push(type._id);
       errorMessage = ` (Skipped type(s): ${errorTypes})`['yellow'];
-      updateProgressIndicator(`${allNodes.length} total nodes${errorMessage}`);
+      updateProgressIndicator({
+        message: `${allNodes.length} total nodes${errorMessage}`,
+        state
+      });
     }
   }
   if (errorTypes.length > 0) {
-    stopProgressIndicator(`${allNodes.length} total nodes${errorMessage}`, 'warn');
+    stopProgressIndicator({
+      message: `${allNodes.length} total nodes${errorMessage}`,
+      state,
+      status: 'warn'
+    });
   } else {
-    stopProgressIndicator(`${allNodes.length} total nodes`, 'success');
+    stopProgressIndicator({
+      message: `${allNodes.length} total nodes`,
+      status: 'success',
+      state
+    });
   }
-  createProgressIndicator(undefined, 'Counting active nodes...', 'indeterminate');
+  createProgressIndicator({
+    total: undefined,
+    message: 'Counting active nodes...',
+    type: 'indeterminate',
+    state
+  });
   const activeNodes = [];
   for (const journey of allJourneys) {
     for (const nodeId in journey.nodes) {
       if ({}.hasOwnProperty.call(journey.nodes, nodeId)) {
         activeNodes.push(nodeId);
-        updateProgressIndicator(`${activeNodes.length} active nodes`);
+        updateProgressIndicator({
+          message: `${activeNodes.length} active nodes`,
+          state
+        });
         const node = journey.nodes[nodeId];
         if (containerNodes.includes(node.nodeType)) {
           const containerNode = await getNode({
@@ -1494,19 +1887,35 @@ export async function findOrphanedNodes({
           });
           for (const innerNode of containerNode.nodes) {
             activeNodes.push(innerNode._id);
-            updateProgressIndicator(`${activeNodes.length} active nodes`);
+            updateProgressIndicator({
+              message: `${activeNodes.length} active nodes`,
+              state
+            });
           }
         }
       }
     }
   }
-  stopProgressIndicator(`${activeNodes.length} active nodes`, 'success');
-  createProgressIndicator(undefined, 'Calculating orphaned nodes...', 'indeterminate');
+  stopProgressIndicator({
+    message: `${activeNodes.length} active nodes`,
+    status: 'success',
+    state
+  });
+  createProgressIndicator({
+    total: undefined,
+    message: 'Calculating orphaned nodes...',
+    type: 'indeterminate',
+    state
+  });
   const diff = allNodes.filter(x => !activeNodes.includes(x._id));
   for (const orphanedNode of diff) {
     orphanedNodes.push(orphanedNode);
   }
-  stopProgressIndicator(`${orphanedNodes.length} orphaned nodes`, 'success');
+  stopProgressIndicator({
+    message: `${orphanedNodes.length} orphaned nodes`,
+    status: 'success',
+    state
+  });
   return orphanedNodes;
 }
 
@@ -1520,9 +1929,16 @@ export async function removeOrphanedNodes({
   state
 }) {
   const errorNodes = [];
-  createProgressIndicator(orphanedNodes.length, 'Removing orphaned nodes...');
+  createProgressIndicator({
+    total: orphanedNodes.length,
+    message: 'Removing orphaned nodes...',
+    state
+  });
   for (const node of orphanedNodes) {
-    updateProgressIndicator(`Removing ${node['_id']}...`);
+    updateProgressIndicator({
+      message: `Removing ${node['_id']}...`,
+      state
+    });
     try {
       // eslint-disable-next-line no-await-in-loop
       await deleteNode({
@@ -1532,10 +1948,17 @@ export async function removeOrphanedNodes({
       });
     } catch (deleteError) {
       errorNodes.push(node);
-      printMessage(` ${deleteError}`, 'error');
+      printMessage({
+        message: ` ${deleteError}`,
+        type: 'error',
+        state
+      });
     }
   }
-  stopProgressIndicator(`Removed ${orphanedNodes.length} orphaned nodes.`);
+  stopProgressIndicator({
+    message: `Removed ${orphanedNodes.length} orphaned nodes.`,
+    state
+  });
   return errorNodes;
 }
 
@@ -1639,15 +2062,26 @@ export async function deleteJourney({
   const status = {
     nodes: {}
   };
-  if (progress) createProgressIndicator(undefined, `Deleting ${journeyId}...`, 'indeterminate');
-  if (progress && verbose) stopProgressIndicator();
+  if (progress) createProgressIndicator({
+    total: undefined,
+    message: `Deleting ${journeyId}...`,
+    type: 'indeterminate',
+    state
+  });
+  if (progress && verbose) stopProgressIndicator({
+    state
+  });
   return deleteTree({
     treeId: journeyId,
     state
   }).then(async deleteTreeResponse => {
     status['status'] = 'success';
     const nodePromises = [];
-    if (verbose) printMessage(`Deleted ${journeyId} (tree)`, 'info');
+    if (verbose) printMessage({
+      message: `Deleted ${journeyId} (tree)`,
+      type: 'info',
+      state
+    });
     if (deep) {
       for (const [nodeId, nodeObject] of Object.entries(deleteTreeResponse.nodes)) {
         // delete inner nodes (nodes inside container nodes)
@@ -1659,7 +2093,11 @@ export async function deleteJourney({
               nodeType: nodeObject['nodeType'],
               state
             });
-            if (verbose) printMessage(`Read ${nodeId} (${nodeObject['nodeType']}) from ${journeyId}`, 'info');
+            if (verbose) printMessage({
+              message: `Read ${nodeId} (${nodeObject['nodeType']}) from ${journeyId}`,
+              type: 'info',
+              state
+            });
             for (const innerNodeObject of containerNode.nodes) {
               nodePromises.push(deleteNode({
                 nodeId: innerNodeObject._id,
@@ -1669,14 +2107,22 @@ export async function deleteJourney({
                 status.nodes[innerNodeObject._id] = {
                   status: 'success'
                 };
-                if (verbose) printMessage(`Deleted ${innerNodeObject._id} (${innerNodeObject.nodeType}) from ${journeyId}`, 'info');
+                if (verbose) printMessage({
+                  message: `Deleted ${innerNodeObject._id} (${innerNodeObject.nodeType}) from ${journeyId}`,
+                  type: 'info',
+                  state
+                });
                 return response2;
               }).catch(error => {
                 status.nodes[innerNodeObject._id] = {
                   status: 'error',
                   error
                 };
-                if (verbose) printMessage(`Error deleting inner node ${innerNodeObject._id} (${innerNodeObject.nodeType}) from ${journeyId}: ${error}`, 'error');
+                if (verbose) printMessage({
+                  message: `Error deleting inner node ${innerNodeObject._id} (${innerNodeObject.nodeType}) from ${journeyId}: ${error}`,
+                  type: 'error',
+                  state
+                });
               }));
             }
             // finally delete the container node
@@ -1688,7 +2134,11 @@ export async function deleteJourney({
               status.nodes[containerNode._id] = {
                 status: 'success'
               };
-              if (verbose) printMessage(`Deleted ${containerNode._id} (${containerNode['_type']['_id']}) from ${journeyId}`, 'info');
+              if (verbose) printMessage({
+                message: `Deleted ${containerNode._id} (${containerNode['_type']['_id']}) from ${journeyId}`,
+                type: 'info',
+                state
+              });
               return response2;
             }).catch(error => {
               var _error$response, _error$response$data;
@@ -1696,17 +2146,29 @@ export async function deleteJourney({
                 status.nodes[containerNode._id] = {
                   status: 'success'
                 };
-                if (verbose) printMessage(`Deleted ${containerNode._id} (${containerNode['_type']['_id']}) from ${journeyId}`, 'info');
+                if (verbose) printMessage({
+                  message: `Deleted ${containerNode._id} (${containerNode['_type']['_id']}) from ${journeyId}`,
+                  type: 'info',
+                  state
+                });
               } else {
                 status.nodes[containerNode._id] = {
                   status: 'error',
                   error
                 };
-                if (verbose) printMessage(`Error deleting container node ${containerNode._id} (${containerNode['_type']['_id']}) from ${journeyId}: ${error.response.data.message}`, 'error');
+                if (verbose) printMessage({
+                  message: `Error deleting container node ${containerNode._id} (${containerNode['_type']['_id']}) from ${journeyId}: ${error.response.data.message}`,
+                  type: 'error',
+                  state
+                });
               }
             }));
           } catch (error) {
-            if (verbose) printMessage(`Error getting container node ${nodeId} (${nodeObject['nodeType']}) from ${journeyId}: ${error}`, 'error');
+            if (verbose) printMessage({
+              message: `Error getting container node ${nodeId} (${nodeObject['nodeType']}) from ${journeyId}: ${error}`,
+              type: 'error',
+              state
+            });
           }
         } else {
           // delete the node
@@ -1718,14 +2180,22 @@ export async function deleteJourney({
             status.nodes[nodeId] = {
               status: 'success'
             };
-            if (verbose) printMessage(`Deleted ${nodeId} (${nodeObject['nodeType']}) from ${journeyId}`, 'info');
+            if (verbose) printMessage({
+              message: `Deleted ${nodeId} (${nodeObject['nodeType']}) from ${journeyId}`,
+              type: 'info',
+              state
+            });
             return response;
           }).catch(error => {
             status.nodes[nodeId] = {
               status: 'error',
               error
             };
-            if (verbose) printMessage(`Error deleting node ${nodeId} (${nodeObject['nodeType']}) from ${journeyId}: ${error}`, 'error');
+            if (verbose) printMessage({
+              message: `Error deleting node ${nodeId} (${nodeObject['nodeType']}) from ${journeyId}: ${error}`,
+              type: 'error',
+              state
+            });
           }));
         }
       }
@@ -1742,17 +2212,33 @@ export async function deleteJourney({
         if (status.nodes[node].status === 'error') errorCount += 1;
       }
       if (errorCount === 0) {
-        stopProgressIndicator(`Deleted ${journeyId} and ${nodeCount - errorCount}/${nodeCount} nodes.`, 'success');
+        stopProgressIndicator({
+          message: `Deleted ${journeyId} and ${nodeCount - errorCount}/${nodeCount} nodes.`,
+          status: 'success',
+          state
+        });
       } else {
-        stopProgressIndicator(`Deleted ${journeyId} and ${nodeCount - errorCount}/${nodeCount} nodes.`, 'fail');
+        stopProgressIndicator({
+          message: `Deleted ${journeyId} and ${nodeCount - errorCount}/${nodeCount} nodes.`,
+          status: 'fail',
+          state
+        });
       }
     }
     return status;
   }).catch(error => {
     status['status'] = 'error';
     status['error'] = error;
-    stopProgressIndicator(`Error deleting ${journeyId}.`, 'fail');
-    if (verbose) printMessage(`Error deleting tree ${journeyId}: ${error}`, 'error');
+    stopProgressIndicator({
+      message: `Error deleting ${journeyId}.`,
+      status: 'fail',
+      state
+    });
+    if (verbose) printMessage({
+      message: `Error deleting tree ${journeyId}: ${error}`,
+      type: 'error',
+      state
+    });
     return status;
   });
 }
@@ -1772,16 +2258,26 @@ export async function deleteJourneys({
   const trees = (await getTrees({
     state
   })).result;
-  createProgressIndicator(trees.length, 'Deleting journeys...');
+  createProgressIndicator({
+    total: trees.length,
+    message: 'Deleting journeys...',
+    state
+  });
   for (const tree of trees) {
-    if (verbose) printMessage('');
+    if (verbose) printMessage({
+      message: '',
+      state
+    });
     options['progress'] = false;
     status[tree._id] = await deleteJourney({
       journeyId: tree._id,
       options,
       state
     });
-    updateProgressIndicator(`${tree._id}`);
+    updateProgressIndicator({
+      message: `${tree._id}`,
+      state
+    });
     // introduce a 100ms wait to allow the progress bar to update before the next verbose message prints from the async function
     if (verbose)
       // eslint-disable-next-line no-await-in-loop
@@ -1801,7 +2297,10 @@ export async function deleteJourneys({
       if (status[journey].nodes[node].status === 'error') nodeErrorCount += 1;
     }
   }
-  stopProgressIndicator(`Deleted ${journeyCount - journeyErrorCount}/${journeyCount} journeys and ${nodeCount - nodeErrorCount}/${nodeCount} nodes.`);
+  stopProgressIndicator({
+    message: `Deleted ${journeyCount - journeyErrorCount}/${journeyCount} journeys and ${nodeCount - nodeErrorCount}/${nodeCount} nodes.`,
+    state
+  });
   return status;
 }
 
@@ -1828,7 +2327,11 @@ export async function enableJourney({
     });
     return newTreeObject['enabled'] === true;
   } catch (error) {
-    printMessage(error.response.data, 'error');
+    printMessage({
+      message: error.response.data,
+      type: 'error',
+      state
+    });
     return false;
   }
 }
@@ -1856,7 +2359,11 @@ export async function disableJourney({
     });
     return newTreeObject['enabled'] === false;
   } catch (error) {
-    printMessage(error.response.data, 'error');
+    printMessage({
+      message: error.response.data,
+      type: 'error',
+      state
+    });
     return false;
   }
 }