@pega/custom-dx-components 0.242.25 → 0.242.27

package/src/util.js

@@ -6,17 +6,21 @@ 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';
 import pascalCase from 'pascalcase';
 import fetch from 'node-fetch';
-import checkGit from 'check-git';
+// import checkGit from 'check-git';
 
 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,
@@ -26,14 +30,34 @@ import {
   BOOTSTRAP_CONFIG,
   LIBRARY_BASED,
   SHARED_DIRECTORY,
-  SHOW_DEBUG
+  SHOW_DEBUG,
+  COMPONENTS_PATH,
+  ARCHIVES_PATH
 } from './constants.js';
+import { arch } from 'os';
+import lib from 'fs-extra';
+import { or } from 'ajv/dist/compile/codegen/index.js';
+import def from 'ajv/dist/vocabularies/applicator/additionalItems.js';
 
 const access = promisify(fs.access);
 
 let showDebug = false;
 let debugLevel = 1;
-
+let haveDependencyDifference = false;
+
+// updated upon start
+let defaultConfigs = {
+  serverType: "",
+  isLibraryBased: false,
+  devBuild: true,
+  library: "",
+  organization: "",
+  currentOrgLib: "",
+  version: "",
+  buildVersion: "",
+  displayLibVersion: "",
+  showDebug: false
+};
 
 export const addDebugLog = (sFunctionName, sLogData, sIncDec) => {
 
@@ -60,6 +84,70 @@ export const addDebugLog = (sFunctionName, sLogData, sIncDec) => {
   }
 }
 
+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
+  };
+
+  // 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[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;
+    }
+
+    retrievedConfigData.showDebug = data["server-config"].devBuild;
+    retrievedConfigData.serverType = data["server-config"].serverType;
+
+    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 retrievedConfigData;
+}
+
+// initialize
+await setUpDefaults();
+
 export const checkPathAccess = async (path, options = {}, throwError = false) => {
 
 
@@ -159,33 +247,52 @@ addDebugLog("getAboutData", `currentOrgLib: ${currentOrgLib}, buildVersion: ${bu
   return `${currentOrgLib} ${buildVersion}, ${dateStamp}, ${infinityVersion}`;
 }
 
-export const getLibraryBased = async () => {
-addDebugLog("getLibraryBased", "", "+");
-  const currentDirectory = process.cwd();
-  const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
+export const checkJWTExpiration = async () => {
+  const tokenAndStaticServer = await getC11NB2STokenAndStaticServer();
 
-  try {
-    // force to throw error and not console log
-    await checkPathAccess(pegaConfigJsonPath, {}, true);
+  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);
   }
-  catch (ex) {
-    // when can't find it, always be false, assume no library based.
-    // This is IMPORTANT for init (npx install)
-    return false;
+
+  const jwt = jwtDecode(tokenAndStaticServer.C11NB2S);
+  const  { exp } = jwt;
+  if (exp < (new Date().getTime() + 1) / 1000) {
+    console.log(chalk.redBright("JWT token has expired, please reauthenticate."));
+    process.exit(1);
   }
 
-  let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
-  data = JSON.parse(data);
+}
 
-  if (data[LIBRARY_BASED]) {
-addDebugLog("getLibraryBased", `based: ${data[LIBRARY_BASED]}`, "");
-addDebugLog("getLibraryBased", "END", "-");
-    return data[LIBRARY_BASED];
-  }
-  else {
-addDebugLog("getLibraryBased", "END", "-");
-    return false;
-  }
+export const getLibraryBased = () => {
+// 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]) {
+// addDebugLog("getLibraryBased", `based: ${data[LIBRARY_BASED]}`, "");
+// addDebugLog("getLibraryBased", "END", "-");
+//     return data[LIBRARY_BASED];
+//   }
+//   else {
+// addDebugLog("getLibraryBased", "END", "-");
+//     return false;
+//   }
+
+  return defaultConfigs.isLibraryBased;
 }
 
 export const setLibraryBased = async (isLibraryBased) => {
@@ -445,14 +552,34 @@ addDebugLog("getPegaServerConfig", "END", "-");
   return config['server-config'];
 };
 
-export const getComponentDefaults = async () => {
-addDebugLog("getComponentDefaults", "", "+");
-  const config = await getPegaConfig();
-addDebugLog("getComponentDefaults", "config:" + JSON.stringify(config), "");
 
-addDebugLog("getComponentDefaults", "END", "-");
-  return config.component;
-};
+// contains all the config, task config, etc. created upon start
+export const getConfigDefaults = () => {
+  addDebugLog("getConfigDefaults", `defaults: ${JSON.stringify(defaultConfigs)}`, "");
+
+  return defaultConfigs;
+
+}
+
+export const forceDefaultsUpdate = async () => {
+  defaultConfigs = await setUpDefaults();
+}
+
+export const updateServerConfigRuleSetAndVersion = async (rulesetName, rulesetVersion) => {
+addDebugLog("updateServerConfigRuleSetAndVersion", `rulesetName: ${rulesetName}, rulesetVersion: ${rulesetVersion}`, "");
+  const currentDirectory = process.cwd();
+  const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
+  let configData = await getPegaConfig();
+  let serverConfig = configData['server-config'];
+
+  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' });
+
+}
 
 export const updateComponentDefaultLibrary = async (library) => {
 addDebugLog("updateComponentDefaultLibrary", `library: ${library}`, "");
@@ -486,6 +613,28 @@ addDebugLog("updateComponentDefaultVersion", `version: ${version}`, "");
 
 }
 
+export const getConfigDevBuild = async() => {
+addDebugLog("getConfigDevBuild", "", "");
+  // const serverConfig = await getPegaServerConfig();
+
+  // return serverConfig.devBuild;
+  return defaultConfigs.devBuild;
+
+}
+
+export const setConfigDevBuild = async (devBuild) => {
+addDebugLog("setConfigDevBuild", `devBuild: ${devBuild}`, "");
+  const currentDirectory = process.cwd();
+  const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
+  let configData = await getPegaConfig();
+  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' });
+}
+
 export const updateDefaultOrganization = async (organization) => {
 addDebugLog("updateDefaultOrganization", `organization: ${organization}`, "");
   let packageData = JSON.parse(fs.readFileSync(path.resolve('package.json'), 'utf-8'));
@@ -496,12 +645,82 @@ addDebugLog("updateDefaultOrganization", `organization: ${organization}`, "");
 
 }
 
-export const getServerType = async () => {
+export const updateConfigVersion = async (componentKey, buildVersion, currentOrgLib) => {
+  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 (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;
+    data.buildDate = dateStamp;
+
+    // write back file
+    fs.writeFileSync(configFile, JSON.stringify(data, null, 4), { encoding: 'utf8' });
+  };
+
+export const getServerType =  () => {
 addDebugLog("getServerType", "", "+");
-  const defaultPegaServerConfig = await getPegaServerConfig();
-addDebugLog("getServerType", "serverType:" + defaultPegaServerConfig.serverType, "");
+//   const defaultPegaServerConfig = await getPegaServerConfig();
+// addDebugLog("getServerType", "serverType:" + defaultPegaServerConfig.serverType, "");
 addDebugLog("getServerType", "END", "-");
-  return defaultPegaServerConfig.serverType;
+  // return defaultPegaServerConfig.serverType;
+  return defaultConfigs.serverType;
 }
 
 export const setServerType = async(serverType) => {
@@ -518,6 +737,12 @@ addDebugLog("setServerType", `serverType: ${serverType}`, "");
 
 }
 
+export const getSrcDirectoryPath = async () => {
+  const currentDirectory = process.cwd();
+
+  return join(currentDirectory, "src");
+}
+
 export const getComponentDirectoryPath = async componentKey => {
 addDebugLog("getComponentDirectoryPath", "", "+");
   const currentDirectory = process.cwd();
@@ -611,14 +836,12 @@ export const showVersion = async () => {
     process.exit(1);
   }
 
-  const hasGit = checkGit(process.cwd());
-
-  if (!hasGit) {
-    console.log(chalk.redBright('DX Component Builder - Git needs to be installed.'));
-    process.exit(1);
-  }
-
+  // const hasGit = checkGit(process.cwd());
 
+  // if (!hasGit) {
+  //   console.log(chalk.redBright('DX Component Builder - Git needs to be installed.'));
+  //   process.exit(1);
+  // }
 };
 
 export const getOOTBComponents = async () => {
@@ -911,29 +1134,51 @@ addDebugLog("getC11NB2STokenAndStaticServer", "", "");
 
   }
   return ({});
-}
+};
 
-export const getLocalLibraryVersions = async (libraryName) => {
+export const getLocalLibraryVersions = async (libraryName, currentVersion = "0.0.0") => {
 addDebugLog("getLocalLibraryVersions", `libraryName: ${libraryName}` , "");
   const currentDirectory = process.cwd();
 
   const directory = join(currentDirectory, libraryName);
   return fs
     .readdirSync(directory, { withFileTypes: true })
-    .filter(dirent => dirent.isDirectory())
+    .filter(dirent => dirent.isDirectory() && dirent.name != currentVersion)
     .map(dirent => dirent.name);
 };
 
+export const getLocalArchivedLibraryVersions = async (libraryName, currentVersion = "0.0.0") => {
+  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) => {
+  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) => {
 addDebugLog("getLocalLibraryVersionDate", `libraryName: ${libraryName}, libraryVersion: ${libraryVersion}` , "");
     const currentDirectory = process.cwd();
     const libDir = join(currentDirectory, libraryName, libraryVersion);
-    const libDataFile = join(libDir, 'componentsconfig.json');
+    const libDataFile = join(libDir, COMPONENTS_CONFIG_FILE_NAME);
 
     let data = fs.readFileSync(libDataFile, { encoding: 'utf8' })
 
     return data;
-}
+};
 
 export const deleteLocalLibrary = async (libraryName) => {
 addDebugLog("deleteLocalLibrary", `libraryName: ${libraryName}` , "");
@@ -962,9 +1207,7 @@ addDebugLog("deleteLocalLibrary", `libraryName: ${libraryName}` , "");
     }
   }
 
-
-
-}
+};
 
 export const deleteLocalLibraryVersion = async (libraryName, libraryVersion) => {
 addDebugLog("getLocalLibraryVersions", `libraryName: ${libraryName}, libraryVersion: ${libraryVersion}` , "");
@@ -987,8 +1230,7 @@ addDebugLog("getLocalLibraryVersions", `libraryName: ${libraryName}, libraryVers
     throw error;
   }
 
-
-}
+};
 
 export const deletePublishExtras = async (libraryName, libraryVersion) => {
 addDebugLog("deletePublishExtras", `libraryName: ${libraryName}, libraryVersion: ${libraryVersion}` , "");
@@ -1011,14 +1253,11 @@ addDebugLog("deletePublishExtras", `libraryName: ${libraryName}, libraryVersion:
     fs.rmSync(dsStore, { force: true });
   }
 
-
-}
-
-
+};
 
 
 export const cleanUp = async () => {
-  addDebugLog("cleanUp", "", "");
+addDebugLog("cleanUp", "", "");
     fs.rm('dist/components', { recursive: true }, err => {
       if (err) {
         throw err;
@@ -1030,4 +1269,434 @@ export const cleanUp = async () => {
         throw err;
       }
     });
-  };
+};
+
+export const getComponentsConfigs = async () => {
+addDebugLog("getComponentsConfigs", "", "");
+  const componentsList = await getComponents();
+  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);
+      const configPath = join(componentDirectory, 'config.json');
+
+      let data = fs.readFileSync(configPath, { encoding: 'utf8' });
+
+      data = JSON.parse(data);
+      componentsConfigJSON.push(data);
+
+    }
+  }
+  return componentsConfigJSON;
+}
+
+
+export const createComponentsConfigFile = async (filePath) => {
+addDebugLog("createComponentsConfigFile", `filePath: ${filePath}`, "");
+  const componentsConfigJSON = await getComponentsConfigs();
+  const compConfgFile = join(filePath, COMPONENTS_CONFIG_FILE_NAME);
+
+  // write out file
+  fs.writeFileSync(compConfgFile, JSON.stringify(componentsConfigJSON), { encoding: 'utf8' });
+
+};
+
+
+export const zipVersionAndArchive = async (orgLibName, version, copyExisting) => {
+addDebugLog("zipVersionAndArchive", `orgLibName: ${orgLibName}, version: ${version}`, "");
+  const srcDirectoryPath = await getSrcDirectoryPath();
+  const currentDirectory = process.cwd();
+  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 archiveDirectory = join (currentDirectory, ARCHIVES_PATH, `${orgLibName}`, `${version}`);
+  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(srcDirectoryPath, 'src');
+
+  // Add config.json file
+  if (fs.existsSync(tasksConfig)) {
+    archive.file(tasksConfig, { name: path.basename(tasksConfig) });
+  }
+
+  // Add package.json file
+  if (fs.existsSync(packageJson)) {
+    archive.file(packageJson, { name: path.basename(packageJson) });
+  }
+
+  // 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();
+
+  // create componentsconfig.json
+  await createComponentsConfigFile(archiveDirectory);
+
+  // const zipBuffer = Buffer.concat(zipChunks);
+  // console.log(chalk.green(`component zipped with size: ${Math.ceil(zipBuffer.length / 1024)} KB`));
+  // const zipContent = zipBuffer.toString('base64');
+
+
+
+};
+
+export const unZipFromArchive = async (fileName) => {
+  await unarchive(fileName, 'temp');
+};
+
+
+export const restoreDependenciesFromPackage = async () => {
+  const currentDirectory = process.cwd();
+  const tempDirectory = join(currentDirectory, "temp");
+  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 archive.`))
+    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);
+
+  // update current package json file
+  fs.writeFileSync(currentPackagePath, JSON.stringify(cData, null, 4), { encoding: 'utf8' });
+
+
+}
+
+export const getHaveDependencyDifference = () => {
+  return haveDependencyDifference;
+}
+
+export const restoreFromArchive = async (fileName, orgLibName, version) => {
+  const currentDirectory = process.cwd();
+  const tempDirectory = join(currentDirectory, "temp");
+  const archiveDirectory = join (currentDirectory, ARCHIVES_PATH, `${orgLibName}`, `${version}`);
+  const archFileName = join(archiveDirectory, fileName);
+
+  await unZipFromArchive(archFileName);
+
+  const tempConfigPath = join(tempDirectory, TASKS_CONFIG_JSON_FILENAME);
+  const currentConfigPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
+  const tempPackagePath = join (tempDirectory, PACKAGE_JSON_FILENAME);
+  const currentPackagePath = join(currentDirectory, PACKAGE_JSON_FILENAME);
+  const tempDirectoryComponents = join(tempDirectory, "src", "components");
+  const currentComponentsPath = join(currentDirectory, "src", "components");
+
+
+  let contents = fs.readFileSync(tempConfigPath);
+  fs.writeFileSync(currentConfigPath, contents);
+
+  // 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('\nUnarchived components are in /temp directory.\n'));
+      console.log(chalk.red('\nYou can migrate /temp/components to src/components manually.\n'));
+      console.log(chalk.red('\nYou can replace /temp/tasks.config.json with tasks.config.json.\n'));
+      process.exit();
+    }
+  }
+
+  // copy temp src/components
+  fs.cpSync(tempDirectoryComponents, currentComponentsPath, { recursive: true, force: true  });
+
+  // remove temp
+  fs.rmSync(tempDirectory, { recursive: true, force: true, maxRetries: 2  });
+
+};
+
+export const clearSrcComponentsDirectory = async () => {
+  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 () => {
+addDebugLog("hasArchives", "call", "");
+  const currentDirectory = process.cwd();
+  const archiveDirectory = join (currentDirectory, ARCHIVES_PATH);
+  const hasArc = fs.existsSync(archiveDirectory);
+addDebugLog("hasArchives", `${hasArc}`, "");
+  return hasArc;
+};
+
+export const deleteArchives = async () => {
+  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 () => {
+
+  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) => {
+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 = "") => {
+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 getLibraryArchivesFiles = async (orgLibName, version) => {
+// addDebugLog("getLibraryArchives", `orgLibName: ${orgLibName}`, "");
+//   const currentDirectory = process.cwd();
+//   const archiveDirectory = join (currentDirectory, ARCHIVES_PATH, `${orgLibName}`, `${version}`);
+
+//   if (!fs.existsSync(archiveDirectory)) {
+//     return [];
+//   }
+
+//   return fs
+//     .readdirSync(archiveDirectory, { withFileTypes: true })
+//     .filter(dirent => !dirent.isDirectory() && !isHiddenFile(dirent.name)  )
+//     .map(dirent => dirent.name);
+
+// };
+
+export const getLibraryArchivesVersions = async (orgLibName, currentVersion) => {
+addDebugLog("getLibraryArchivesVersions", `orgLibName: ${orgLibName}`, "");
+  // const archFileList = await getLibraryArchivesFiles(orgLibName, currentVersion);
+  // let archiveVersionList = [];
+
+  // if (archFileList && archFileList.length > 0) {
+  //   for (let index in archFileList) {
+  //     let fileName = archFileList[index];
+  //     let fVersion = fileName.replace(orgLibName.concat("_"), "");
+  //     fVersion = fVersion.replace(".zip", "");
+  //     if (currentVersion != fVersion) {
+  //       archiveVersionList.push(fVersion);
+  //     }
+
+  //   }
+  // }
+  // else {
+  //   console.error(
+  //     `${chalk.red.bold(`No archives found for ${orgLibName}.`)}`
+  //   );
+  //   process.exit(1);
+  // }
+
+  // if (archiveVersionList.length == 0) {
+  //   console.error(
+  //     `${chalk.red.bold(`No archives found for ${orgLibName} beyond current version.`)}`
+  //   );
+  //   process.exit(1);
+  // }
+
+  //   return archiveVersionList;
+
+  const currentDirectory = process.cwd();
+  const archiveDirectory = join (currentDirectory, ARCHIVES_PATH, `${orgLibName}`);
+
+  // const currentVersion = getConfigDefaults().buildVersion;
+
+  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) => {
+  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}/${version}`)}`);
+    throw new Error(`No such file ${libraryName}`);
+  }
+
+
+}
+
+export const deleteLocalArchiveLibraryVersion = async(libraryName, 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}`);
+  }
+
+}
+
+
+// init
+await forceDefaultsUpdate();