codefresh 0.78.0 → 0.78.4

package/lib/interface/cli/commands/hybrid/helper.js

@@ -40,10 +40,10 @@ const INSTALLATION_DEFAULTS = {
 const RUNTIME_IMAGES = {
     DOCKER_PUSHER_IMAGE: 'codefresh/cf-docker-pusher:6.0.3',
     DOCKER_PULLER_IMAGE: 'codefresh/cf-docker-puller:8.0.2',
-    DOCKER_TAG_PUSHER_IMAGE: 'codefresh/cf-docker-tag-pusher:v2',
+    DOCKER_TAG_PUSHER_IMAGE: 'codefresh/cf-docker-tag-pusher:1.3.0',
     DOCKER_BUILDER_IMAGE: 'codefresh/cf-docker-builder:1.1.12',
-    GC_BUILDER_IMAGE: 'codefresh/cf-gc-builder:0.4.0',
-    CONTAINER_LOGGER_IMAGE: 'codefresh/cf-container-logger:1.4.5',
+    GC_BUILDER_IMAGE: 'codefresh/cf-gc-builder:0.4.4',
+    CONTAINER_LOGGER_IMAGE: 'codefresh/cf-container-logger:1.6.1',
     GIT_CLONE_IMAGE: 'codefresh/cf-git-cloner:10.0.3',
     COMPOSE_IMAGE: 'docker/compose:1.11.2',
     KUBE_DEPLOY: 'codefresh/cf-deploy-kubernetes:latest',

package/lib/interface/cli/commands/offline-logs/base.cmd.js

@@ -16,12 +16,12 @@ const command = new Command({
       .env("RUNTIME_MONGO")
       .option("uri", {
         describe:
-          "Mongodb URI. If not provided, will be parsed from environment variables.",
+          "Mongodb URI. If not provided, will be parsed from environment variable RUNTIME_MONGO_URI.",
         type: "string",
       })
       .option("db", {
         describe:
-          "Database name. If not provided, will be parsed from environment variables.",
+          "Database name. If not provided, will be parsed from environment variable RUNTIME_MONGO_DB.",
         type: "string",
       });
   },

package/lib/interface/cli/commands/offline-logs/ensure-index.cmd.js

@@ -18,22 +18,24 @@ const command = new Command({
     ),
   handler: async (argv) => {
     const { uri, db } = argv;
-    const client = new MongoClient(uri);
+    const client = new MongoClient( uri, { useUnifiedTopology: true } );
     await client.connect();
     const database = client.db(db);
     const failedCollections = [];
+    const errors = [];
     for (const collection of utils.defaultCollections) {
       try {
         await utils.ensureIndex(database, collection);
       } catch (error) {
         console.error(`failed to ensure index of collection '${collection}', error: ${error.message}`);
         failedCollections.push(collection);
+        errors.push(error);
       }
     }
     client.close();
     if (failedCollections.length) {
       throw new Error(
-        `failed to ensure indexes of ${failedCollections.join(", ")}`
+        `failed to ensure indexes of ${failedCollections.join(', ')}, ${errors.join(', ')}`
       );
     }
   },

package/lib/interface/cli/commands/offline-logs/ensure-index.spec.js

@@ -1,5 +1,3 @@
-// const {Db, Collection} = require('mongodb');
-const { Collection } = require('yaml/types');
 const utils = require('./utils')
 
 describe("ensure-index", () => {
@@ -29,6 +27,7 @@ describe("ensure-index", () => {
       utils.getUserInput.mockReturnValue(true);
       const collection = 'whatever';
       const expectedIndexObj = { accountId: 1, jobId: 1 }
+      const expectedOptions = { background: true }
 
       //execute
       await utils.ensureIndex(mockDatabase, collection);
@@ -39,7 +38,7 @@ describe("ensure-index", () => {
       expect(mockCollection.estimatedDocumentCount).toBeCalledTimes(1);
       expect(utils.getUserInput).toBeCalledTimes(1);
       expect(mockCollection.createIndex).toBeCalledTimes(1);
-      expect(mockCollection.createIndex).toBeCalledWith(expectedIndexObj)
+      expect(mockCollection.createIndex).toBeCalledWith(expectedIndexObj, expectedOptions)
       });
     it("index does not exists and user says no on prompt", async () => {
       //setup

package/lib/interface/cli/commands/offline-logs/offload-to-collection.cmd.js

@@ -1,96 +1,188 @@
 const { MongoClient, ObjectId } = require("mongodb");
-const moment = require('moment')
-const Command = require('../../Command');
-const cmd = require('./base.cmd');
-const { objectIdFromDate, defaultCollections } = require('./utils')
-
-const offloadToCollection = async function(sourceDBObj, collection, targetDB, cutoffDate) {
-  const sourceCollectionObj = sourceDBObj.collection(collection)
-  const targetCollection = `archive-${collection}`
-  
-  const cutoffDateObj = moment(cutoffDate)
-                        .add(1, 'days')
-                        .startOf("day")
-
-  if(!cutoffDateObj.isValid()){
-    throw new Error('please enter a valid date in ISO 8601 format')
+const moment = require("moment");
+const semver = require("semver");
+const Command = require("../../Command");
+const cmd = require("./base.cmd");
+const {
+  objectIdFromDate,
+  defaultCollections,
+  findMinLog,
+  checkCursorState,
+  createRangeStr,
+  getMinDate,
+} = require("./utils");
+
+const MERGE_RELEASE_VERSION = "4.2.0";
+
+const offloadToCollection = async function (
+  sourceDBObj,
+  collection,
+  targetDB,
+  cutoffDate
+) {
+  const sourceCollectionObj = sourceDBObj.collection(collection);
+
+  const cutoffDateObj = moment(cutoffDate).add(1, "days").startOf("day");
+
+  if (!cutoffDateObj.isValid()) {
+    throw new Error("please enter a valid date in ISO 8601 format");
   }
 
-  const cutoffDateId = objectIdFromDate(cutoffDateObj.toDate())
+  const cutoffDateId = objectIdFromDate(cutoffDateObj.toDate());
 
-  var result = sourceCollectionObj.aggregate([
-      { $match: { _id: { $lte: ObjectId(cutoffDateId) } } },
-      { $merge: {
-          into: {db: targetDB, coll: targetCollection},
-          on: "_id",
-          whenMatched: "keepExisting",
-          whenNotMatched: "insert"
-      }}
-  ])
-
-  await result.toArray()
-
-  if (!result.cursorState.killed){
-    console.info(`logs from '${collection}' were archived to '${targetCollection}'`)
-    await sourceCollectionObj.deleteMany({_id: {$lte: ObjectId(cutoffDateId)}})
+  const minLog = await findMinLog(
+    sourceCollectionObj,
+    cutoffDateId,
+    collection
+  );
+
+  if (!minLog) {
+    console.info(
+      `No logs to archive in collection ${collection} from the given date.`
+    );
+    return;
   }
-  else {
-      console.error("Cursor error. Archiving operation may not be completed.")
-      console.error("The old logs were not deleted from the source collection.")
+
+  const lowerBound = getMinDate(minLog);
+  const upperBound = moment(cutoffDateObj);
+  const targetCollection = `${createRangeStr(
+    lowerBound,
+    upperBound,
+    collection
+  )}-archive`;
+
+  const mongoInfo = await sourceDBObj.admin().serverInfo();
+  const mongoServerVersion = await mongoInfo.version;
+
+  if (semver.lte(MERGE_RELEASE_VERSION, mongoServerVersion)) {
+    await archiveWithMerge(
+      sourceCollectionObj,
+      cutoffDateId,
+      targetDB,
+      targetCollection,
+      collection
+    );
+  } else {
+    await archiveWithOut(
+      sourceCollectionObj,
+      cutoffDateId,
+      targetCollection,
+      collection
+    );
   }
-}
+};
+///////////////////////////////////////////////////////////////////////////////////
+const archiveWithMerge = async function (
+  sourceCollectionObj,
+  cutoffDateId,
+  targetDB,
+  targetCollection,
+  collection
+) {
+  var result = sourceCollectionObj.aggregate([
+    { $match: { _id: { $lte: ObjectId(cutoffDateId) } } },
+    {
+      $merge: {
+        into: { db: targetDB, coll: targetCollection },
+        on: "_id",
+        whenMatched: "keepExisting",
+        whenNotMatched: "insert",
+      },
+    },
+  ]);
 
+  await result.toArray();
+
+  checkCursorState(result, collection, targetCollection);
+
+  await sourceCollectionObj.deleteMany({
+    _id: { $lte: ObjectId(cutoffDateId) },
+  });
+};
+///////////////////////////////////////////////////////////////////////////////////
+const archiveWithOut = async function (
+  sourceCollectionObj,
+  cutoffDateId,
+  targetCollection,
+  collection
+) {
+  var result = sourceCollectionObj.aggregate([
+    { $match: { _id: { $lte: ObjectId(cutoffDateId) } } },
+    { $out: targetCollection },
+  ]);
+
+  await result.toArray();
+
+  checkCursorState(result, collection, targetCollection);
+
+  await sourceCollectionObj.deleteMany({
+    _id: { $lte: ObjectId(cutoffDateId) },
+  });
+};
+///////////////////////////////////////////////////////////////////////////////////
 const command = new Command({
-    command: 'offload-to-collection',
-    parent: cmd,
-    description: 'Archiving logs from one or more source collections to target collections.',
-    webDocs: {
-        category: 'Logs',
-        title: 'Offload To Collection',
-    },
-    builder: yargs => yargs
-    .option('targetDB', {
-          alias: 'tdb',
-          describe: "Target database name, if none inserted, db will be defined as target.",
-          type: "string",
-        })
-    .option('cutoffDate', {
-      alias: "cod",
-      describe:
-        "The date in ISO format (yyyy-MM-dd) from which logs will be archived (going backwards, including logs from that day).",
-      demandOption: true,
-      type: "string",
-    })
-    .example('codefresh offline-logs offload-to-collection --uri "mongodb://192.168.99.100:27017" --db logs --c logs foo --cod "2021-07-08" '),
-    handler: async (argv) => {
-      const {
-        uri,
-        db,
-        targetDB,
-        cutoffDate,
-      } = argv
-
-      const client = new MongoClient(uri);
-      try{
-        await client.connect()
-        const failedCollections = [];
-        const sourceDBObj = client.db(db);
-        const promises = defaultCollections.map( async (collection) => {
-          try{
-            await offloadToCollection(sourceDBObj, collection, targetDB || db, cutoffDate);
-          } catch (error) {
-            failedCollections.push(collection)
-          }
-        })
-        await Promise.all(promises)
-
-        if (failedCollections.length){
-          throw new Error(`failed to offload from collections: ${failedCollections.join(', ')}`)
+  command: "offload-to-collection",
+  parent: cmd,
+  description:
+    "Archiving logs from one or more source collections to target collections.",
+  webDocs: {
+    category: "Logs",
+    title: "Offload To Collection",
+  },
+  builder: (yargs) =>
+    yargs
+      .option("targetDB", {
+        alias: "tdb",
+        describe:
+          "This option is available only for mongodb version 4.2 and up. for older versions it will be ignored. \
+          Target database name, if none inserted, db will be defined as target.",
+        type: "string",
+      })
+      .option("cutoffDate", {
+        alias: "cod",
+        describe:
+          "The date in ISO format (yyyy-MM-dd) from which logs will be archived (going backwards, including logs from that day).",
+        demandOption: true,
+        type: "string",
+      })
+      .example(
+        'codefresh offline-logs offload-to-collection --uri "mongodb://192.168.99.100:27017" --db logs --cod "2021-07-08" '
+      ),
+  handler: async (argv) => {
+    const { uri, db, targetDB, cutoffDate } = argv;
+
+    const client = new MongoClient(uri, { useUnifiedTopology: true });
+    try {
+      await client.connect();
+      const failedCollections = [];
+      const errors = [];
+      const sourceDBObj = client.db(db);
+      const promises = defaultCollections.map(async (collection) => {
+        try {
+          await offloadToCollection(
+            sourceDBObj,
+            collection,
+            targetDB || db,
+            cutoffDate
+          );
+        } catch (error) {
+          failedCollections.push(collection);
+          errors.push(error);
         }
-      } finally {
-          client.close();
+      });
+      await Promise.all(promises);
+
+      if (failedCollections.length) {
+        throw new Error(
+          `failed to offload from collections: ${failedCollections.join(
+            ", "
+          )}. ${errors.join(", ")}`
+        );
       }
-    },
-})
+    } finally {
+      client.close();
+    }
+  },
+});
 
-module.exports = command;
+module.exports = command;

package/lib/interface/cli/commands/offline-logs/offload-to-file.cmd.js

@@ -1,59 +1,66 @@
-
 const { MongoClient, ObjectId } = require("mongodb");
-const moment = require('moment')
-const Command = require('../../Command');
-const cmd = require('./base.cmd');
-const {objectIdFromDate, writeLogsToFile, checkRemnant, defaultCollections} = require('./utils');
+const moment = require("moment");
+const Command = require("../../Command");
+const cmd = require("./base.cmd");
+const {
+  objectIdFromDate,
+  writeLogsToFile,
+  checkRemnant,
+  findMinLog,
+  getMinDate,
+  defaultCollections,
+} = require("./utils");
 
-const offloadToFile = async function(database, collection, chunkDuration, cutoffDate, path) {
+const offloadToFile = async function (
+  database,
+  collection,
+  chunkDuration,
+  cutoffDate,
+  path
+) {
   const collectionObj = database.collection(collection);
 
-  if (chunkDuration <= 0){
-    throw new Error('please enter a valid chunkDuration ( > 0)')
+  if (chunkDuration <= 0) {
+    throw new Error("please enter a valid chunkDuration ( > 0)");
   }
-  let chunkSize = chunkDuration
+  let chunkSize = chunkDuration;
 
   // the cutoff date will be the start of the next day from user input (archive will include the given cutoff date)
   const cutoffDateObj = moment(cutoffDate, moment.ISO_8601, true)
-    .add(1, 'days')
+    .add(1, "days")
     .startOf("day");
-  if(!cutoffDateObj.isValid()){
-    throw new Error('please enter a valid date in ISO 8601 format')
+  if (!cutoffDateObj.isValid()) {
+    throw new Error("please enter a valid date in ISO 8601 format");
   }
-  const cutoffDateId = objectIdFromDate(cutoffDateObj.toDate())
+  const cutoffDateId = objectIdFromDate(cutoffDateObj.toDate());
+
+  const minLog = await findMinLog(collectionObj, cutoffDateId, collection);
 
-  const minLog = await collectionObj
-    .find({ _id: { $lt: ObjectId(cutoffDateId) } })
-    .sort({ _id: 1 })
-    .limit(1)
-    .toArray();
-  
-  if (minLog.length === 0) {
-      console.info(`No logs to archive in Collection ${collection} from the given date.`);
-      return;
+  if (!minLog) {
+    console.info(
+      `No logs to archive in Collection ${collection} from the given date.`
+    );
+    return;
   }
-  
-  const minLogId = ObjectId(minLog[0]._id)
-  const minDate = moment(
-    minLogId.getTimestamp()
-  ).startOf("day").toDate();
+
+  const minDate = getMinDate(minLog);
 
   for (
     let lowerBound = moment(minDate);
     lowerBound < cutoffDateObj;
-    lowerBound.add( chunkSize, 'days' )
+    lowerBound.add(chunkSize, "days")
   ) {
     //in case total days period is not devided with chunkSize, the last chunk size needs to be smaller.
-    const remnant = checkRemnant(lowerBound, cutoffDateObj)
+    const remnant = checkRemnant(lowerBound, cutoffDateObj);
 
     if (remnant < chunkSize && remnant > 0) {
       chunkSize = remnant;
     }
-    const upperBound = moment(lowerBound).add( chunkSize, 'days' );
+    const upperBound = moment(lowerBound).add(chunkSize, "days");
+
+    const lowerBoundId = objectIdFromDate(lowerBound.toDate());
+    const upperBoundId = objectIdFromDate(upperBound.toDate());
 
-    const lowerBoundId = objectIdFromDate(lowerBound.toDate())
-    const upperBoundId = objectIdFromDate(upperBound.toDate())
-      
     const logsToArchive = await collectionObj
       .find({
         _id: {
@@ -64,7 +71,7 @@ const offloadToFile = async function(database, collection, chunkDuration, cutoff
       .toArray();
 
     if (logsToArchive.length > 0) {
-      writeLogsToFile(upperBound, lowerBound, collection, logsToArchive, path)
+      writeLogsToFile(upperBound, lowerBound, collection, logsToArchive, path);
 
       await collectionObj.deleteMany({
         _id: {
@@ -74,83 +81,95 @@ const offloadToFile = async function(database, collection, chunkDuration, cutoff
       });
     }
   }
-}
+};
 
 const command = new Command({
-    command: 'offload-to-file',
-    parent: cmd,
-    description: 'Archiving logs from one or more source collections to files by chunks of days.',
-    webDocs: {
-        category: 'Logs',
-        title: 'Offload To File',
-    },
-    builder: yargs => yargs
-      .option('chunkDuration', {
+  command: "offload-to-file",
+  parent: cmd,
+  description:
+    "Archiving logs from one or more source collections to files by chunks of days.",
+  webDocs: {
+    category: "Logs",
+    title: "Offload To File",
+  },
+  builder: (yargs) =>
+    yargs
+      .option("chunkDuration", {
         alias: "chdur",
         describe:
           "Chunk size in days, each chunk will be archived into a different file.",
         default: 1,
         type: "number",
       })
-      .option('cutoffDate', {
+      .option("cutoffDate", {
         alias: "cod",
         describe:
           "The date in ISO format (yyyy-MM-dd) from which logs will be archived (going backwards, including logs from that day).",
         demandOption: true,
         type: "string",
       })
-      .option('path', {
+      .option("path", {
         describe: "Directory path to which archive files will be saved.",
         default: ".",
         type: "string",
       })
-      .option('collections', {
-        alias: 'c',
+      .option("collections", {
+        alias: "c",
         describe: "Source collections names",
         default: defaultCollections,
         array: true,
         type: "string",
         coerce(arg) {
           for (const collection of arg) {
-            if (!collection.includes('logs') && !collection.includes('metadata')) {
-              throw new Error ('invalid collection name')
+            if (
+              !collection.includes("logs") &&
+              !collection.includes("metadata")
+            ) {
+              throw new Error("invalid collection name");
             }
-            return arg
-          } 
-        }
-      })
-      .example('codefresh offline-logs offload-to-file --uri "mongodb://192.168.99.100:27017" --db logs --collections archive-logs --cod "2021-07-08" --chdur 3 --path "./" '),
-    handler: async (argv) => {
-      const {
-        uri,
-        cutoffDate,
-        chunkDuration,
-        path,
-        db,
-        collections,
-      } = argv;
-      const client = new MongoClient(uri);
-      try {
-        await client.connect();
-        const failedCollections = [];
-        const database = client.db(db);
-        const promises = collections.map( async ( collection ) => {
-          try {
-            await offloadToFile( database, collection, chunkDuration, cutoffDate, path );
-          } catch (e) {
-            console.log(e)
-            failedCollections.push(collection);
+            return arg;
           }
-        })
-        await Promise.all(promises);
-
-        if (failedCollections.length) {
-          throw new Error(`failed to offload from collections: ${failedCollections.join(', ')}`)
+        },
+      })
+      .example(
+        'codefresh offline-logs offload-to-file --uri "mongodb://192.168.99.100:27017" --db logs --collections archive-logs --cod "2021-07-08" --chdur 3 --path "./" '
+      ),
+  handler: async (argv) => {
+    const { uri, cutoffDate, chunkDuration, path, db, collections } = argv;
+    const client = new MongoClient(uri, { useUnifiedTopology: true });
+    try {
+      await client.connect();
+      const failedCollections = [];
+      const errors = [];
+      const database = client.db(db);
+      const promises = collections.map(async (collection) => {
+        try {
+          await offloadToFile(
+            database,
+            collection,
+            chunkDuration,
+            cutoffDate,
+            path
+          );
+        } catch (e) {
+          console.log(e);
+          failedCollections.push(collection);
+          errors.push(error);
         }
-      } finally {
-        client.close();
+      });
+      await Promise.all(promises);
+
+      if (failedCollections.length) {
+        throw new Error(
+          `failed to offload from collections: ${failedCollections.join(
+            ", "
+          )}. ${errors.join(", ")}`
+        );
       }
-    },
+    } finally {
+      client.close();
+    }
+  },
 });
 
 module.exports = command;

package/lib/interface/cli/commands/offline-logs/utils.js

@@ -1,5 +1,6 @@
 const readline = require("readline");
 const moment = require("moment");
+const { ObjectId } = require("mongodb")
 
 const { join } = require("path");
 const fs = require("fs");
@@ -18,17 +19,28 @@ const writeLogsToFile = function (
   logsToArchive,
   path
 ) {
-  const date = moment(upperBound).subtract(1, "days");
-  const fileDateRange = `${moment(lowerBound).format(
-    "YYYY-MM-DD"
-  )}-${date.format("YYYY-MM-DD")}`;
-  const fileName = `${fileDateRange}-${collection}.json`;
+  const fileName = `${createRangeStr(lowerBound, upperBound, collection)}.json`
   const absPath = join(path, fileName);
   const data = JSON.stringify(logsToArchive);
   fs.writeFileSync(absPath, data);
   console.info(`logs from collection '${collection}' were offloaded to '${absPath}'`)
 };
 
+const createRangeStr = function(lowerBound, upperBound, collection) {
+  const upperBoundDate = moment(upperBound).subtract(1, "days");
+  const fileDateRange = `${moment(lowerBound).format(
+    "YYYY-MM-DD"
+  )}-${upperBoundDate.format("YYYY-MM-DD")}`;
+  return `${fileDateRange}-${collection}`;
+}
+
+const getMinDate = function(minLog) {
+  const minLogId = ObjectId(minLog._id)
+  return moment(
+    minLogId.getTimestamp()
+  ).startOf("day");
+}
+
 const checkRemnant = function (lowerBound, cutoffDateObj) {
   return Math.ceil(cutoffDateObj.diff(lowerBound, "days"));
 };
@@ -61,6 +73,7 @@ const ensureIndex = async function (database, collection) {
 
   await collectionObj.createIndex(
     { accountId: 1, jobId: 1 },
+    { background: true },
   );
   console.info(
     `index '${indexName}' was created for collection '${collection}'`
@@ -95,11 +108,52 @@ const getUserInput = async function (queryStr) {
   }
 };
 
+const collectionExists = async function(dbObject, targetCollection) {
+  const collectionsObjectList = await dbObject.listCollections().toArray();
+  const collectionsList = collectionsObjectList.map((object) => {
+    return object.name;
+  })
+  return (collectionsList.indexOf(targetCollection) >= 0);
+}
+
+const findMinLog = async function(collectionObj, UpperBoundDateId, collection) {
+  const minLog = await collectionObj
+    .find({ _id: { $lt: ObjectId(UpperBoundDateId) } })
+    .sort({ _id: 1 })
+    .limit(1)
+    .toArray();
+
+  if (minLog.length === 0) {
+    return undefined;
+  }
+
+  return minLog[0];
+}
+
+const checkCursorState = function (cursor, collection, targetCollection) {
+  if (!cursor.cursorState.killed) {
+    console.info(
+      `logs from '${collection}' were archived to '${targetCollection}'`
+    );
+    return;
+  } else {
+    throw new Error(
+      "Cursor error. Archiving operation may not be completed.\
+      The old logs were not deleted from the source collection."
+    );
+  }
+}
+
 module.exports = {
   objectIdFromDate,
   writeLogsToFile,
   checkRemnant,
   ensureIndex,
   getUserInput,
+  collectionExists,
+  findMinLog,
+  checkCursorState,
+  createRangeStr,
+  getMinDate,
   defaultCollections,
 };

package/lib/interface/cli/helpers/validation.js

@@ -24,6 +24,7 @@ function _getPipelineName(filename) {
 }
 
 async function validatePipelineSpec(data) {
+    const specTemplate = _.get(data, 'spec.specTemplate');
     const steps = _.get(data, 'spec.steps');
     const stages = _.get(data, 'spec.stages');
     const yamlObj = {};
@@ -36,6 +37,9 @@ async function validatePipelineSpec(data) {
     if (stages) {
         yamlObj.stages = stages;
     }
+    if (specTemplate) {  // CR-6414 Using specTemplate - skip check spec/stages - they are not used
+        return { valid: true, message: 'Using specTemplate' };
+    }
     const validatedYaml = yaml.safeDump(yamlObj);
     const result = await sdk.pipelines.validateYaml({ yaml: validatedYaml, outputFormat: 'lint' });
     let message;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codefresh",
-  "version": "0.78.0",
+  "version": "0.78.4",
   "description": "Codefresh command line utility",
   "main": "index.js",
   "preferGlobal": true,
@@ -36,9 +36,9 @@
     "bluebird": "^3.5.1",
     "cf-errors": "^0.1.16",
     "chalk": "^4.1.0",
-    "cli-progress": "3.6.0",
+    "cli-progress": "3.10.0",
     "codefresh-sdk": "^1.9.22",
-    "colors": "^1.1.2",
+    "colors": "1.4.0",
     "columnify": "^1.5.4",
     "compare-versions": "^3.4.0",
     "copy-dir": "^0.3.0",
@@ -64,7 +64,7 @@
     "mongodb": "^3.0.1",
     "node-forge": "^0.10.0",
     "ora": "^3.0.0",
-    "prettyjson": "^1.2.1",
+    "prettyjson": "^1.2.5",
     "promise-retry": "^2.0.1",
     "recursive-readdir": "^2.2.1",
     "request": "^2.88.0",

package/yarn.lock

@@ -1010,13 +1010,12 @@ cli-cursor@^3.1.0:
   dependencies:
     restore-cursor "^3.1.0"
 
-cli-progress@3.6.0:
-  version "3.6.0"
-  resolved "https://registry.yarnpkg.com/cli-progress/-/cli-progress-3.6.0.tgz#20317e6a653c3e5636fb5f03a7d67cd48ebc215a"
-  integrity sha512-elg6jkiDedYrvwqWSae2FGvtbMo37Lo04oI9jJ5cI43Ge3jrDPWzeL3axv7MgBLYHDY/kGio/CXa49m4MWMrNw==
+cli-progress@3.10.0:
+  version "3.10.0"
+  resolved "https://registry.yarnpkg.com/cli-progress/-/cli-progress-3.10.0.tgz#63fd9d6343c598c93542fdfa3563a8b59887d78a"
+  integrity sha512-kLORQrhYCAtUPLZxqsAt2YJGOvRdt34+O6jl5cQGb7iF3dM55FQZlTR+rQyIK9JUcO9bBMwZsTlND+3dmFU2Cw==
   dependencies:
-    colors "^1.1.2"
-    string-width "^2.1.1"
+    string-width "^4.2.0"
 
 cli-spinners@^2.0.0:
   version "2.3.0"
@@ -1127,7 +1126,7 @@ color-name@~1.1.4:
   resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.4.tgz#c2a09a87acbde69543de6f63fa3995c826c536a2"
   integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==
 
-colors@^1.1.2:
+colors@1.4.0:
   version "1.4.0"
   resolved "https://registry.yarnpkg.com/colors/-/colors-1.4.0.tgz#c50491479d4c1bdaed2c9ced32cf7c7dc2360f78"
   integrity sha512-a+UqTh4kgZg/SlGvfbzDHpgRu7AAQOmmqRHJnxhRZICKFUT91brVhNNt58CMWU9PsBbv3PDCZUHbVxuDiH2mtA==
@@ -4525,12 +4524,12 @@ pretty-format@^23.6.0:
     ansi-regex "^3.0.0"
     ansi-styles "^3.2.0"
 
-prettyjson@^1.2.1:
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/prettyjson/-/prettyjson-1.2.1.tgz#fcffab41d19cab4dfae5e575e64246619b12d289"
-  integrity sha1-/P+rQdGcq0365eV15kJGYZsS0ok=
+prettyjson@^1.2.5:
+  version "1.2.5"
+  resolved "https://registry.yarnpkg.com/prettyjson/-/prettyjson-1.2.5.tgz#ef3cfffcc70505c032abc59785884b4027031835"
+  integrity sha512-rksPWtoZb2ZpT5OVgtmy0KHVM+Dca3iVwWY9ifwhcexfjebtgjg3wmrUt9PvJ59XIYBcknQeYHD8IAnVlh9lAw==
   dependencies:
-    colors "^1.1.2"
+    colors "1.4.0"
     minimist "^1.2.0"
 
 private@^0.1.8: