@pega/custom-dx-components 0.24.17 → 0.25.2

package/src/util.js

@@ -1,9 +1,13 @@
 import fs from 'fs';
+import path from 'path';
 import { join } from 'path';
 import { promisify } from 'util';
 import https from 'https';
 import crypto from 'node:crypto';
 import { createRequire } from 'module';
+import {jwtDecode} from 'jwt-decode';
+import archiver from 'archiver';
+import {unarchive} from 'unarchive';
 
 import chalk from 'chalk';
 import mustache from 'mustache';
@@ -14,30 +18,184 @@ import fetch from 'node-fetch';
 import * as currentPath from './currentPath.cjs';
 import {
   COMPONENTS_DIRECTORY_PATH,
+  COMPONENTS_CONFIG_FILE_NAME,
   TASKS_CONFIG_JSON_FILENAME,
+  PACKAGE_JSON_FILENAME,
   TOKEN_PATH,
   OOTB_COMPONENT_SERVICE_REST_ENDPOINT,
   DELETE_COMPONENT_SERVICE_REST_ENDPOINT,
   LP_DELETE_COMPONENT_SERVICE_REST_ENDPOINT,
   OOTB_COMPONENTS,
-  USE_PROMOTED_WEB_PACK
+  USE_PROMOTED_WEB_PACK,
+  BOOTSTRAP_CONFIG,
+  LIBRARY_BASED,
+  SHARED_DIRECTORY,
+  SHOW_DEBUG,
+  COMPONENTS_PATH,
+  ARCHIVES_PATH,
+  BIN_ARCHIVES_PATH,
+  TEMP_PATH,
+  JEST_TESTS_FUNCTIONAL_PATH,
+  IMPORT_RELATIVE_PATH,
+  EXPORT_RELATIVE_PATH
 } from './constants.js';
 
+
 const access = promisify(fs.access);
 
+let showDebug = false;
+let debugLevel = 1;
+let haveDependencyDifference = false;
+let addAboutData = true;
+
+
+// updated upon start
+let defaultConfigs = {
+  serverType: "",
+  isLibraryBased: false,
+  devBuild: true,
+  library: "",
+  organization: "",
+  currentOrgLib: "",
+  version: "",
+  buildVersion: "",
+  displayLibVersion: "",
+  showDebug: false,
+  importRelativePath: "",
+  exportRelativePath: ""
+};
+
+let pegaConfig = null;
+let pegaData = null;
+let sPegaData;
+let sPegaServerConfig;
+
+export const modAddAboutData = (addInAboutData) => {
+  // used by jest to not put in to match assets without aboutData
+  addAboutData = addInAboutData;
+}
+
+export const addDebugLog = (sFunctionName, sLogData, sIncDec) => {
+
+  let sLog;
+  if (showDebug) {
+      if (sIncDec === "-") {
+          debugLevel--;
+      }
+
+      sLog = `>> log ${debugLevel} `;
+
+      for (let i =0; i < debugLevel; i++) {
+          sLog = sLog.concat("-");
+      }
+
+      sLog = sLog.concat(sFunctionName).concat(": ").concat(sLogData);
+
+      console.log(`${chalk.hex('#A0522D')(sLog)}`);
+
+      if (sIncDec === "+") {
+          debugLevel++;
+      }
+
+  }
+}
+
+export const setUpDefaults = async () => {
+
+  // defaults, start up function will set these up
+  // so that won't have to continously hit files to get data
+  // thus saving time.
+  let retrievedConfigData = {
+    serverType: "",
+    isLibraryBased: false,
+    devBuild: true,
+    library: "",
+    organization: "",
+    currentOrgLib: "",
+    version: "",
+    buildVersion: "",
+    displayLibVersion: "",
+    showDebug: false,
+    importRelativePath: "",
+    exportRelativePath: ""
+  };
+
+  // retrievedConfigData
+  const currentDirectory = process.cwd();
+  const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
+
+  try {
+    // force to throw error and not console log
+    await checkPathAccess(pegaConfigJsonPath, {}, true);
+
+    let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
+    data = JSON.parse(data);
+
+    if (data[IMPORT_RELATIVE_PATH]) {
+      retrievedConfigData.importRelativePath = data[IMPORT_RELATIVE_PATH];
+    }
+
+
+    if (data[EXPORT_RELATIVE_PATH]) {
+      retrievedConfigData.exportRelativePath = data[EXPORT_RELATIVE_PATH];
+    }
+
+    if (data[LIBRARY_BASED]) {
+      retrievedConfigData.isLibraryBased = data[LIBRARY_BASED];
+    }
+    retrievedConfigData.library = data.component.library;
+    retrievedConfigData.version = data.component.version;
+
+
+    const { organization } = JSON.parse(fs.readFileSync(path.resolve('package.json'), 'utf8'));
+    retrievedConfigData.organization = organization;
+
+    if (data["showDebug"]) {
+      retrievedConfigData.showDebug = data.showDebug;
+      showDebug = data.showDebug;
+    }
+
+    retrievedConfigData.serverType = data["server-config"].serverType;
+    retrievedConfigData.devBuild = data["server-config"].devBuild;
+
+    retrievedConfigData.buildVersion = retrievedConfigData.devBuild ? `${retrievedConfigData.version}-dev` : retrievedConfigData.version;
+    retrievedConfigData.currentOrgLib = `${retrievedConfigData.organization}_${retrievedConfigData.library}`;
+    retrievedConfigData.displayLibVersion = `${retrievedConfigData.currentOrgLib }/${retrievedConfigData.buildVersion}`;
+
+  }
+  catch (ex) {
+    // when can't find it, always be false, assume no library based.
+    // This is IMPORTANT for init (npx install)
+    return false;
+  }
+
+  return JSON.parse(JSON.stringify(retrievedConfigData));
+}
+
+// initialize
+// await setUpDefaults();
+
 export const checkPathAccess = async (path, options = {}, throwError = false) => {
+
+
   const { errorMessage } = options;
 
   try {
     await access(path, fs.constants.R_OK);
   } catch (err) {
     if (throwError) {
+if (showDebug) addDebugLog("checkPathAccess", "path: ".concat(path), "+");
+if (showDebug) addDebugLog("checkPathAccess", "Error: ".concat(err), "");
+if (showDebug) addDebugLog("checkPathAccess", "END", "-");
       throw new Error(err);
+
     }
     else {
+if (showDebug) addDebugLog("checkPathAccess", "path: ".concat(path), "+");
       const message =
         errorMessage || `${chalk.red.bold('ERROR')} Could not able to access path - ${path}`;
       console.error(message);
+if (showDebug) addDebugLog("checkPathAccess", "END", "-");
       process.exit(1);
     }
 
@@ -45,6 +203,7 @@ export const checkPathAccess = async (path, options = {}, throwError = false) =>
 };
 
 export const getUseWebPackPromotion = async () => {
+if (showDebug) addDebugLog("getUseWebPackPromotion", "", "");
   const currentDirectory = process.cwd();
   const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
 
@@ -79,6 +238,8 @@ export const getUseWebPackPromotion = async () => {
 }
 
 export const updateUseWebPackPromotion = async ( useValue = false ) => {
+if (showDebug) addDebugLog("updateUseWebPackPromotion", "", "");
+
   const currentDirectory = process.cwd();
   const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
 
@@ -96,11 +257,149 @@ export const updateUseWebPackPromotion = async ( useValue = false ) => {
 
   data["usePromotedWebPack"] = useValue;
 
-  fs.writeFileSync(pegaConfigJsonPath, JSON.stringify(data, null, 4), { encoding: 'utf8' });
+  fs.writeFileSync(pegaConfigJsonPath, JSON.stringify(data, null, 4), { encoding: 'utf8',flag:'w' });
+
+}
+
+export const getAboutData = async (currentOrgLib, buildVersion, dateStamp) => {
+if (showDebug) addDebugLog("getAboutData", `currentOrgLib: ${currentOrgLib}, buildVersion: ${buildVersion}, dateStamp: ${dateStamp}`)
+  const tokenAndStaticServer = await getC11NB2STokenAndStaticServer();
+
+  if (tokenAndStaticServer.C11NB2S === undefined) {
+    // console.log(chalk.yellowBright("Need to authenticate, missing services token.\nLibrary requires authentication to acquire a token to build."));
+    return `${currentOrgLib} ${buildVersion}, ${dateStamp}`;
+  }
+
+  const jwt = jwtDecode(tokenAndStaticServer.C11NB2S);
+  let infinityVersion= jwt.infinity_version;
+  infinityVersion = infinityVersion.replace("8.", "");
+
+  return `${currentOrgLib} ${buildVersion}, ${dateStamp}, ${infinityVersion}`;
+}
+
+export const checkJWTExpiration = async () => {
+  const tokenAndStaticServer = await getC11NB2STokenAndStaticServer();
+
+  if (tokenAndStaticServer.C11NB2S === undefined) {
+    console.log(chalk.redBright("Need to authenticate, missing services token.\nBuilding a library requires authentication to acquire a token to build."));
+    process.exit(1);
+  }
+
+  const jwt = jwtDecode(tokenAndStaticServer.C11NB2S);
+  const  { exp, customer_org } = jwt;
+  if (exp < (new Date().getTime() + 1) / 1000) {
+    console.log(chalk.redBright("JWT token has expired, please reauthenticate."));
+    process.exit(1);
+  }
+
+  // check that there is customer_org
+  if (!customer_org || customer_org === "") {
+    console.log(chalk.red(`PegaInfinity server DSS setting ${chalk.redBright.bold(`C11nCCv2CustomerOrg`)} is NOT set.`));
+    console.log(chalk.red("Please update DSS setting, save and then reauthenticate."));
+    process.exit(1);
+  }
+
+}
+
+export const getLibraryBased = () => {
+if (showDebug) addDebugLog("getLibraryBased", "", "");
+//   const currentDirectory = process.cwd();
+//   const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
+
+//   try {
+//     // force to throw error and not console log
+//     await checkPathAccess(pegaConfigJsonPath, {}, true);
+//   }
+//   catch (ex) {
+//     // when can't find it, always be false, assume no library based.
+//     // This is IMPORTANT for init (npx install)
+//     return false;
+//   }
+
+//   let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
+//   data = JSON.parse(data);
+
+//   if (data[LIBRARY_BASED]) {
+// if (showDebug) addDebugLog("getLibraryBased", `based: ${data[LIBRARY_BASED]}`, "");
+// if (showDebug) addDebugLog("getLibraryBased", "END", "-");
+//     return data[LIBRARY_BASED];
+//   }
+//   else {
+// if (showDebug) addDebugLog("getLibraryBased", "END", "-");
+//     return false;
+//   }
+
+  return defaultConfigs.isLibraryBased;
+}
+
+export const setLibraryBased = async (isLibraryBased) => {
+if (showDebug) addDebugLog("setLibraryBased", "", "");
+  const currentDirectory = process.cwd();
+  const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
+
+  try {
+    // force to throw error and not console log
+    await checkPathAccess(pegaConfigJsonPath, {}, true);
+  }
+  catch (ex) {
+    // when can't find it, always be false, assume no library based.
+    // This is IMPORTANT for init (npx install)
+    return false;
+  }
+
+  let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
+  data = JSON.parse(data);
+
+  if (data[LIBRARY_BASED] != undefined) {
+    data[LIBRARY_BASED] = isLibraryBased;
+
+    // update file
+    // stringify "4", makes the json string look like JSON in the file, formated instead of a single line
+    try {
+      fs.writeFileSync(pegaConfigJsonPath, JSON.stringify(data, null, 4), { encoding: 'utf8',flag:'w' });
+    }
+    catch (err) {
+      console.error(err);
+    }
+    //await forceDefaultsUpdate();
+    defaultConfigs.isLibraryBased = isLibraryBased;
+
+    // reset
+    pegaData = null;
+    pegaConfig = null;
+
+  }
+
+}
+
+export const getShowDebug = () => {
+  // const currentDirectory = process.cwd();
+  // const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
+
+  // try {
+  //   // force to throw error and not console log
+  //   await checkPathAccess(pegaConfigJsonPath, {}, true);
+  // }
+  // catch (ex) {
+  //   // when can't find it, always be false, assume no library based.
+  //   // This is IMPORTANT for init (npx install)
+  //   return false;
+  // }
+
+  // let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
+  // data = JSON.parse(data);
+
+  // if (data[SHOW_DEBUG]) {
+  //   return data[SHOW_DEBUG];
+  // }
+  // else return false;
+  return defaultConfigs.showDebug;
 
 }
 
+
 export const deleteLocalComponent = async componentKey => {
+if (showDebug) addDebugLog("deleteLocalComponent", `componentKey: ${componentKey}`, "");
   const currentDirectory = process.cwd();
   const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
 
@@ -136,6 +435,7 @@ export const getHttpsAgent = serverConfig => {
 };
 
 export const deleteServerComponent = async componentKey => {
+if (showDebug) addDebugLog("deleteServerComponent", `componentKey: ${componentKey}`, "");
   const serverConfig = await getPegaServerConfig();
   const { server, user, password } = serverConfig;
   const url = constructCompleteUrl(server, DELETE_COMPONENT_SERVICE_REST_ENDPOINT);
@@ -180,7 +480,8 @@ export const deleteServerComponent = async componentKey => {
   }
 };
 
-export const getComponents = async () => {
+export const copyFileToShared = async ( fileName, fileContents) => {
+if (showDebug) addDebugLog("copyFileToShared", `fileName: ${fileName}`, "");
   const currentDirectory = process.cwd();
   const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
 
@@ -198,13 +499,201 @@ export const getComponents = async () => {
   }
 
   const directory = join(currentDirectory, data[COMPONENTS_DIRECTORY_PATH]);
+  const sharedDirectory = join(directory, SHARED_DIRECTORY);
+
+  // if shared doesn't exist, create it
+  if (!fs.existsSync(sharedDirectory)) {
+    fs.mkdirSync(sharedDirectory, { recursive: true });
+  }
+
+  const filePath = join(sharedDirectory, fileName);
+  if (!fs.existsSync(filePath)) {
+    fs.writeFileSync(filePath, fileContents);
+  }
+
+
+};
+
+export const getComponents = async (overrideDirectory = null) => {
+if (showDebug) addDebugLog("getComponents", "", "");
+  const currentDirectory = process.cwd();
+  const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
+
+  await checkPathAccess(pegaConfigJsonPath);
+
+  let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
+
+  data = JSON.parse(data);
+
+  if (!data[COMPONENTS_DIRECTORY_PATH]) {
+    console.error(
+      `${chalk.red.bold('ERROR')} Could not find components directory path in config.json`
+    );
+    process.exit(1);
+  }
+
+  const directory = overrideDirectory || join(currentDirectory, data[COMPONENTS_DIRECTORY_PATH]);
+
   return fs
     .readdirSync(directory, { withFileTypes: true })
-    .filter(dirent => dirent.isDirectory())
+    .filter(dirent => dirent.isDirectory() && dirent.name !== SHARED_DIRECTORY)
     .map(dirent => dirent.name);
 };
 
+export const getTopLevelConfigFiles = async (directory) => {
+if (showDebug) addDebugLog("getTopLevelConfigFiles", `directory: ${directory}`, "");
+  if (fs.existsSync(directory)) {
+    return fs
+    .readdirSync(directory, { withFileTypes: true })
+    .filter(dirent => !dirent.isDirectory())
+    .map(dirent => dirent.name);
+  }
+  else {
+    return [];
+  }
+}
+
+export const removeTopLevelConfigFiles = async (directory) => {
+if (showDebug) addDebugLog("removeTopLevelConfigFiles", `directory: ${directory}`, "");
+  const configFiles = await getTopLevelConfigFiles(directory);
+
+  if (configFiles && configFiles.length > 0) {
+    for (const configF of configFiles) {
+      // don't remove these files, otherwise, remove it
+      if (configF !== "package-lock.json" &&
+          configF !== "package.json" &&
+          configF !== "tasks.config.json" &&
+          configF !== ".gitignore" &&
+          configF !== ".npmrc" &&
+          configF !== ".prettierignore") {
+        fs.rmSync( join(directory, configF), { recursive: true, force: true, maxRetries: 2 });
+      }
+    }
+  }
+}
+
+export const restoreTopLevelConfigFiles = async(directory) => {
+if (showDebug) addDebugLog("restoreTopLevelConfigFiles", `directory: ${directory}`, "");
+  const currentDirectory = process.cwd();
+  const tempDirectory = join(currentDirectory, TEMP_PATH);
+  const configFiles = await getTopLevelConfigFiles(tempDirectory);
+
+  if (configFiles && configFiles.length > 0) {
+    for (const configF of configFiles) {
+      if (configF !== "package-lock.json" && configF !== "package.json") {
+        fs.copyFileSync(join(tempDirectory, configF), join(directory, configF));
+      }
+    }
+  }
+}
+
+export const getTemplateConfigFiles = async () => {
+if (showDebug) addDebugLog("getTemplateConfigFiles", ``, "");
+  const currentDirectory = process.cwd();
+  const initDir = join(currentDirectory, "node_modules", "@pega", "custom-dx-components", "src", "tasks", "init");
+  const templateDir = join(initDir, "template");
+
+  if (fs.existsSync(templateDir)) {
+    return fs
+    .readdirSync(templateDir, { withFileTypes: true })
+    .filter(dirent => !dirent.isDirectory())
+    .map(dirent => dirent.name);
+  }
+  else {
+    return [];
+  }
+
+}
+
+export const restoreTopLevelConfigFilesFromTemplate = async(clearDep = true) => {
+if (showDebug) addDebugLog("restoreTopLevelConfigFilesFromTemplate", ``, "");
+  // we can't loose devDep that is part of install, so go get the template mustache and push
+  // those in, replacing any changes there, but allowing additional, an keeping it updated
+  // so won't loose new function if an old archive
+  const currentDirectory = process.cwd();
+  const initDir = join(currentDirectory, "node_modules", "@pega", "custom-dx-components", "src", "tasks", "init");
+  const templateDir = join(initDir, "template");
+  const packageTemplateJsonPath = path.join(templateDir, 'package.json.mustache');
+
+  const currentPackagePath = join(currentDirectory, PACKAGE_JSON_FILENAME);
+  let currentPackageData;
+
+  // reset
+  haveDependencyDifference = false;
+
+  try {
+    currentPackageData = fs.readFileSync(currentPackagePath);
+  }
+  catch (ex) {
+    console.log($chalk.red(`\nUnable to retrieve current package.json.`))
+    process.exit(1);
+  }
+  let cData = JSON.parse(currentPackageData);
+
+  let retrievedTemplateData;
+  try {
+    retrievedTemplateData = fs.readFileSync(packageTemplateJsonPath);
+  }
+  catch (ex) {
+    console.log($chalk.red(`\nUnable to retrieve package.json.mustache from code.`))
+    process.exit(1);
+  }
+
+  // copy template dependecies and devDependencies
+  const tData = JSON.parse(retrievedTemplateData);
+
+
+  // check to see if any dependency changes
+  const sDep = JSON.stringify(tData.dependencies);
+  const sDevDep = JSON.stringify(tData.devDependencies);
+
+  const sCurDep = JSON.stringify(cData.dependencies);
+  const sCurDevDep = JSON.stringify(cData.devDependencies);
+
+  // any changes, update haveDependencyDifference variable
+  if (sDep != sCurDep) {
+    haveDependencyDifference = true;
+  }
+  else if (sDevDep != sCurDevDep) {
+    haveDependencyDifference = true;
+  }
+
+  await removeTopLevelConfigFiles(currentDirectory);
+
+
+  // clear out
+  if (clearDep) {
+    cData.dependencies = {};
+    cData.devDependencies = {};
+  }
+
+
+  const tDep = tData.dependencies;
+  for (const [key, value] of Object.entries(tDep)) {
+    cData.dependencies[key] = value;
+  }
+  const tDevDep = tData.devDependencies;
+  for (const [key, value] of Object.entries(tDevDep)) {
+    cData.devDependencies[key] = value;
+  }
+
+  // update current package json file
+  fs.writeFileSync(currentPackagePath, JSON.stringify(cData, null, 4), { encoding: 'utf8',flag:'w' });
+
+  // restore from template
+  const templateFiles = await getTemplateConfigFiles();
+  if (templateFiles && templateFiles.length > 0) {
+    for (const tFile of templateFiles) {
+      if (tFile !== "package.json.mustache" && tFile !== "templateNPMRC.txt" && tFile !== "tasks.config.json") {
+        fs.copyFileSync(join(templateDir, tFile), join(currentDirectory, tFile));
+      }
+    }
+  }
+
+}
+
 export const getSubComponents = async (directory, type) => {
+if (showDebug) addDebugLog("getDirectoryFiles", `directory: ${directory}, type: ${type}`, "");
   const subDirectory = join(directory, type);
   return fs
     .readdirSync(subDirectory, { withFileTypes: true })
@@ -213,6 +702,7 @@ export const getSubComponents = async (directory, type) => {
 };
 
 export const getDirectoryFiles = async directory => {
+if (showDebug) addDebugLog("getDirectoryFiles", `directory: ${directory}`, "");
   return fs
     .readdirSync(directory, { withFileTypes: true })
     .filter(dirent => !dirent.isDirectory())
@@ -220,6 +710,7 @@ export const getDirectoryFiles = async directory => {
 };
 
 export const getComponentsObj = async () => {
+if (showDebug) addDebugLog("getComponentsObj", "", "+");
   const compList = [];
 
   // const componentList = await getDirectoryFiles(directory);
@@ -232,102 +723,331 @@ export const getComponentsObj = async () => {
         container.name = name;
         container.value = name;
 
+if (showDebug) addDebugLog("getComponentsObj", "container: " + JSON.stringify(container), "");
         return container;
       })
     );
   }
 
+if (showDebug) addDebugLog("getComponentsObj", "END", "-");
   return compList;
 };
 
-export const getPegaConfig = async () => {
-  const currentDirectory = process.cwd();
-  const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
+export const getPegaConfig = async (force = false) => {
+if (showDebug) { addDebugLog("getPegaConfig", "", "+"); }
+  if (!pegaData || force) {
 
-  await checkPathAccess(pegaConfigJsonPath);
+if (showDebug)  { addDebugLog("getPegaConfig", "retrieveData", ""); }
+    const currentDirectory = process.cwd();
+    const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
 
-  let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
-  data = JSON.parse(data);
+    await checkPathAccess(pegaConfigJsonPath);
 
-  return data;
+    sPegaData = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
+    pegaData = JSON.parse(sPegaData);
+  }
+
+
+if (showDebug) { addDebugLog("getPegaConfig", "pegaData: " + sPegaData, ""); }
+if (showDebug) { addDebugLog("getPegaConfig", "END", "-"); }
+
+  return pegaData;
 };
 
 export const getPegaServerConfig = async () => {
-  const config = await getPegaConfig();
-  return config['server-config'];
-};
+if (showDebug) addDebugLog("getPegaServerConfig", "", "+");
+  if (!pegaConfig) {
+    pegaConfig = await getPegaConfig();
+    sPegaServerConfig = JSON.stringify(pegaConfig['server-config']);
+  }
 
-export const getComponentDefaults = async () => {
-  const config = await getPegaConfig();
-  return config.component;
+if (showDebug) addDebugLog("getPegaServerConfig", "server config:" + sPegaServerConfig, "");
+if (showDebug) addDebugLog("getPegaServerConfig", "END", "-");
+  return pegaConfig['server-config'];
 };
 
-export const getServerType = async () => {
-  const defaultPegaServerConfig = await getPegaServerConfig();
-  return defaultPegaServerConfig.serverType;
+
+// contains all the config, task config, etc. created upon start
+export const getConfigDefaults = () => {
+if (showDebug) addDebugLog("getConfigDefaults", `defaults: ${JSON.stringify(defaultConfigs)}`, "");
+
+  return defaultConfigs;
+
 }
 
-export const setServerType = async(serverType) => {
+export const forceDefaultsUpdate = async () => {
+  defaultConfigs = await setUpDefaults();
+}
+
+export const updateServerConfigRuleSetAndVersion = async (rulesetName, rulesetVersion) => {
+if (showDebug) addDebugLog("updateServerConfigRuleSetAndVersion", `rulesetName: ${rulesetName}, rulesetVersion: ${rulesetVersion}`, "");
   const currentDirectory = process.cwd();
   const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
-  let configData = await getPegaConfig();
+  let configData = await getPegaConfig(true);
   let serverConfig = configData['server-config'];
-  serverConfig.serverType = serverType;
+
+  serverConfig.rulesetName = rulesetName;
+  serverConfig.rulesetVersion = rulesetVersion;
 
   // update file
   // stringify "4", makes the json string look like JSON in the file, formated instead of a single line
-  fs.writeFileSync(pegaConfigJsonPath, JSON.stringify(configData, null, 4), { encoding: 'utf8' });
+  fs.writeFileSync(pegaConfigJsonPath, JSON.stringify(configData, null, 4), { encoding: 'utf8',flag:'w' });
 
 }
 
-export const getComponentDirectoryPath = async componentKey => {
+export const updateComponentDefaultLibrary = async (library) => {
+if (showDebug) addDebugLog("updateComponentDefaultLibrary", `library: ${library}`, "");
   const currentDirectory = process.cwd();
   const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
 
   await checkPathAccess(pegaConfigJsonPath);
 
-  let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
-  data = JSON.parse(data);
+  let config = await getPegaConfig(true);
+  let componentsDefault = config.component;
+  componentsDefault.library = library;
 
-  if (!data[COMPONENTS_DIRECTORY_PATH]) {
-    console.error(
-      `${chalk.red.bold('ERROR')} Could not able find components directory path in config.json`
-    );
-    process.exit(1);
-  }
 
-  return join(currentDirectory, data[COMPONENTS_DIRECTORY_PATH], componentKey);
-};
+  fs.writeFileSync(pegaConfigJsonPath, JSON.stringify(config, null, 4),  { encoding: 'utf8',flag:'w' });
 
-export const compileMustacheTemplate = (file, data) => {
-  const content = fs.readFileSync(file, 'utf8');
-  return mustache.render(content, data);
-};
+}
 
-export const isPascalCase = string => {
-  return string === pascalCase(string);
-};
+export const updateComponentDefaultVersion = async (version) => {
+if (showDebug) addDebugLog("updateComponentDefaultVersion", `version: ${version}`, "");
+  const currentDirectory = process.cwd();
+  const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
 
-export const convertIntoPascalCase = string => {
-  return pascalCase(string);
-};
+  await checkPathAccess(pegaConfigJsonPath);
 
-export const constructCompleteUrl = (baseServer, endPoint) => {
-  return baseServer.endsWith('/') ? `${baseServer}${endPoint}` : `${baseServer}/${endPoint}`;
-};
+  let config = await getPegaConfig(true);
+  let componentsDefault = config.component;
+  componentsDefault.version = version;
 
-export const sanitize = str => {
-  /* Allow only numbers and case insensitive alphabets */
-  str = str.replace(/[^a-zA-Z0-9 ]/g, '');
-  /* spaces will be replaced by - */
-  str = str.replace(/\s+/g, '-');
-  return str;
-};
 
-export const validateSemver = str => {
-  /* basic semver version validation - 0.0.1-dev */
-  const regex = /^[0-9]\d*\.\d+\.\d+(?:-[a-zA-Z0-9]+)?$/g;
-  return regex.test(str);
+  fs.writeFileSync(pegaConfigJsonPath, JSON.stringify(config, null, 4),  { encoding: 'utf8',flag:'w' });
+
+}
+
+export const getConfigDevBuild = async() => {
+if (showDebug) addDebugLog("getConfigDevBuild", "", "");
+  // const serverConfig = await getPegaServerConfig();
+
+  // return serverConfig.devBuild;
+  return defaultConfigs.devBuild;
+
+}
+
+export const setConfigDevBuild = async (devBuild) => {
+if (showDebug) addDebugLog("setConfigDevBuild", `devBuild: ${devBuild}`, "");
+  const currentDirectory = process.cwd();
+  const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
+  let configData = await getPegaConfig(true);
+  let serverConfig = configData['server-config'];
+  serverConfig.devBuild = devBuild;
+
+  // update file
+  // stringify "4", makes the json string look like JSON in the file, formated instead of a single line
+  fs.writeFileSync(pegaConfigJsonPath, JSON.stringify(configData, null, 4), { encoding: 'utf8',flag:'w' });
+}
+
+export const setConfigImportRelativePath = async (importRelativePath) => {
+if (showDebug) addDebugLog("setConfigImportRelativePath", `importRelativePath: ${importRelativePath}`, "");
+  const currentDirectory = process.cwd();
+  const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
+  let configData = await getPegaConfig(true);
+  configData[IMPORT_RELATIVE_PATH] = importRelativePath;
+
+  // update file
+  // stringify "4", makes the json string look like JSON in the file, formated instead of a single line
+  fs.writeFileSync(pegaConfigJsonPath, JSON.stringify(configData, null, 4), { encoding: 'utf8',flag:'w' });
+}
+
+export const setConfigExportRelativePath = async (exportRelativePath) => {
+if (showDebug) addDebugLog("setConfigExportRelativePath", `exportRelativePath: ${exportRelativePath}`, "");
+  const currentDirectory = process.cwd();
+  const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
+  let configData = await getPegaConfig(true);
+  configData[EXPORT_RELATIVE_PATH] = exportRelativePath;
+
+  // update file
+  // stringify "4", makes the json string look like JSON in the file, formated instead of a single line
+  fs.writeFileSync(pegaConfigJsonPath, JSON.stringify(configData, null, 4), { encoding: 'utf8',flag:'w' });
+}
+
+export const updateDefaultOrganization = async (organization) => {
+if (showDebug) addDebugLog("updateDefaultOrganization", `organization: ${organization}`, "");
+  let packageData = JSON.parse(fs.readFileSync(path.resolve('package.json'), 'utf-8'));
+
+  packageData.organization = organization;
+
+  fs.writeFileSync(path.resolve('package.json'), JSON.stringify(packageData, null, 4),  { encoding: 'utf8',flag:'w' });
+
+}
+
+export const updateConfigVersion = async (componentKey, buildVersion, currentOrgLib) => {
+if (showDebug) addDebugLog("updateConfigVersion", `componentKey: ${componentKey}, buildVersion: ${buildVersion}, currentOrgLib: ${currentOrgLib}`, "");
+  const componentDirectory = await getComponentDirectoryPath(componentKey);
+  const configFileName = 'config.json';
+
+  const configFile = path.join(componentDirectory, configFileName);
+  let configData;
+  try {
+    configData = fs.readFileSync(path.resolve(configFile), 'utf8');
+  } catch (err) {
+    // for now, if now file just end
+    console.log(`${chalk.bold.yellow(`Config file not available for: ${componentKey}`)}`);
+    return;
+  }
+  const currentDate = new Date(Date.now());
+  const dateStamp = currentDate.toDateString();
+  const aboutData = await getAboutData(currentOrgLib, buildVersion, dateStamp);
+
+  let data;
+  try {
+    data = JSON.parse(configData);
+
+    //find "About" and create or update
+    const properties = data.properties;
+    if (properties) {
+      let foundProp = null;
+
+      // check to see if PegaAboutData exists.  If customer decides to put
+      // data under PegaAboutData, we won't change the order
+      // otherise, will put at bottom
+      for (let i in properties) {
+        if (properties[i].name && properties[i].name === "PegaAboutData") {
+          foundProp = properties[i];
+          break;
+        }
+      }
+
+      if (addAboutData) {
+        if (foundProp) {
+          foundProp.label = aboutData;
+        }
+        else {
+          // don't have "About"
+          const aboutLabelJSON =  {
+            "format": "LABEL",
+            "label": "About",
+            "name": "PegaAboutLabel",
+            "variant": "h3"
+          };
+          const aboutDataJSON = {
+            "format": "LABEL",
+            "label": aboutData,
+            "name": "PegaAboutData",
+            "variant": "primary"
+          }
+          properties.push(aboutLabelJSON);
+          properties.push(aboutDataJSON);
+        }
+      }
+
+
+    }
+  } catch (er) {
+    throw new Error(`Invalid schema json in config.json: ${er}`);
+  }
+
+  data.version = buildVersion;
+
+  if (addAboutData) {
+    data.buildDate = dateStamp;
+  }
+
+
+
+  // write back file
+  fs.writeFileSync(configFile, JSON.stringify(data, null, 4), { encoding: 'utf8',flag:'w' });
+};
+
+export const getServerType =  () => {
+if (showDebug) addDebugLog("getServerType", "", "+");
+//   const defaultPegaServerConfig = await getPegaServerConfig();
+// if (showDebug) addDebugLog("getServerType", "serverType:" + defaultPegaServerConfig.serverType, "");
+if (showDebug) addDebugLog("getServerType", "END", "-");
+  // return defaultPegaServerConfig.serverType;
+  return defaultConfigs.serverType;
+}
+
+export const setServerType = async(serverType) => {
+if (showDebug) addDebugLog("setServerType", `serverType: ${serverType}`, "");
+  const currentDirectory = process.cwd();
+  const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
+  let configData = await getPegaConfig(true);
+  let serverConfig = configData['server-config'];
+  serverConfig.serverType = serverType;
+
+  // update file
+  // stringify "4", makes the json string look like JSON in the file, formated instead of a single line
+  fs.writeFileSync(pegaConfigJsonPath, JSON.stringify(configData, null, 4), { encoding: 'utf8',flag:'w' });
+
+  // reset
+  pegaData = null;
+  pegaConfig = null;
+
+  await forceDefaultsUpdate();
+}
+
+export const getSrcDirectoryPath = async () => {
+  const currentDirectory = process.cwd();
+
+  return join(currentDirectory, "src");
+}
+
+export const getComponentDirectoryPath = async (componentKey, overrideDir = null) => {
+if (showDebug) addDebugLog("getComponentDirectoryPath", "", "+");
+  const currentDirectory = process.cwd();
+  const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
+
+  await checkPathAccess(pegaConfigJsonPath);
+
+  let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
+  data = JSON.parse(data);
+
+  if (!data[COMPONENTS_DIRECTORY_PATH]) {
+    console.error(
+      `${chalk.red.bold('ERROR')} Could not able find components directory path in config.json`
+    );
+    process.exit(1);
+  }
+if (showDebug) addDebugLog("getComponentDirectoryPath", "path: " + join(currentDirectory, data[COMPONENTS_DIRECTORY_PATH], componentKey), "");
+if (showDebug) addDebugLog("getComponentDirectoryPath", "END", "-");
+  return overrideDir ? join(overrideDir, componentKey) : join(currentDirectory, data[COMPONENTS_DIRECTORY_PATH], componentKey);
+};
+
+
+export const compileMustacheTemplate = (file, data) => {
+if (showDebug) addDebugLog("compileMustacheTemplate", `file: ${file}`, "");
+  const content = fs.readFileSync(file, 'utf8');
+  return mustache.render(content, data);
+};
+
+export const isPascalCase = string => {
+  return string === pascalCase(string);
+};
+
+export const convertIntoPascalCase = string => {
+  return pascalCase(string);
+};
+
+export const constructCompleteUrl = (baseServer, endPoint) => {
+if (showDebug) addDebugLog("constructCompleteUrl", "url: " + baseServer.endsWith('/') ? `${baseServer}${endPoint}` : `${baseServer}/${endPoint}`, "");
+  return baseServer.endsWith('/') ? `${baseServer}${endPoint}` : `${baseServer}/${endPoint}`;
+};
+
+export const sanitize = str => {
+  /* Allow only numbers and case insensitive alphabets */
+  str = str.replace(/[^a-zA-Z0-9 ]/g, '');
+  /* spaces will be replaced by - */
+  str = str.replace(/\s+/g, '-');
+  return str;
+};
+
+export const validateSemver = str => {
+  /* basic semver version validation - 0.0.1-dev */
+  const regex = /^[0-9]\d*\.\d+\.\d+(?:-[a-zA-Z0-9]+)?$/g;
+  return regex.test(str);
 };
 
 export const validateRulesetVersion = str => {
@@ -344,7 +1064,7 @@ export const standardizeStr = (str, length) => {
   return str.padEnd(length);
 };
 
-export const showVersion = () => {
+export const showVersion = async () => {
   // get package version, so can display at start
   // const require = createRequire(import.meta.url);
   const require = createRequire(currentPath.default);
@@ -352,6 +1072,12 @@ export const showVersion = () => {
   const pData = require('@pega/custom-dx-components/package.json');
 
   console.log(chalk.green(`DX Component Builder v${pData.version}`));
+  showDebug = getShowDebug();
+
+  if (getLibraryBased() && getServerType() === "launchpad") {
+    console.log(`\nLaunchpad commands only supported for ${chalk.bold.green('non library mode')} components.\n`);
+    process.exit();
+  }
 
   // do a check of node version, it should be 18 or greater
   const arNodeVersion = process.versions.node.split('.');
@@ -377,6 +1103,7 @@ export const showVersion = () => {
 };
 
 export const getOOTBComponents = async () => {
+if (showDebug) addDebugLog("getOOTBComponents", "", "");
   return new Promise(resolve => {
     fs.readFile(OOTB_COMPONENTS, 'utf-8', async (error, ootbComponentsData) => {
       if (error) {
@@ -429,6 +1156,7 @@ export const getOOTBComponents = async () => {
 };
 
 export const deleteInfinityServerComponent = async componentKey => {
+if (showDebug) addDebugLog("deleteInfinityServerComponent", `componentKey: ${componentKey}`, "");
   const serverConfig = await getPegaServerConfig();
   const { server } = serverConfig;
   const url = constructCompleteUrl(server, DELETE_COMPONENT_SERVICE_REST_ENDPOINT);
@@ -507,6 +1235,7 @@ export const deleteInfinityServerComponent = async componentKey => {
 };
 
 export const deleteLaunchpadServerComponent = async componentKey => {
+if (showDebug) addDebugLog("deleteLaunchpadServerComponent", `componentKey: ${componentKey}`, "");
   const { server, isolationId } = await getPegaServerConfig();
   const deleteUrl = constructCompleteUrl(
     server,
@@ -592,3 +1321,947 @@ export const deleteLaunchpadServerComponent = async componentKey => {
     throw new Error(error);
   }
 };
+
+export const getBootstrapConfig = async (restServerUrl, authorizationHeader) => {
+if (showDebug) addDebugLog("getBootstrapConfig", `restServerUrl: ${restServerUrl}`, "");
+  const serverConfig = await getPegaServerConfig();
+
+  return fetch(`${restServerUrl}/${BOOTSTRAP_CONFIG}`, {
+    method: 'GET',
+    agent: getHttpsAgent(serverConfig),
+    headers: new Headers({
+      Authorization: authorizationHeader
+    })
+  }).then((response) => {
+    if (response.ok) {
+      return response.json();
+    }
+    throw Error('D_pxBootstrapConfig load failed.', { cause: response.status });
+  });
+};
+
+export const updateC11NB2SForInfinity = async () => {
+if (showDebug) addDebugLog("updateC11NB2SForInfinity", "", "");
+  const serverConfig = await getPegaServerConfig();
+  const { server } = serverConfig;
+  const OAuthData = fs.readFileSync(TOKEN_PATH, 'utf8');
+
+  if (OAuthData) {
+    const { access_token: accessToken, token_type: tokenType } = JSON.parse(OAuthData);
+
+    const bootstrapJSON = await getBootstrapConfig(server, `${tokenType} ${accessToken}`);
+
+    if (bootstrapJSON) {
+      const bootstrap = JSON.parse(bootstrapJSON.pyConfigJSON);
+
+      const objOauthData = JSON.parse(OAuthData);
+      objOauthData["C11NB2S"] = bootstrap.tokens.C11NB2S;
+      objOauthData["appStaticContentServer"] = bootstrap.serviceConfig.appStaticContentServer;
+
+      // write out file
+      fs.writeFileSync(TOKEN_PATH, JSON.stringify(objOauthData), { encoding: 'utf8',flag:'w' });
+    }
+
+  }
+};
+
+export const updateC11NB2SForLaunchpad = async () => {
+
+
+
+};
+
+export const getC11NB2STokenAndStaticServer = async () => {
+if (showDebug) addDebugLog("getC11NB2STokenAndStaticServer", "", "");
+  const serverConfig = await getPegaServerConfig();
+  const { server } = serverConfig;
+  let OAuthData;
+  try {
+    OAuthData = fs.readFileSync(TOKEN_PATH, 'utf8');
+  }
+  catch (ex) {
+    return ({});
+  }
+
+  if (OAuthData) {
+    const { C11NB2S, appStaticContentServer } = JSON.parse(OAuthData)
+
+    if (C11NB2S) {
+      return ({ C11NB2S, appStaticContentServer});
+    }
+
+  }
+  return ({});
+};
+
+export const getLocalLibraries = async () => {
+if (showDebug) addDebugLog("getLocalLibraries", "" , "");
+  const currentDirectory = process.cwd();
+  const configDef = getConfigDefaults();
+  const libFilter = configDef.organization.concat("_");
+
+  return fs
+  .readdirSync(currentDirectory, { withFileTypes: true })
+  .filter(dirent => dirent.isDirectory() && dirent.name.startsWith(libFilter))
+  .map(dirent => dirent.name);
+}
+
+export const getLocalLibraryVersions = async (libraryName, currentVersion = "0.0.0") => {
+if (showDebug) addDebugLog("getLocalLibraryVersions", `libraryName: ${libraryName}` , "");
+  const currentDirectory = process.cwd();
+
+  const directory = join(currentDirectory, libraryName);
+  return fs
+    .readdirSync(directory, { withFileTypes: true })
+    .filter(dirent => dirent.isDirectory() && dirent.name != currentVersion)
+    .map(dirent => dirent.name);
+};
+
+export const getLocalArchivedLibraryVersions = async (libraryName, currentVersion = "0.0.0") => {
+if (showDebug) addDebugLog("getLocalArchivedLibraryVersions", `libraryName: ${libraryName}` , "");
+  const currentDirectory = process.cwd();
+  const archiveDirectory = join (currentDirectory, ARCHIVES_PATH, `${libraryName}`);
+
+  return fs
+    .readdirSync(archiveDirectory, { withFileTypes: true })
+    .filter(dirent => dirent.isDirectory() && dirent.name != currentVersion)
+    .map(dirent => dirent.name);
+};
+
+export const getLocalArchivedLibrraryVersionData = async(libraryName, libraryVersion) => {
+if (showDebug) addDebugLog("getLocalArchivedLibrraryVersionData", `libraryName: ${libraryName}, libraryVersion: ${libraryVersion}`, "");
+  const currentDirectory = process.cwd();
+  const archiveDirectory = join (currentDirectory, ARCHIVES_PATH, `${libraryName}`, `${libraryVersion}`);
+
+  const componentConfigFile = join (archiveDirectory, COMPONENTS_CONFIG_FILE_NAME);
+
+  let data = fs.readFileSync(componentConfigFile, { encoding: 'utf8' })
+
+  return data;
+}
+
+export const getLocalLibraryVersionData = async (libraryName, libraryVersion) => {
+if (showDebug) addDebugLog("getLocalLibraryVersionDate", `libraryName: ${libraryName}, libraryVersion: ${libraryVersion}` , "");
+    const currentDirectory = process.cwd();
+    const libDir = join(currentDirectory, libraryName, libraryVersion);
+    const libDataFile = join(libDir, COMPONENTS_CONFIG_FILE_NAME);
+
+    let data = fs.readFileSync(libDataFile, { encoding: 'utf8' })
+
+    return data;
+};
+
+export const deleteLocalLibrary = async (libraryName) => {
+if (showDebug) addDebugLog("deleteLocalLibrary", `libraryName: ${libraryName}` , "");
+  const currentDirectory = process.cwd();
+
+  const directory = join(currentDirectory, libraryName);
+
+  // for some odd reason, it errors out with an error in "err", but it does delete
+  // all the contents.  The try/catch then calls again to delete the top level
+  try {
+    if (fs.existsSync(directory)) {
+      fs.rmSync(directory, { recursive: true, force: true, maxRetries: 2 });
+      console.log(`Library: ${chalk.green.bold(libraryName)} is deleted from Local`);
+    }
+    else {
+      console.log(`Library: ${chalk.red.bold(libraryName)} does not exist.`);
+    }
+  }
+  catch (ex) {
+    if (fs.existsSync(directory)) {
+      fs.rmSync(directory, { recursive: true, force: true, maxRetries: 2 });
+      console.log(`Library: ${chalk.green.bold(libraryName)} is deleted from Local`);
+    }
+    else {
+      console.log(`Library: ${chalk.red.bold(libraryName)} does not exist.`);
+    }
+  }
+
+};
+
+export const deleteLocalLibraryVersion = async (libraryName, libraryVersion) => {
+if (showDebug) addDebugLog("getLocalLibraryVersions", `libraryName: ${libraryName}, libraryVersion: ${libraryVersion}` , "");
+  const currentDirectory = process.cwd();
+
+  const directory = join(currentDirectory, libraryName, libraryVersion);
+
+  try {
+    if (fs.existsSync(directory)) {
+      console.log(`Deleting library version: ${chalk.green.bold(libraryName)}:${chalk.green.bold(libraryVersion)}`);
+      fs.rmSync(directory, { recursive: true, force: true, maxRetries: 2  });
+      console.log(`Library version: ${chalk.green.bold(libraryName)}:${chalk.green.bold(libraryVersion)} is deleted from Local`);
+    }
+    else {
+      console.log(`Library version: ${chalk.red.bold(libraryName)}:${chalk.red.bold(libraryVersion)} does not exist.`);
+    }
+
+  }
+  catch (error) {
+    throw error;
+  }
+
+};
+
+export const deletePublishExtras = async (libraryName, libraryVersion) => {
+if (showDebug) addDebugLog("deletePublishExtras", `libraryName: ${libraryName}, libraryVersion: ${libraryVersion}` , "");
+  // this function will delete LibraryName.zip file, so new one created by publish
+  // check if .DS_store file exists in Library, if so delete it because causes issue with services
+
+  const currentDirectory = process.cwd();
+  const zipFile = libraryName.concat(".zip");
+
+  // delete zip file
+  const zipPath = join(currentDirectory, zipFile);
+  if (fs.existsSync(zipPath)) {
+    fs.rmSync(zipPath, { force: true });
+  }
+
+  // mac issue
+  const libVersion = join(currentDirectory, libraryName);
+  const dsStore = join(libVersion, ".DS_Store");
+  if (fs.existsSync(dsStore)) {
+    fs.rmSync(dsStore, { force: true });
+  }
+
+};
+
+
+export const cleanUp = async () => {
+if (showDebug) addDebugLog("cleanUp", "", "");
+  if (fs.existsSync('dist/components')) {
+    fs.rm('dist/components', { recursive: true }, err => {
+      if (err) {
+        throw err;
+      }
+    });
+  }
+
+  if (fs.existsSync('lib')) {
+    fs.rm('lib', { recursive: true, force: true }, err => {
+      if (err) {
+        throw err;
+      }
+    });
+  }
+
+};
+
+export const getComponentsConfigs = async (compDir = null) => {
+if (showDebug) addDebugLog("getComponentsConfigs", "", "");
+  const componentsList = await getComponents(compDir);
+
+  let componentsConfigJSON = [];
+  if (componentsList && componentsList.length > 0) {
+    // open each config.json and copy into componentsConfigJSON
+    for (let i in componentsList) {
+      const componentKey = componentsList[i];
+      const componentDirectory = await getComponentDirectoryPath(componentKey, compDir);
+      const configPath = join(componentDirectory, 'config.json');
+
+      if (fs.existsSync(configPath)) {
+        let data = fs.readFileSync(configPath, { encoding: 'utf8' });
+
+        data = JSON.parse(data);
+        componentsConfigJSON.push(data);
+      }
+
+
+    }
+  }
+  return componentsConfigJSON;
+}
+
+
+export const createComponentsConfigFile = async (filePath, compDir) => {
+if (showDebug) addDebugLog("createComponentsConfigFile", `filePath: ${filePath}`, "");
+  const componentsConfigJSON = await getComponentsConfigs(compDir);
+  const compConfgFile = join(filePath, COMPONENTS_CONFIG_FILE_NAME);
+
+  // write out file
+  fs.writeFileSync(compConfgFile, JSON.stringify(componentsConfigJSON), { encoding: 'utf8',flag:'w' });
+
+};
+
+
+export const zipVersionAndArchive = async (orgLibName, version, currentDirectory = "") => {
+if (showDebug) addDebugLog("zipVersionAndArchive", `orgLibName: ${orgLibName}, version: ${version}`, "");
+  // const srcDirectoryPath = await getSrcDirectoryPath();
+  if (currentDirectory === "") {
+    currentDirectory = process.cwd();
+  }
+  const srcDirectoryPath = join(currentDirectory, "src");
+  const tasksConfig = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
+  const packageJson = join(currentDirectory, PACKAGE_JSON_FILENAME);
+  const archiveFileName = `${orgLibName}_${version}.zip`;
+
+
+  // const configContent = Buffer.from(fs.readFileSync(configJson)).toString();
+  const mainDirectory = process.cwd();
+  const archiveDirectory = join (mainDirectory, ARCHIVES_PATH, `${orgLibName}`, `${version}`);
+  if (!fs.existsSync(archiveDirectory)) {
+    fs.mkdirSync(archiveDirectory, { recursive: true });
+  }
+
+  // create componentsconfig.json
+  await createComponentsConfigFile(archiveDirectory, join(srcDirectoryPath, "components"));
+
+  const archiveFile = join(archiveDirectory, archiveFileName);
+  if (fs.existsSync(orgLibName)) {
+
+  }
+
+  const output = fs.createWriteStream(archiveFile);
+  const archive = archiver('zip', {
+    zlib: { level: 9 } // Sets the compression level.
+  });
+
+  const zipChunks = [];
+  archive.on('data', chunk => zipChunks.push(chunk));
+
+  // Add src directory
+  archive.directory(srcDirectoryPath, 'src');
+
+  // grab all files (not directories and archive)
+  const configFiles = await getTopLevelConfigFiles(currentDirectory);
+  if (configFiles && configFiles.length > 0) {
+    for (const configF of configFiles) {
+      if (configF !== "package-lock.json") {
+        archive.file(
+          join(currentDirectory, configF), { name: configF });
+      }
+
+    }
+  }
+
+  // pipe archive data to the file
+  archive.pipe(output);
+
+  output.on('end', function() {
+    console.log('Data has been drained');
+  });
+
+
+  // good practice to catch warnings (ie stat failures and other non-blocking errors)
+  archive.on('warning', function(err) {
+    if (err.code === 'ENOENT') {
+      // log warning
+    } else {
+      // throw error
+      throw err;
+    }
+  });
+
+  // good practice to catch this error explicitly
+  archive.on('error', function(err) {
+    throw err;
+  });
+
+  await archive.finalize();
+
+  return output;
+
+};
+
+export const zipVersionAndArchiveCL = async (orgLibName, version, currentDirectory = "") => {
+if (showDebug) addDebugLog("zipVersionAndArchiveCL", `orgLibName: ${orgLibName}, version: ${version}, currentDirectory: ${currentDirectory}`, "");
+  // const srcDirectoryPath = await getSrcDirectoryPath();
+  if (currentDirectory === "") {
+    currentDirectory = process.cwd();
+  }
+  const libDirectoryPath = join(currentDirectory, orgLibName, version);
+  const tasksConfig = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
+  const packageJson = join(currentDirectory, PACKAGE_JSON_FILENAME);
+  const archiveFileName = `${orgLibName}_${version}.zip`;
+
+
+  // const configContent = Buffer.from(fs.readFileSync(configJson)).toString();
+  const mainDirectory = process.cwd();
+  const archiveDirectory = join (mainDirectory, BIN_ARCHIVES_PATH);
+  if (!fs.existsSync(archiveDirectory)) {
+    fs.mkdirSync(archiveDirectory, { recursive: true });
+  }
+
+
+  const archiveFile = join(archiveDirectory, archiveFileName);
+  if (fs.existsSync(orgLibName)) {
+
+  }
+
+  const output = fs.createWriteStream(archiveFile);
+  const archive = archiver('zip', {
+    zlib: { level: 9 } // Sets the compression level.
+  });
+
+  const zipChunks = [];
+  archive.on('data', chunk => zipChunks.push(chunk));
+
+  // Add src directory
+  archive.directory(libDirectoryPath, false);
+
+
+  // pipe archive data to the file
+  archive.pipe(output);
+
+  output.on('end', function() {
+    console.log('Data has been drained');
+  });
+
+
+  // good practice to catch warnings (ie stat failures and other non-blocking errors)
+  archive.on('warning', function(err) {
+    if (err.code === 'ENOENT') {
+      // log warning
+    } else {
+      // throw error
+      throw err;
+    }
+  });
+
+  // good practice to catch this error explicitly
+  archive.on('error', function(err) {
+    throw err;
+  });
+
+  await archive.finalize();
+
+  return output;
+
+};
+
+export const unZipFromArchive = async (fileName) => {
+if (showDebug) addDebugLog("unZipFromArchive", `fileName: ${fileName}`, "");
+  await unarchive(fileName, TEMP_PATH);
+};
+
+
+
+export const updateComponentTaskConfig = async () => {
+if (showDebug) addDebugLog("updateComponentTaskConfig", "", "");
+  const currentDirectory = process.cwd();
+  const tempDirectory = join(currentDirectory, TEMP_PATH);
+
+  const tempConfigPath = join(tempDirectory, TASKS_CONFIG_JSON_FILENAME);
+  const currentConfigPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
+
+  const contents = fs.readFileSync(tempConfigPath);
+  const originalContents = fs.readFileSync(currentConfigPath);
+
+  let contentsData = JSON.parse(contents);
+  let originalContentsData = JSON.parse(originalContents);
+
+  // only copy "components" from archived task.config and "devBuild"
+  // that way, your current tasks.config isn't messed up
+  originalContentsData["server-config"].devBuild = contentsData["server-config"].devBuild;
+  originalContentsData["component"] = contentsData["component"];
+
+  fs.writeFileSync(currentConfigPath, JSON.stringify(originalContentsData, null, 4), { encoding: 'utf8',flag:'w' });
+
+}
+
+export const restoreDependenciesFromPackage = async () => {
+if (showDebug) addDebugLog("restoreDependenciesFromPackage", "", "");
+  const currentDirectory = process.cwd();
+  const tempDirectory = join(currentDirectory, TEMP_PATH);
+  const tempPackagePath = join (tempDirectory, PACKAGE_JSON_FILENAME);
+  const currentPackagePath = join(currentDirectory, PACKAGE_JSON_FILENAME);
+
+  let retrievedPackageData;
+  let currentPackageData;
+
+  // reset
+  haveDependencyDifference = false;
+
+  try {
+    retrievedPackageData = fs.readFileSync(tempPackagePath);
+  }
+  catch (ex) {
+    console.log(chalk.red(`\nUnable to retrieve package.json from store.`))
+    process.exit(1);
+  }
+
+  try {
+    currentPackageData = fs.readFileSync(currentPackagePath);
+  }
+  catch (ex) {
+    console.log(chalk.red(`\nUnable to retrieve current package.json.`))
+    process.exit(1);
+  }
+
+
+  let rData = JSON.parse(retrievedPackageData);
+  let cData = JSON.parse(currentPackageData);
+
+  // now keep current package.json, but replace devDependencies and dependencies.
+  const sDep = JSON.stringify(rData.dependencies);
+  const sDevDep = JSON.stringify(rData.devDependencies);
+
+  const sCurDep = JSON.stringify(cData.dependencies);
+  const sCurDevDep = JSON.stringify(cData.devDependencies);
+
+  // any changes, update haveDependencyDifference variable
+  if (sDep != sCurDep) {
+    haveDependencyDifference = true;
+  }
+  else if (sDevDep != sCurDevDep) {
+    haveDependencyDifference = true;
+  }
+
+
+  cData.dependencies = JSON.parse(sDep);
+  cData.devDependencies = JSON.parse(sDevDep);
+
+  // we can't loose devDep that is part of install, so go get the template mustache and push
+  // those in, replacing any changes there, but allowing additional, an keeping it updated
+  // so won't loose new function if an old archive
+  const initDir = join(currentDirectory, "node_modules", "@pega", "custom-dx-components", "src", "tasks", "init");
+  const templateDir = join(initDir, "template");
+  const packageTemplateJsonPath = path.join(templateDir, 'package.json.mustache');
+  let retrievedTemplateData;
+  try {
+    retrievedTemplateData = fs.readFileSync(packageTemplateJsonPath);
+  }
+  catch (ex) {
+    console.log($chalk.red(`\nUnable to retrieve package.json.mustache from code.`))
+    process.exit(1);
+  }
+  const tData = JSON.parse(retrievedTemplateData);
+  const tDevDep = tData.devDependencies;
+  for (const [key, value] of Object.entries(tDevDep)) {
+    rData.devDependencies[key] = value;
+  }
+
+  // overwrite cData specifics
+  rData.name = cData.name;
+  rData.description = cData.description;
+  rData.organization = cData.organization;
+  rData.main = cData.main;
+  rData.type = cData.type;
+  rData.scripts = cData.scripts;
+  rData.scriptsComments = cData.scriptsComments;
+  rData.repository = cData.repository;
+  rData.keywords = cData.keywords;
+
+
+  // update current package json file
+  fs.writeFileSync(currentPackagePath, JSON.stringify(rData, null, 4), { encoding: 'utf8',flag:'w' });
+
+
+}
+
+
+export const restoreDependenciesFromTemplate = async () => {
+  if (showDebug) addDebugLog("restoreDependenciesFromTemplate", "", "");
+    const currentDirectory = process.cwd();
+    const currentPackagePath = join(currentDirectory, PACKAGE_JSON_FILENAME);
+
+    let currentPackageData;
+
+    // reset
+    haveDependencyDifference = true;
+
+    try {
+      currentPackageData = fs.readFileSync(currentPackagePath);
+    }
+    catch (ex) {
+      console.log(chalk.red(`\nUnable to retrieve current package.json.`))
+      process.exit(1);
+    }
+
+
+    let cData = JSON.parse(currentPackageData);
+
+
+    // we can't loose devDep that is part of install, so go get the template mustache and push
+    // those in, replacing any changes there, but allowing additional, an keeping it updated
+    // so won't loose new function if an old archive
+    const initDir = join(currentDirectory, "node_modules", "@pega", "custom-dx-components", "src", "tasks", "init");
+    const templateDir = join(initDir, "template");
+    const packageTemplateJsonPath = path.join(templateDir, 'package.json.mustache');
+    let retrievedTemplateData;
+    try {
+      retrievedTemplateData = fs.readFileSync(packageTemplateJsonPath);
+    }
+    catch (ex) {
+      console.log($chalk.red(`\nUnable to retrieve package.json.mustache from code.`))
+      process.exit(1);
+    }
+    const tData = JSON.parse(retrievedTemplateData);
+    const tDevDep = tData.devDependencies;
+    const tDep = tData.dependencies;
+
+    for (const [key, value] of Object.entries(tDevDep)) {
+      cData.devDependencies[key] = value;
+    }
+
+    for (const [key, value] of Object.entries(tDep)) {
+      cData.dependencies[key] = value;
+    }
+
+
+    // update current package json file
+    fs.writeFileSync(currentPackagePath, JSON.stringify(cData, null, 4), { encoding: 'utf8',flag:'w' });
+
+
+  }
+
+
+export const restoreDependenciesFromPackage_old = async () => {
+  if (showDebug) addDebugLog("restoreDependenciesFromPackage", "", "");
+    const currentDirectory = process.cwd();
+    const tempDirectory = join(currentDirectory, TEMP_PATH);
+    const tempPackagePath = join (tempDirectory, PACKAGE_JSON_FILENAME);
+    const currentPackagePath = join(currentDirectory, PACKAGE_JSON_FILENAME);
+
+    let retrievedPackageData;
+    let currentPackageData;
+
+    // reset
+    haveDependencyDifference = false;
+
+    try {
+      retrievedPackageData = fs.readFileSync(tempPackagePath);
+    }
+    catch (ex) {
+      console.log($chalk.red(`\nUnable to retrieve package.json from store.`))
+      process.exit(1);
+    }
+
+    try {
+      currentPackageData = fs.readFileSync(currentPackagePath);
+    }
+    catch (ex) {
+      console.log($chalk.red(`\nUnable to retrieve current package.json.`))
+      process.exit(1);
+    }
+
+
+    const rData = JSON.parse(retrievedPackageData);
+    let cData = JSON.parse(currentPackageData);
+
+    // now keep current package.json, but replace devDependencies and dependencies.
+    const sDep = JSON.stringify(rData.dependencies);
+    const sDevDep = JSON.stringify(rData.devDependencies);
+
+    const sCurDep = JSON.stringify(cData.dependencies);
+    const sCurDevDep = JSON.stringify(cData.devDependencies);
+
+    // any changes, update haveDependencyDifference variable
+    if (sDep != sCurDep) {
+      haveDependencyDifference = true;
+    }
+    else if (sDevDep != sCurDevDep) {
+      haveDependencyDifference = true;
+    }
+
+
+    cData.dependencies = JSON.parse(sDep);
+    cData.devDependencies = JSON.parse(sDevDep);
+
+    // we can't loose devDep that is part of install, so go get the template mustache and push
+    // those in, replacing any changes there, but allowing additional, an keeping it updated
+    // so won't loose new function if an old archive
+    const initDir = join(currentDirectory, "node_modules", "@pega", "custom-dx-components", "src", "tasks", "init");
+    const templateDir = join(initDir, "template");
+    const packageTemplateJsonPath = path.join(templateDir, 'package.json.mustache');
+    let retrievedTemplateData;
+    try {
+      retrievedTemplateData = fs.readFileSync(packageTemplateJsonPath);
+    }
+    catch (ex) {
+      console.log($chalk.red(`\nUnable to retrieve package.json.mustache from code.`))
+      process.exit(1);
+    }
+    const tData = JSON.parse(retrievedTemplateData);
+    const tDevDep = tData.devDependencies;
+    for (const [key, value] of Object.entries(tDevDep)) {
+      cData.devDependencies[key] = value;
+    }
+
+
+    // update current package json file
+    fs.writeFileSync(currentPackagePath, JSON.stringify(cData, null, 4), { encoding: 'utf8',flag:'w' });
+
+
+  }
+
+export const getHaveDependencyDifference = () => {
+if (showDebug) addDebugLog("getHaveDependencyDifference", ``, "");
+  return haveDependencyDifference;
+}
+
+export const restoreFromArchive = async (fileName, orgLibName, version) => {
+if (showDebug) addDebugLog("restoreFromArchive", `fileName: ${fileName}, orgLibName: ${orgLibName}, version: ${version}`, "");
+  const currentDirectory = process.cwd();
+  const tempDirectory = join(currentDirectory, TEMP_PATH);
+  const archiveDirectory = join (currentDirectory, ARCHIVES_PATH, `${orgLibName}`, `${version}`);
+  const archFileName = join(archiveDirectory, fileName);
+
+  await unZipFromArchive(archFileName);
+
+
+  const tempPackagePath = join (tempDirectory, PACKAGE_JSON_FILENAME);
+  const currentPackagePath = join(currentDirectory, PACKAGE_JSON_FILENAME);
+  const tempDirectoryComponents = join(tempDirectory, "src");
+  const currentComponentsPath = join(currentDirectory, "src");
+
+  // remove all config files
+  await removeTopLevelConfigFiles(currentDirectory);
+
+  await restoreTopLevelConfigFiles(currentDirectory);
+
+  // take your current tasks.config and update with component and devBuild from saved tasks.config
+  await updateComponentTaskConfig();
+
+  // restore package json dependencies
+  await restoreDependenciesFromPackage();
+
+  // remove current components
+  fs.rmSync(currentComponentsPath, { recursive: true, force: true, maxRetries: 2  });
+
+  if (fs.existsSync(currentComponentsPath)) {
+    // try another round of rm
+    fs.rmSync(currentComponentsPath, { recursive: true, force: true, maxRetries: 2  });
+
+    if (fs.existsSync(currentComponentsPath)) {
+      // still an issue
+      console.log(chalk.red('\nUnable to complete clear out src/components directory.\n'));
+      console.log(chalk.red('\nUnstored components are in /temp directory.\n'));
+      console.log(chalk.red('\nYou can migrate /store/temp/components to src/components manually.\n'));
+      console.log(chalk.red('\nYou can replace /store/temp/tasks.config.json with tasks.config.json.\n'));
+      process.exit();
+    }
+  }
+
+
+  // copy temp src/components
+  if (fs.existsSync(tempDirectoryComponents)) {
+
+    fs.cpSync(tempDirectoryComponents, currentComponentsPath, { recursive: true, force: true  });
+   }
+   else {
+     // nothing was archived (no src/components)
+     // so make a src/components if doesn't exist
+     if (!fs.existsSync(currentComponentsPath)) {
+       fs.mkdirSync(currentComponentsPath, { "recursive" : true});
+     }
+   }
+
+
+   // remove temp  (windows not working well with "sync", can be async, since as long as deleted, fine)
+   fs.rm(tempDirectory, { recursive: true, force: true, maxRetries: 5  },  () => {});
+
+};
+
+export const clearSrcComponentsDirectory = async () => {
+if (showDebug) addDebugLog("clearSrcComponentsDirectory", ``, "");
+  const currentDirectory = process.cwd();
+  const currentComponentsPath = join(currentDirectory, "src", "components");
+
+  // remove current components
+  fs.rmSync(currentComponentsPath, { recursive: true, force: true, maxRetries: 2  });
+
+  // create blank src
+  fs.mkdirSync(currentComponentsPath, { recursive: true });
+};
+
+export const isHiddenFile = (fileName) => {
+  if (fileName.indexOf(".") == 0) {
+    return true;
+  }
+
+  return false;
+};
+
+export const getCurrentOrgLib = () =>{
+  return defaultConfigs.currentOrgLib;
+};
+
+export const hasArchives = async () => {
+if (showDebug) addDebugLog("hasArchives", "call", "");
+  const currentDirectory = process.cwd();
+  const archiveDirectory = join (currentDirectory, ARCHIVES_PATH);
+  const hasArc = fs.existsSync(archiveDirectory);
+if (showDebug) addDebugLog("hasArchives", `${hasArc}`, "");
+  return hasArc;
+};
+
+export const deleteArchives = async () => {
+if (showDebug) addDebugLog("deleteArchives", ``, "");
+  const currentDirectory = process.cwd();
+  const archiveDirectory = join (currentDirectory, ARCHIVES_PATH);
+  const hasArc = fs.existsSync(archiveDirectory);
+
+  if (hasArc) {
+    try {
+      fs.rmSync(archiveDirectory, { recursive: true });
+    } catch (err) {
+    }
+  }
+}
+
+export const checkLibraryAndArchives = async () => {
+if (showDebug) addDebugLog("checkLibraryAndArchives", ``, "");
+  const isLibraryBased =  getLibraryBased();
+  const hasArch = await hasArchives();
+
+  if (isLibraryBased && !hasArch) {
+    console.log(chalk.yellow('\nPlease create a library before proceeding.\n'));
+    process.exit();
+  }
+};
+
+export const hasLibraryAndVersion = async (libraryName, version, devBuild) => {
+if (showDebug) addDebugLog("hasLibraryAndVersion", `libraryName: ${libraryName}, version: ${version}, devBuild: ${devBuild}`, "");
+  // const orgLib = getConfigDefaults();
+  // const currentOrgLib = `${orgLib.organization}_${libraryName}`;
+  // const libFiles = await getLibraryArchivesFiles(currentOrgLib);
+  // let currentVersion = version;
+  // if (devBuild) {
+  //   currentVersion = currentVersion.concat("-dev");
+  // }
+  // const fileName = `${currentOrgLib}_${currentVersion}.zip`;
+  // if (libFiles && libFiles.length > 0) {
+  //   if (libFiles.includes(fileName)) {
+  //     return true;
+  //   }
+  // }
+
+  // return false;
+
+  const orgLib = getConfigDefaults();
+  const currentOrgLib = `${orgLib.organization}_${libraryName}`;
+  const libVersions = await getLibraryArchivesVersions(currentOrgLib);
+  let currentVersion = version;
+  if (devBuild) {
+    currentVersion = currentVersion.concat("-dev");
+  }
+
+  if (libVersions.includes(currentVersion)) {
+    return true;
+  }
+
+  return false;
+
+
+};
+
+export const getLibraryArchiveDirectories = async (currentOrgLib = "") => {
+if (showDebug) addDebugLog("getLibraryArchiveDirectories", "", "");
+  const currentDirectory = process.cwd();
+  const archiveDirectory = join (currentDirectory, ARCHIVES_PATH);
+
+
+  if (!fs.existsSync(archiveDirectory)) {
+    return [];
+  }
+
+  return fs
+  .readdirSync(archiveDirectory, { withFileTypes: true })
+  .filter(dirent => dirent.isDirectory() && (dirent.name != currentOrgLib) )
+  .map(dirent => dirent.name);
+};
+
+
+
+export const getLibraryArchivesVersions = async (orgLibName, currentVersion) => {
+if (showDebug) addDebugLog("getLibraryArchivesVersions", `orgLibName: ${orgLibName}`, "");
+
+  const currentDirectory = process.cwd();
+  const archiveDirectory = join (currentDirectory, ARCHIVES_PATH, `${orgLibName}`);
+
+  if (!fs.existsSync(archiveDirectory)) {
+    return [];
+  }
+
+  return fs
+    .readdirSync(archiveDirectory, { withFileTypes: true })
+    .filter(dirent => dirent.isDirectory() && dirent.name != currentVersion   )
+    .map(dirent => dirent.name);
+
+
+
+};
+
+export const deleteLocalArchiveLibrary = async(libraryName) => {
+if (showDebug) addDebugLog("deleteLocalArchiveLibrary", `libraryName: ${libraryName}`, "");
+  const currentDirectory = process.cwd();
+  const archiveDirectory = join (currentDirectory, ARCHIVES_PATH, libraryName);
+
+  try {
+    fs.rmSync(archiveDirectory, { recursive: true });
+    console.log(`${chalk.green.bold(libraryName)} is deleted from Local.`);
+  } catch (err) {
+    console.log(`${chalk.green.red(`No such file ${libraryName}`)}`);
+    // throw new Error(`No such file ${libraryName}`);
+  }
+
+  // check if no other libraries, the remove /store
+  const archList = getLibraryArchiveDirectories();
+  if (archList.length === 0) {
+    const archPath = join (currentDirectory, ARCHIVES_PATH);
+
+    fs.rmSync(archPath, { recursive : true});
+  }
+
+}
+
+export const deleteLocalArchiveLibraryVersion = async(libraryName, version) => {
+if (showDebug) addDebugLog("deleteLocalArchiveLibraryVersion", `libraryName: ${libraryName}, version: ${version}`, "");
+  const currentDirectory = process.cwd();
+  const archiveDirectory = join (currentDirectory, ARCHIVES_PATH, libraryName, version);
+
+  try {
+    fs.rmSync(archiveDirectory, { recursive: true });
+    console.log(`${chalk.green.bold(`${libraryName}/${version}`)} is deleted from Local.`);
+
+
+
+  } catch (err) {
+    console.log(`${chalk.green.red(`No such file ${libraryName}/${version}`)}`);
+    // throw new Error(`No such file ${libraryName}/${version}`);
+  }
+
+}
+
+export const cleanUpTemp = async() => {
+if (showDebug) addDebugLog("cleanUpTemp", ``, "");
+  const currentDirectory = process.cwd();
+  const tempDirectory = join (currentDirectory, TEMP_PATH);
+
+  if (fs.existsSync(tempDirectory)) {
+    fs.rmSync(tempDirectory, { recursive: true });
+  }
+
+}
+
+
+export const getJestFunctionalTestList = async(whichTests) => {
+if (showDebug) addDebugLog("getJestFunctionalTestList", ``, "");
+  const functionalDir = path.join(path.resolve(), JEST_TESTS_FUNCTIONAL_PATH);
+  const libFilter = "localLib";
+
+  switch (whichTests) {
+    case "ALL" :
+      return fs
+      .readdirSync(functionalDir, { withFileTypes: true })
+      .filter(dirent => !dirent.isDirectory() )
+      .map(dirent => dirent.name);
+    case "Original":
+      return fs
+      .readdirSync(functionalDir, { withFileTypes: true })
+      .filter(dirent => !dirent.isDirectory() && !dirent.name.startsWith(libFilter))
+      .map(dirent => dirent.name);
+    case "Library" :
+      return fs
+      .readdirSync(functionalDir, { withFileTypes: true })
+      .filter(dirent => !dirent.isDirectory() && dirent.name.startsWith(libFilter))
+      .map(dirent => dirent.name);
+  }
+
+
+}
+
+
+// init
+await forceDefaultsUpdate();