@pega/custom-dx-components 0.25.12 → 0.25.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pega/custom-dx-components",
-  "version": "0.25.12",
+  "version": "0.25.14",
   "description": "Utility for building custom UI components",
   "bin": "./bin/index.js",
   "scripts": {
@@ -19,7 +19,7 @@
     "@babel/plugin-transform-class-properties": "^7.25.9",
     "@babel/preset-react": "^7.26.3",
     "@pega/auth": "^0.2.23",
-    "@pega/constellation-dx-components-build-utils": "^1.0.1",
+    "@pega/constellation-dx-components-build-utils": "^2.0.0-dev",
     "@pega/inquirer-fuzzy-path": "^3.0.0",
     "ajv": "^8.17.1",
     "ajv-keywords": "^5.1.0",

package/src/constants.js

@@ -1,6 +1,7 @@
 // cSpell:ignore words timeofday caseview casepreview objectview
 export const TASKS_CONFIG_JSON_FILENAME = 'tasks.config.json';
 export const PACKAGE_JSON_FILENAME = 'package.json';
+export const PACKAGE_LOCK_JSON_FILENAME = 'package-lock.json';
 export const BUILD_CONFIG_JSON_FILENAME = 'build.config.json';
 export const WEBPACK_CONFIG_JS_FILENAME = 'webpack.config.js';
 export const WEBPACK_PATHS_JS_FILENAME = 'paths.js';
@@ -39,6 +40,9 @@ export const LP_DELETE_COMPONENT_SERVICE_REST_ENDPOINT =
   'pegalaunchpad/c11n/isolations/{isolationId}/v102/assetsUpdate';
 
 export const PUBLISH_COMPONENT_LIBRARY_SERVICE_REST_ENDPOINT = 'PRRestService/dev/v1/publish_component_library';
+export const PUBLISH_COMPONENT_ARCHIVE_SERVICE_REST_ENDPOINT = 'PRRestService/dev/v1/publish_component_archive';
+export const LIST_COMPONENT_LIBRARIES_SERVICE_REST_ENDPOINT = 'PRRestService/dev/v1/list_component_libraries';
+
 
 export const FIELD_PATH = '/field';
 export const TEMPLATE_PATH = '/template';

package/src/tasks/build-lib/index.js

@@ -3,7 +3,7 @@ import inquirer from 'inquirer';
 import { Listr } from 'listr2';
 import chalk from 'chalk';
 
-import { buildLib } from '@pega/constellation-dx-components-build-utils/index.js';
+import { buildLib, buildLibV3 } from '@pega/constellation-dx-components-build-utils/index.js';
 
 import validate from '../validator/index.js';
 import { lintComponent } from '../linter/index.js';
@@ -115,7 +115,7 @@ addDebugLog("localBuildLibrary", `organization: ${organization}, library: ${libr
   // with subdirectories for each version.
   // If "buildDev", we append to version "-dev".  Currently, only "-dev" versions, when published, can be deleted.
 addDebugLog("buildLib", "services call", "");
-  buildLib(
+  buildLibV3(
     buildLibName,
     buildVersion,
     tokenAndStaticServer.C11NB2S,

package/src/tasks/export-archive/helper.js

@@ -110,6 +110,20 @@ addDebugLog("getLibraryVersionQuestion", "", "");
   ];
 };
 
+export const getServerOrDirectoryQuestion = async () => {
+  addDebugLog("getLibraryVersionQuestion", "", "");
+
+      return [
+      {
+        name: 'exportTo',
+        type: 'rawlist',
+        message: `Export to`,
+        choices:  [{name: 'Local directory', value: 'Directory'}, {name: 'Server', value: 'Server'}],
+        defaut: 'Directory'
+      }
+    ];
+  };
+
 export const getFullArchiveQuestions = async () => {
 
   return [

package/src/tasks/export-archive/index.js

@@ -14,13 +14,16 @@ import {
   checkLibraryAndArchives,
   getConfigDefaults,
   getLibraryBased,
+  getLibraryBasedCL,
   zipVersionAndArchive,
   zipVersionAndArchiveCL,
-  cleanUpTemp
+  cleanUpTemp,
+  checkAccessTokenExpiration
  } from '../../util.js';
 import { TASKS_CONFIG_JSON_FILENAME, ARCHIVES_PATH, BIN_ARCHIVES_PATH } from '../../constants.js';
-import { getFilePathQuestions, getLibraryQuestion, getLibraryVersionQuestion, updateSavedExportFilePath, getFullArchiveQuestions  } from './helper.js';
+import { getFilePathQuestions, getLibraryQuestion, getLibraryVersionQuestion, updateSavedExportFilePath, getFullArchiveQuestions, getServerOrDirectoryQuestion  } from './helper.js';
 import { localBuildLibrary } from '../build-lib/index.js';
+import publishArchive from '../publish-archive/index.js';
 
 import inquirerFuzzyPath from '@pega/inquirer-fuzzy-path';
 
@@ -293,22 +296,26 @@ export default async options => {
   await checkLibraryAndArchives();
 
   await checkPathAccess(pegaConfigJsonPath);
+
   const isLibraryBased = getLibraryBased();
   if (!isLibraryBased) {
     console.log(`Command only supported for ${chalk.bold.green('library mode')} components.`)
     process.exit();
   }
+  const isLibraryBasedCL = getLibraryBasedCL();
 
   await cleanUpTemp();
 
   addDebugLog("exportArchive", "", "+");
 
+  let exportTo = "";
 
   if (options.params.length >= 8) {
     let fullArchive = options.params[3];
     const libraryName = options.params[4];
     const libraryVersion = options.params[5];
     const filePath = options.params[6];
+    exportTo = "Directory";
 
 
     const currentOrArchive = options.params[7];
@@ -321,6 +328,7 @@ export default async options => {
     let selectedVersion = "";
     let fullArchive = "";
 
+
     if (options.params.length >= 5) {
       fullArchive = options.params[3];
       orgLibName = options.params[4];
@@ -370,23 +378,48 @@ export default async options => {
         ({ selectedVersion } = libraryVersionAnswer);
       }
 
-      inquirer.registerPrompt('fuzzypath', inquirerFuzzyPath);
+      if (isLibraryBasedCL) {
+        if (exportTo === "") {
+          const serverOrDirectoryQuestion = await getServerOrDirectoryQuestion();
+          const serverOrDirectoryAnswer = await inquirer.prompt(serverOrDirectoryQuestion);
+          ({ exportTo } = serverOrDirectoryAnswer);
+        }
+      }
+      else {
+        exportTo = "Directory";
+      }
 
-      filePathQuestions = await getFilePathQuestions();
-      filePathAnswers = await inquirer.prompt(filePathQuestions);
-      ({ filePath } = filePathAnswers);
 
-      await updateSavedExportFilePath(filePath);
+      if (exportTo === "Directory") {
+        inquirer.registerPrompt('fuzzypath', inquirerFuzzyPath);
+
+        filePathQuestions = await getFilePathQuestions();
+        filePathAnswers = await inquirer.prompt(filePathQuestions);
+        ({ filePath } = filePathAnswers);
+
+        await updateSavedExportFilePath(filePath);
+
+        // if (path.sep === "/") {
+        //   if (filePath.lastIndexOf(path.sep) != filePath.length - 1) {
+        //     filePath = filePath.concat(path.sep);
+        //   }
+        // }
+
+        await exportArch( filePath, orgLibName, selectedVersion, fullArchive);
+
+      }
+      else {
+        await checkAccessTokenExpiration();
+
+        // publish to server
+        await publishArchive(orgLibName, selectedVersion);
+
+      }
+
 
     }
 
-    // if (path.sep === "/") {
-    //   if (filePath.lastIndexOf(path.sep) != filePath.length - 1) {
-    //     filePath = filePath.concat(path.sep);
-    //   }
-    // }
 
-    await exportArch( filePath, orgLibName, selectedVersion, fullArchive);
 
   }
 

package/src/tasks/init/template/package.json.mustache

@@ -106,7 +106,7 @@
     "@babel/preset-react": "^7.26.3",
     "@babel/preset-typescript": "^7.26.0",
     "@pega/configs": "^0.16.2",
-    "@pega/custom-dx-components": "~0.25.12",
+    "@pega/custom-dx-components": "~0.25.14",
     "@pega/pcore-pconnect-typedefs": "^4.1.0-alpha.1",
     "@storybook/addon-actions": "^7.6.19",
     "@storybook/addon-essentials": "^7.6.19",

package/src/tasks/list-pub/helper.js

@@ -1,12 +1,22 @@
+
+import fs from 'fs';
+import path from 'path';
 import chalk from 'chalk';
+import fetch from 'node-fetch';
+import { join } from 'path';
 
 import {
   getPegaServerConfig,
   addDebugLog,
-  getC11NB2STokenAndStaticServer
+  getC11NB2STokenAndStaticServer,
+  getApplicationAndVersionFromToken,
+  constructCompleteUrl,
+  getHttpsAgent,
+  getConfigDefaults
 } from '../../util.js';
 
 import { listLibJSONResponse } from '@pega/constellation-dx-components-build-utils/index.js';
+import { LIST_COMPONENT_LIBRARIES_SERVICE_REST_ENDPOINT, TOKEN_PATH } from '../../constants.js';
 
 export const SOURCE_OF_COMPONENT_TYPES = {
   SERVER: 'Server',
@@ -72,3 +82,96 @@ addDebugLog("listLibJSONResponse", "services end", "");
   return [];
 
 }
+
+async function fetchComponenLibrariessFromInfinity(apiUrl, headers) {
+  addDebugLog("fetchComponenLibrariessFromInfinity", `apiUrl: ${apiUrl}`, "");
+    const serverConfig = await getPegaServerConfig();
+    return new Promise((resolve, reject) => {
+      let status = 500;
+      fetch(apiUrl, {
+        method: 'GET',
+        agent: getHttpsAgent(serverConfig),
+        headers
+      })
+        .then((response) => {
+          status = response.status;
+          if (status === 401) {
+            throw new Error('Error occurred in authentication. Please regenerate using authenticate');
+          }
+          else if (status === 404){
+            throw new Error('404: Server resource not found');
+          }
+          else if (status === 405){
+            throw new Error('405: Server method not allowed');
+          }
+          else if (status === 408){
+            throw new Error('408: Server timed out');
+          }
+          return response.json();
+        })
+        .then((resp) => {
+          // const respData = JSON.parse(resp);
+          if (status === 401) {
+            throw new Error('Error occurred in authentication. Please regenerate using authenticate');
+            // console.log(accessTokenUri, refreshToken);
+            /* TODO - Handle refresh_token */
+          } else if (status === 200) {
+            resolve(resp);
+          } else {
+            throw new Error(`${resp.message}`);
+          }
+        })
+        // eslint-disable-next-line prefer-promise-reject-errors
+        .catch((e) => reject(`${chalk.bold.red(e)}`));
+    });
+  }
+
+export const getInfinityLibraries = async() => {
+addDebugLog("getInfinityLibraries", '', "");
+
+  const { app_name, app_version } = await getApplicationAndVersionFromToken();
+  const defaultPegaServerConfig = await getPegaServerConfig();
+  let url = constructCompleteUrl(
+    defaultPegaServerConfig.server,
+    LIST_COMPONENT_LIBRARIES_SERVICE_REST_ENDPOINT
+  );
+
+  const ApplicationName = app_name;
+  const ApplicationVersion = app_version;
+  const rulesetName = defaultPegaServerConfig.rulesetName;
+  const rulesetVersion = defaultPegaServerConfig.rulesetVersion;
+
+  let urlParams = `/AppName/${ApplicationName}/AppVersion/${ApplicationVersion}/ruleset/${rulesetName}/rulesetVersion/${rulesetVersion}`;
+  //let urlParams = `&ApplicationName=${ApplicationName}&ApplicationVersion=${ApplicationVersion}&RulesetName=${rulesetName}&RulesetVersion=${rulesetVersion}`;
+  //urlParams = encodeURIComponent(urlParams);
+
+
+  url = url.concat(urlParams);
+
+  return new Promise((resolve, reject) => {
+    try {
+      fs.readFile(TOKEN_PATH, 'utf8', (err, data) => {
+        if (err) {
+          // eslint-disable-next-line prefer-promise-reject-errors
+          reject(`\n${chalk.bold.red('Error occurred in authentication. Please regenerate using authenticate')}`);
+        }
+        if (data) {
+          const { access_token: accessToken, token_type: tokenType } = JSON.parse(data);
+
+          const headers = {};
+          headers.Authorization = `${tokenType} ${accessToken}`;
+
+          fetchComponenLibrariessFromInfinity(url, headers)
+            .then((response) => resolve(response))
+            .catch((e) => reject(e));
+
+        }
+      });
+    } catch (error) {
+      console.log(`\n${chalk.bold.red(error)}`);
+      // eslint-disable-next-line prefer-promise-reject-errors
+      reject(`${chalk.bold.red(error)}`);
+    }
+  });
+
+}

package/src/tasks/list-pub/index.js

@@ -1,11 +1,11 @@
 import inquirer from 'inquirer';
 import chalk from 'chalk';
 
-import {showVersion, getC11NB2STokenAndStaticServer, getLocalLibraries, getLocalLibraryVersions, getLocalLibraryVersionData, getLibraryBased, addDebugLog, checkLibraryAndArchives, getConfigDefaults, cleanUpTemp } from '../../util.js';
+import {showVersion, getC11NB2STokenAndStaticServer, getLocalLibraries, getLocalLibraryVersions, getLocalLibraryVersionData, getLibraryBased, addDebugLog, checkLibraryAndArchives, getConfigDefaults, cleanUpTemp, getPegaServerConfig } from '../../util.js';
 
 import { listLibJSONResponse } from '@pega/constellation-dx-components-build-utils/index.js';
 
-import { getListLibraryQuestions, SOURCE_OF_COMPONENT_TYPES, getServerLibraries, getServerLocalQuestion } from './helper.js';
+import { getListLibraryQuestions, SOURCE_OF_COMPONENT_TYPES, getServerLibraries, getInfinityLibraries,  getServerLocalQuestion } from './helper.js';
 
 
 
@@ -139,6 +139,50 @@ addDebugLog("listPublished", "END", "-");
   }
   else {
 
+    const arLibs = await getInfinityLibraries();
+
+    if (arLibs && arLibs.pxResults && arLibs.pxResults.length > 0) {
+
+      const libs = arLibs.pxResults.map((oLib, index) => ({ name: oLib.pyLabel, value: index}));
+
+
+      const libAnswers = await inquirer.prompt([
+        {
+          name: 'library',
+          type: 'rawlist',
+          message: 'Pick library',
+          choices: libs
+        }
+      ]);
+
+      const libraryIndex = libAnswers.library;
+
+      const data = JSON.parse(arLibs.pxResults[libraryIndex].pxComponentDefinition);
+
+      // get built on from first component if exists
+      let builtOn = "(date unavailable)";
+      if (data[0] && data[0].buildDate) {
+        builtOn = data[0].buildDate;
+      }
+
+      let libData = data.map((component) => ( {'Component': component.name, 'Label': component.label, 'Version': component.version, 'Type': component.type, 'Sub Type' : component.subtype}));
+      console.log(chalk.bold.blueBright(`\nList of ${libraryName}:${selectedVersion} components built on ${builtOn}.`));
+      console.table(libData, ['Component', 'Label', 'Version', 'Type', 'Sub Type']);
+
+    }
+    else {
+      // No library with that name
+      const serverConfig = await getPegaServerConfig();
+      console.log(chalk.redBright(`No server component libraries exist in given ruleset ${chalk.bold(`${serverConfig.rulesetName}:${serverConfig.rulesetVersion}`)}`));
+      console.log(chalk.redBright(`You need to publish a library to this ruleset first.`));
+addDebugLog("listPublished", "END", "-");
+      process.exit(1);
+
+    }
+
+/*
+    // old app static server
+
     const arLibs = await getServerLibraries();
     if (arLibs && arLibs.length > 0) {
 
@@ -180,11 +224,10 @@ addDebugLog("listPublished", "END", "-");
         let libData = data.map((component) => ( {'Component': component.name, 'Label': component.label, 'Version': component.version, 'Type': component.type, 'Sub Type' : component.subtype}));
         console.log(chalk.bold.blueBright(`\nList of ${libraryName}:${selectedVersion} components built on ${builtOn}.`));
         console.table(libData, ['Component', 'Label', 'Version', 'Type', 'Sub Type']);
-    }
-    else {
-      console.log(chalk.red("No libraries available on server."));
-    }
-
+      }
+      else {
+        console.log(chalk.red("No libraries available on server."));
+      }
 
 
     }
@@ -196,6 +239,7 @@ addDebugLog("listPublished", "END", "-");
       process.exit(1);
 
     }
+    */
 
   }
 

package/src/tasks/publish/index.js

@@ -6,7 +6,7 @@ import fs from 'fs';
 import validate from '../validator/index.js';
 import bundleComponent from '../bundle/index.js';
 import { lintComponent } from '../linter/index.js';
-import { getComponentDirectoryPath, showVersion, getLibraryBased, addDebugLog, getPegaServerConfig, updateServerConfigRuleSetAndVersion, checkLibraryAndArchives, getConfigDevBuild, checkAccessTokenExpiration, checkJWTExpiration, getConfigDefaults } from '../../util.js';
+import { getComponentDirectoryPath, showVersion, getLibraryBased, addDebugLog, updateServerConfigRuleSetAndVersion, checkLibraryAndArchives, getConfigDevBuild, checkAccessTokenExpiration, checkJWTExpiration, getConfigDefaults } from '../../util.js';
 
 import { getPublishComponentQuestions, publishComponentToServer, zipComponent } from './helper.js';
 import { default as buildLibrary } from '../build-lib/index.js';
@@ -26,6 +26,9 @@ addDebugLog("publish", "", "+");
 
   await checkAccessTokenExpiration();
 
+  //
+  // library based V2 publishing
+  //
   if (isLibraryBased) {
 
     await checkJWTExpiration();
@@ -106,9 +109,15 @@ addDebugLog("publish", "", "+");
 
     }
 
+    // end of V2 publishing
     return true;
   }
 
+  // otherwise continue with original V1 publishig of individual components
+
+  //
+  // orginial V1 publish
+  //
 
   let OauthData;
   try {

package/src/tasks/publish-archive/helper.js

@@ -0,0 +1,58 @@
+import {
+  addDebugLog,
+  getPegaServerConfig,
+  validateRulesetVersion
+} from '../../util.js';
+
+
+export const getLibraryVersionQuestion = async(libVersions) => {
+addDebugLog("getLibraryVersionQuestion", `libVersions: ${libVersions}`, "");
+    return [
+      {
+        name: 'version',
+        type: 'rawlist',
+        message: 'Select library version to publish',
+        choices: libVersions
+      }
+    ];
+
+}
+
+export const getPublishComponentQuestions = async componentKey => {
+addDebugLog("getPublishComponentQuestions", `componentKey: ${componentKey}`, "");
+
+
+  const defaultPegaConfig = await getPegaServerConfig();
+
+  return [
+    {
+      name: 'rulesetName',
+      message: 'Enter ruleset name',
+      default: defaultPegaConfig.rulesetName,
+      validate: value => {
+        if (value.trim()) {
+          return true;
+        }
+        return 'Ruleset name cannot be empty';
+      },
+      when: () => {
+        return defaultPegaConfig.serverType === 'infinity';
+      }
+    },
+    {
+      name: 'rulesetVersion',
+      message: 'Enter ruleset version',
+      default: defaultPegaConfig.rulesetVersion,
+      validate: value => {
+        if (validateRulesetVersion(value)) {
+          return true;
+        }
+        return 'Please provide compatible version e.g 01-01-01';
+      },
+      when: () => {
+        return defaultPegaConfig.serverType === 'infinity';
+      }
+    }
+  ];
+
+};

package/src/tasks/publish-archive/index.js

@@ -0,0 +1,257 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import fetch from 'node-fetch';
+import { join } from 'path';
+import fs from 'fs';
+
+
+import { zipUnArchiveToTempAndReturnBuffer, constructCompleteUrl, getHttpsAgent, getPegaServerConfig, addDebugLog, getConfigDefaults, zipVersionAndArchiveAndReturnBuffer } from '../../util.js';
+
+import { getPublishComponentQuestions } from './helper.js';
+
+import {
+  LP_PUBLISH_COMPONENT_SERVICE_REST_ENDPOINT,
+  PUBLISH_COMPONENT_ARCHIVE_SERVICE_REST_ENDPOINT,
+  TEMP_PATH,
+  TOKEN_PATH,
+  ARCHIVES_PATH
+} from '../../constants.js';
+
+
+export const publishComponentLibraryArchiveToServer = async (data, doFetch) => {
+  addDebugLog("publishComponentToServer", `data: ${data}`, "");
+    const { zipContent, rulesetName, rulesetVersion, libraryName, version } = data;
+
+    const defaultPegaServerConfig = await getPegaServerConfig();
+    const { serverType, isolationId } = defaultPegaServerConfig;
+    const isLaunchpad = serverType === 'launchpad';
+    const launchpadRestEndpoint = LP_PUBLISH_COMPONENT_SERVICE_REST_ENDPOINT.replace(
+      '{isolationId}',
+      isolationId || 'undefined'
+    );
+    let apiBody;
+
+    if (isLaunchpad) {
+      // currently no launchpad records to rule resolve a library
+
+      // apiBody = {
+      //   type: 'CustomComponent',
+      //   zipContent,
+      //   componentName: JSON.parse(configContent).componentKey,
+      //   pxUpdateDateTime: '',
+      //   environmentID: defaultPegaServerConfig.isolationId
+      // };
+    } else {
+      apiBody = {
+        zipContent,
+        publishFor: 'constellation',
+        rulesetName,
+        rulesetVersion,
+        libraryName,
+        version,
+        category: ''
+      };
+    }
+
+    const defaultPegaConfig = await getPegaServerConfig();
+    const url = constructCompleteUrl(
+      defaultPegaConfig.server,
+      isLaunchpad ? launchpadRestEndpoint : PUBLISH_COMPONENT_ARCHIVE_SERVICE_REST_ENDPOINT
+    );
+
+    if (doFetch) {
+      try {
+        const OauthData = fs.readFileSync(TOKEN_PATH, 'utf8');
+        if (OauthData) {
+          const {
+            access_token: accessToken,
+            token_type: tokenType
+            // refresh_token: refreshToken
+          } = JSON.parse(OauthData);
+          let status = 500;
+          let headers = {};
+
+          if (isLaunchpad) {
+            headers.cookie = `Pega-AAT=${accessToken}`;
+            headers['Content-Type'] = 'application/json';
+          } else {
+            headers.Authorization = `${tokenType} ${accessToken}`;
+          }
+
+          const response = await fetch(url, {
+            method: 'POST',
+            agent: getHttpsAgent(defaultPegaConfig),
+            headers,
+            body: JSON.stringify(apiBody)
+          });
+
+          status = response.status;
+          if (!response.ok) {
+            if (status === 401) {
+              throw new Error(
+                'Error occurred in authentication. Please regenerate using authenticate'
+              );
+              // console.log(accessTokenUri, refreshToken);
+              /* TODO - Handle refresh_token */
+            } else if (status === 404) {
+              throw new Error('404: Server resource not found');
+            } else if (status === 405) {
+              throw new Error('405: Server method not allowed');
+            } else if (status === 408) {
+              throw new Error('408: Server timed out');
+            } else if (response.status === 403) {
+              throw new Error('Error forbidden: User does not have privileges to Publish.');
+            }
+          }
+
+          try {
+            const respData = isLaunchpad ? await response.text() : await response.json();
+            console.log(chalk.bold.green(`Success : ${isLaunchpad ? respData : respData.message}`));
+
+            if (status === 500) {
+              status = 999;
+              throw new Error(respData.message);
+            }
+          } catch (err) {
+            if (status === 500) {
+              throw new Error(
+                `Error occurred in authentication. Please regenerate using authenticate`
+              );
+            } else if (status === 999) {
+              throw new Error(err);
+            }
+          }
+        } else {
+          throw new Error(`Error occurred in authentication. Please regenerate using authenticate`);
+        }
+      } catch (err) {
+        // throw new Error(`Error occurred in authentication. Please regenerate using authenticate`);
+        throw Error(err);
+      }
+    }
+  };
+
+
+
+
+
+
+
+
+export default async (orgLibName, selectedVersion) => {
+  // console.log(orgLibName + ", " + selectedVersion);
+  const configDef = await getConfigDefaults();
+  let archiveBeforeStore = false;
+
+
+  const rulesetQuestions = await getPublishComponentQuestions();
+  const rulesetAnswers = await inquirer.prompt(rulesetQuestions);
+  const { rulesetName, rulesetVersion} = rulesetAnswers;
+
+  let content = {
+    libraryName : orgLibName,
+    version : selectedVersion,
+    rulesetName, rulesetVersion
+  };
+
+
+  if (orgLibName === configDef.currentOrgLib && selectedVersion === configDef.buildVersion) {
+
+    console.log("\nYou've selected the current working library/version.");
+    console.log("Export store or the current.");
+    const archAnswers = await inquirer.prompt([
+      {
+        name: 'currentOrStore',
+        type: 'rawlist',
+        message: 'Select current or store',
+        default: "Current",
+        choices: ["Current", "Store"]
+      },
+    ]);
+
+    const currentOrStore = archAnswers.currentOrStore;
+
+    if (currentOrStore === "Current") {
+      archiveBeforeStore = true;
+    }
+
+    if (archiveBeforeStore) {
+
+      // returns both the output promise and the buffer that can be sent to PegaInfinity
+      let zipBuffer = await zipVersionAndArchiveAndReturnBuffer(configDef.currentOrgLib, configDef.buildVersion);
+
+      zipBuffer.output.on('close', function() {
+        if (zipBuffer.zipContent != null) {
+          content = { ...content, zipContent: zipBuffer.zipContent};
+
+          try {
+            publishComponentLibraryArchiveToServer(content, true )
+            .then( () => {
+              console.log(chalk.green.bold(`Success: Published Archive ${content.libraryName}/${content.version} to server.`));
+            })
+            .catch( (err) =>  {
+              console.log(chalk.red.bold(err));
+            })
+          }
+          catch (err) {
+            console.log(chalk.bold.red(err.toString()));
+          }
+
+        }
+
+      });
+
+      return;
+
+    }
+  }
+  else {
+
+    // for now, to get a "buffer" from a zip file, need to unzip it in a /temp directory
+    // then re-zip.  During the re-zip, create a buffer that can be passed to PegaInfinity
+
+    const mainDirectory = process.cwd();
+    const archiveFileName = `${orgLibName}_${selectedVersion}.arch.zip`;
+    const archiveDirectory = join (mainDirectory, ARCHIVES_PATH, `${orgLibName}`, `${selectedVersion}`);
+    if (fs.existsSync(archiveDirectory)) {
+      const archiveFile = join(archiveDirectory, archiveFileName);
+
+      // unzip to /temp, then re-zip and retrieve the buffer (remove /temp later)
+      let zipBuffer = await zipUnArchiveToTempAndReturnBuffer(orgLibName, selectedVersion);
+
+      zipBuffer.output.on('close', function() {
+
+        // get rid of temp directory, regardless
+        const tempDirectory = join (mainDirectory, TEMP_PATH);
+        if (fs.existsSync(tempDirectory)) {
+          fs.rmSync(tempDirectory, { recursive: true });
+        }
+
+        if (zipBuffer.zipContent != null) {
+
+          content = { ...content, zipContent: zipBuffer.zipContent};
+
+          try {
+            publishComponentLibraryArchiveToServer(content, true )
+            .then( () => {
+              console.log(chalk.green.bold(`Success: Published Archive ${content.libraryName}/${content.version} to server.`));
+            })
+            .catch( (err) =>  {
+              console.log(chalk.red.bold(err));
+            })
+          }
+          catch (err) {
+            console.log(chalk.bold.red(err.toString()));
+          }
+
+
+
+        }
+
+      });
+
+    }
+
+
+  }
+};

package/src/tasks/publish-lib/index.js

@@ -11,6 +11,7 @@ import { lintComponent } from '../linter/index.js';
 import { constructCompleteUrl, getComponentDirectoryPath, getHttpsAgent, getPegaServerConfig, showVersion, getC11NB2STokenAndStaticServer, getLocalLibraryVersions, getLibraryBased, getLibraryBasedCL, deletePublishExtras, addDebugLog, checkLibraryAndArchives, checkJWTExpiration, getConfigDefaults } from '../../util.js';
 
 import { publishLib, listLibJSONResponse, deleteLibVersion } from '@pega/constellation-dx-components-build-utils/index.js';
+import { default as buildLibrary } from '../build-lib/index.js';
 
 import { getLibraryVersionQuestion } from './helper.js';
 
@@ -192,18 +193,25 @@ export const publishComponentLibraryToServer = async (data, doFetch) => {
           }
 
           try {
-            const respData = isLaunchpad ? await response.text() : await response.json();
-            console.log(chalk.bold.green(`Success : ${isLaunchpad ? respData : respData.message}`));
+            // const respData = isLaunchpad ? await response.text() : await response.json();
+            const headerType = response.headers.get('content-type');
+            const respData = headerType.includes("json") ? await response.json() : await response.text();
+            let respMessage = headerType.includes("json") ? respData.message : respData;
+
 
             if (status === 500) {
               status = 999;
-              throw new Error(respData.message);
+              if (respMessage === '') {
+                respMessage = `Server error, please check server logs for error.`;
+              }
+              throw new Error(respMessage);
             }
+
+            console.log(chalk.bold.green(`Success : ${respMessage }`));
+
           } catch (err) {
             if (status === 500) {
-              throw new Error(
-                `Error occurred in authentication. Please regenerate using authenticate`
-              );
+              throw new Error(`Server error, please check server logs for error.`);
             } else if (status === 999) {
               throw new Error(err);
             }
@@ -238,7 +246,7 @@ export const publishUILibraryComponentToInfinity = async (content) => {
     await publishComponentLibraryToServer(content, true );
     // console.log(chalk.green.bold(`Success: Published ${content.libraryName}/${content.version} to server as a CL.`));
   }
-  catch (ex) {
+  catch (err) {
     console.log(chalk.bold.red(err.toString()));
   }
 
@@ -417,62 +425,64 @@ addDebugLog("publishLibrary", "", "+");
       return;
     }
 
-    if (okToPublish) {
-
- // /*
-
-      let libVersionExists = await doesLibraryExist(libraryName, version);
-      let overrideExisting = false;
-      let checkDeleted = false;
 
-      await deletePublishExtras(libraryName, version);
+    const isLibraryBasedCL =  getLibraryBasedCL();
+    if (okToPublish) {
+      if (isLibraryBasedCL) {
+        // developer test
 
+        let content = { libraryName, version, rulesetName, rulesetVersion };
+        await publishUILibraryComponentToInfinity(content);
 
-      if (libVersionExists) {
-          console.log("\nLibrary " + chalk.bold.yellow(`${libraryName}/${version}`) + " already exists.");
-          const questions = [
-            {
-              name: 'override',
-              type: 'confirm',
-              message: `Do you wish to overrite it`,
-              default: false
-            }
-          ];
 
-          await inquirer.prompt(questions).then(async answers => {
-            overrideExisting = answers.override;
-            });
       }
-
-      if (libVersionExists) {
-        if (overrideExisting) {
-          console.log("\nDeleting existing library " + chalk.bold.yellow(`${libraryName}:${version}`) + " ...");
-addDebugLog("deleteLibVersion", `services call: libraryName: ${libraryName}, version: ${version}`, "");
-          await deleteLibVersion(libraryName, version, tokenAndStaticServer.C11NB2S, tokenAndStaticServer.appStaticContentServer);
-addDebugLog("deleteLibVersion", "services end", "");
-          checkDeleted = true;
-        }
-        else {
-          // don't override, so end
-          console.log(chalk.yellow(`You will need to increment your library version to publish`));
-addDebugLog("publishLibrary", "END", "-");
-          return;
+      else {
+        let libVersionExists = await doesLibraryExist(libraryName, version);
+        let overrideExisting = false;
+        let checkDeleted = false;
+
+        await deletePublishExtras(libraryName, version);
+
+
+        if (libVersionExists) {
+            console.log("\nLibrary " + chalk.bold.yellow(`${libraryName}/${version}`) + " already exists.");
+            const questions = [
+              {
+                name: 'override',
+                type: 'confirm',
+                message: `Do you wish to overrite it`,
+                default: false
+              }
+            ];
+
+            await inquirer.prompt(questions).then(async answers => {
+              overrideExisting = answers.override;
+              });
         }
-      }
 
-      // need a timeout to give services time to delete the library
-      // setTimeout( function(){ await publishNewLibraryAsync(libraryName, version, checkDeleted)}, 700 );
-      await publishNewLibraryAsync(libraryName, version, checkDeleted);
- // */
+        if (libVersionExists) {
+          if (overrideExisting) {
+            console.log("\nDeleting existing library " + chalk.bold.yellow(`${libraryName}:${version}`) + " ...");
+  addDebugLog("deleteLibVersion", `services call: libraryName: ${libraryName}, version: ${version}`, "");
+            await deleteLibVersion(libraryName, version, tokenAndStaticServer.C11NB2S, tokenAndStaticServer.appStaticContentServer);
+  addDebugLog("deleteLibVersion", "services end", "");
+            checkDeleted = true;
+          }
+          else {
+            // don't override, so end
+            console.log(chalk.yellow(`You will need to increment your library version to publish`));
+  addDebugLog("publishLibrary", "END", "-");
+            return;
+          }
+        }
 
-      // developer test
-      const isLibraryBasedCL =  getLibraryBasedCL();
-      if (isLibraryBasedCL) {
-        let content = { libraryName, version, rulesetName, rulesetVersion };
+        // need a timeout to give services time to delete the library
+        // setTimeout( function(){ await publishNewLibraryAsync(libraryName, version, checkDeleted)}, 700 );
+        await publishNewLibraryAsync(libraryName, version, checkDeleted);
 
-        await publishUILibraryComponentToInfinity(content);
       }
 
+
     }
 
   }

package/src/util.js

@@ -21,6 +21,7 @@ import {
   COMPONENTS_CONFIG_FILE_NAME,
   TASKS_CONFIG_JSON_FILENAME,
   PACKAGE_JSON_FILENAME,
+  PACKAGE_LOCK_JSON_FILENAME,
   TOKEN_PATH,
   OOTB_COMPONENT_SERVICE_REST_ENDPOINT,
   DELETE_COMPONENT_SERVICE_REST_ENDPOINT,
@@ -42,6 +43,7 @@ import {
 } from './constants.js';
 
 
+
 const access = promisify(fs.access);
 
 let showDebug = false;
@@ -288,19 +290,34 @@ export const applyPegaData = async (configJson) => {
 if (showDebug) addDebugLog("applyPegaData", "", "");
   const tokenAndStaticServer = await getC11NB2STokenAndStaticServer();
   const currentDirectory = process.cwd()
-  const currentPackagePath = join(currentDirectory, PACKAGE_JSON_FILENAME);
-  let currentPackageData;
+  // const currentPackagePath = join(currentDirectory, PACKAGE_JSON_FILENAME);
+  const currentPackageLockPath = join(currentDirectory, PACKAGE_LOCK_JSON_FILENAME);
+  // let currentPackageData;
+  let currentPackageLockData;
+
+  // try {
+  //   currentPackageData = fs.readFileSync(currentPackagePath);
+  // }
+  // catch (ex) {
+  //   console.log(chalk.red(`\nUnable to retrieve current package.json.`));
+  //   process.exit(1);
+  // }
 
   try {
-    currentPackageData = fs.readFileSync(currentPackagePath);
+    currentPackageLockData = fs.readFileSync(currentPackageLockPath);
   }
   catch (ex) {
-    console.log($chalk.red(`\nUnable to retrieve current package.json.`))
+    console.log(chalk.red(`\nUnable to retrieve current package-lock.json.`));
     process.exit(1);
   }
 
-  const cData = JSON.parse(currentPackageData);
-  const cosmosVersion = cData.dependencies["@pega/cosmos-react-core"];
+  // const cData = JSON.parse(currentPackageData);
+  // const cosmosVersion = cData.dependencies["@pega/cosmos-react-core"];
+
+  const cData = JSON.parse(currentPackageLockData);
+  const cosmosReact = cData.packages["node_modules/@pega/cosmos-react-core"];
+  const cosmosVersion = cosmosReact.version;
+
   let infinityVersion = "";
 
   if (tokenAndStaticServer.C11NB2S === undefined) {
@@ -361,6 +378,20 @@ export const checkAccessTokenExpiration = async() => {
 
 }
 
+export const getApplicationAndVersionFromToken = async() => {
+  const tokenAndStaticServer = await getC11NB2STokenAndStaticServer();
+
+  if (tokenAndStaticServer.access_token === undefined) {
+    console.log(chalk.redBright("Need to authenticate, missing token.\n"));
+    process.exit(1);
+  }
+
+  const jwt = jwtDecode(tokenAndStaticServer.access_token);
+  const { app_name, app_version } = jwt;
+  return { app_name, app_version };
+
+}
+
 export const getLibraryBased = () => {
 if (showDebug) addDebugLog("getLibraryBased", "", "");
 //   const currentDirectory = process.cwd();
@@ -1729,6 +1760,161 @@ if (showDebug) addDebugLog("zipVersionAndArchive", `orgLibName: ${orgLibName}, v
 
 };
 
+export const zipVersionAndArchiveAndReturnBuffer = 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}.arch.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();
+
+  const zipBuffer = Buffer.concat(zipChunks);
+  const zipContent = zipBuffer.toString('base64');
+
+  return { output, zipContent};
+
+};
+
+export const zipUnArchiveToTempAndReturnBuffer = async(orgLibName, version) => {
+
+  // unarchive to temp
+  const currentDirectory = process.cwd();
+  const tempDirectory = join (currentDirectory, TEMP_PATH);
+  const srcDirectoryPath = join(tempDirectory, "src");
+
+  const archiveFileName = `${orgLibName}_${version}.arch.zip`;
+  const archiveDirectory = join (currentDirectory, ARCHIVES_PATH, `${orgLibName}`, `${version}`);
+  const archFileName = join(archiveDirectory, archiveFileName);
+
+  await unZipFromArchive(archFileName);
+
+  // archive is in temp directory
+  const archiveFile = join(tempDirectory, archiveFileName);
+
+  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(tempDirectory);
+  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();
+
+  const zipBuffer = Buffer.concat(zipChunks);
+  const zipContent = zipBuffer.toString('base64');
+
+  return { output, zipContent};
+
+
+}
+
 export const zipVersionAndArchiveCL = async (orgLibName, version, currentDirectory = "") => {
 if (showDebug) addDebugLog("zipVersionAndArchiveCL", `orgLibName: ${orgLibName}, version: ${version}, currentDirectory: ${currentDirectory}`, "");
   // const srcDirectoryPath = await getSrcDirectoryPath();