@contrast/contrast 1.0.10 → 1.0.11

package/dist/scaAnalysis/common/treeUpload.js

@@ -2,11 +2,14 @@
 const commonApi = require('../../utils/commonApi');
 const { APP_VERSION } = require('../../constants/constants');
 const commonSendSnapShot = async (analysis, config) => {
-    const requestBody = {
-        appID: config.applicationId,
-        cliVersion: APP_VERSION,
-        snapshot: analysis
-    };
+    let requestBody = {};
+    config.experimental === true
+        ? (requestBody = sendToSCAServices(config, analysis))
+        : (requestBody = {
+            appID: config.applicationId,
+            cliVersion: APP_VERSION,
+            snapshot: analysis
+        });
     const client = commonApi.getHttpClient(config);
     return client
         .sendSnapshot(requestBody, config)
@@ -22,6 +25,18 @@ const commonSendSnapShot = async (analysis, config) => {
         throw err;
     });
 };
+const sendToSCAServices = (config, analysis) => {
+    return {
+        applicationId: config.applicationId,
+        dependencyTree: analysis,
+        organizationId: config.organizationId,
+        language: config.language,
+        tool: {
+            name: 'Contrast Codesec',
+            version: APP_VERSION
+        }
+    };
+};
 module.exports = {
     commonSendSnapShot
 };

package/dist/scaAnalysis/dotnet/analysis.js

@@ -31,13 +31,25 @@ const readAndParseLockFile = lockFilePath => {
     }
     return lockFile;
 };
+const checkForCorrectFiles = languageFiles => {
+    if (!languageFiles.includes('packages.lock.json')) {
+        throw new Error(i18n.__('languageAnalysisHasNoLockFile', '.NET'));
+    }
+    if (!languageFiles.some(i => i.includes('.csproj'))) {
+        throw new Error(i18n.__('languageAnalysisProjectFileError', '.NET'));
+    }
+};
 const getDotNetDeps = (filePath, languageFiles) => {
-    const projectFile = readAndParseProjectFile(filePath + `/${languageFiles[0]}`);
-    const lockFile = readAndParseLockFile(filePath + `/${languageFiles[1]}`);
+    checkForCorrectFiles(languageFiles);
+    const projectFileName = languageFiles.find(fileName => fileName.includes('.csproj'));
+    const lockFileName = languageFiles.find(fileName => fileName.includes('.json'));
+    const projectFile = readAndParseProjectFile(filePath + `/${projectFileName}`);
+    const lockFile = readAndParseLockFile(filePath + `/${lockFileName}`);
     return { projectFile, lockFile };
 };
 module.exports = {
     getDotNetDeps,
     readAndParseProjectFile,
-    readAndParseLockFile
+    readAndParseLockFile,
+    checkForCorrectFiles
 };

package/dist/scaAnalysis/go/goAnalysis.js

@@ -1,12 +1,18 @@
 "use strict";
 const { createGoTSMessage } = require('../common/formatMessage');
+const { parseDependenciesForSCAServices } = require('../common/scaParserForGoAndJava');
 const goReadDepFile = require('./goReadDepFile');
 const goParseDeps = require('./goParseDeps');
-const goAnalysis = (config, languageFiles) => {
+const goAnalysis = config => {
     try {
         const rawGoDependencies = goReadDepFile.getGoDependencies(config);
         const parsedGoDependencies = goParseDeps.parseGoDependencies(rawGoDependencies);
-        return createGoTSMessage(parsedGoDependencies);
+        if (config.experimental) {
+            return parseDependenciesForSCAServices(parsedGoDependencies);
+        }
+        else {
+            return createGoTSMessage(parsedGoDependencies);
+        }
     }
     catch (e) {
         console.log(e.message.toString());

package/dist/scaAnalysis/java/analysis.js

@@ -5,17 +5,20 @@ const i18n = require('i18n');
 const fs = require('fs');
 const MAVEN = 'maven';
 const GRADLE = 'gradle';
-const determineProjectTypeAndCwd = (files, file) => {
+const determineProjectTypeAndCwd = (files, config) => {
     const projectData = {};
+    if (files.length > 1) {
+        files = files.filter(i => config.fileName.includes(i));
+    }
     if (files[0].includes('pom.xml')) {
         projectData.projectType = MAVEN;
     }
     else if (files[0].includes('build.gradle')) {
         projectData.projectType = GRADLE;
     }
-    projectData.cwd = file
-        ? file.replace('pom.xml', '').replace('build.gradle', '')
-        : file;
+    projectData.cwd = config.file
+        ? config.file.replace('pom.xml', '').replace('build.gradle', '')
+        : config.file;
     return projectData;
 };
 const buildMaven = (config, projectData, timeout) => {
@@ -86,7 +89,7 @@ const getJavaBuildDeps = (config, files) => {
         projectType: undefined
     };
     try {
-        const projectData = determineProjectTypeAndCwd(files, config.file);
+        const projectData = determineProjectTypeAndCwd(files, config);
         if (projectData.projectType === MAVEN) {
             output.mvnDependancyTreeOutput = buildMaven(config, projectData, timeout);
         }
@@ -101,5 +104,6 @@ const getJavaBuildDeps = (config, files) => {
     }
 };
 module.exports = {
-    getJavaBuildDeps
+    getJavaBuildDeps,
+    determineProjectTypeAndCwd
 };

package/dist/scaAnalysis/java/index.js

@@ -2,12 +2,18 @@
 const analysis = require('./analysis');
 const { parseBuildDeps } = require('./javaBuildDepsParser');
 const { createJavaTSMessage } = require('../common/formatMessage');
+const { parseDependenciesForSCAServices } = require('../common/scaParserForGoAndJava');
 const javaAnalysis = (config, languageFiles) => {
     languageFiles.JAVA.forEach(file => {
         file.replace('build.gradle.kts', 'build.gradle');
     });
     const javaDeps = buildJavaTree(config, languageFiles.JAVA);
-    return createJavaTSMessage(javaDeps);
+    if (config.experimental) {
+        return parseDependenciesForSCAServices(javaDeps);
+    }
+    else {
+        return createJavaTSMessage(javaDeps);
+    }
 };
 const buildJavaTree = (config, files) => {
     const javaBuildDeps = analysis.getJavaBuildDeps(config, files);

package/dist/scaAnalysis/java/javaBuildDepsParser.js

@@ -14,13 +14,12 @@ const parseBuildDeps = (config, input) => {
 const preParser = shavedOutput => {
     let obj = [];
     for (let dep in shavedOutput) {
+        shavedOutput[dep] = shaveDependencyType(shavedOutput[dep]);
         obj.push(shavedOutput[dep]
             .replace('+-', '+---')
             .replace('[INFO]', '')
             .replace('\\-', '\\---')
             .replace(':jar:', ':')
-            .replace(':test', '')
-            .replace(':compile', '')
             .replace(' +', '+')
             .replace(' |', '|')
             .replace(' \\', '\\')
@@ -50,6 +49,21 @@ const preParser = shavedOutput => {
     }
     return depTree;
 };
+const shaveDependencyType = dep => {
+    if (dep.endsWith('\r')) {
+        dep = dep.slice(0, -1);
+    }
+    if (dep.endsWith(':test')) {
+        dep = dep.slice(0, -5);
+    }
+    if (dep.endsWith(':compile')) {
+        dep = dep.slice(0, -8);
+    }
+    if (dep.endsWith(':provided')) {
+        dep = dep.slice(0, -9);
+    }
+    return dep;
+};
 const shaveOutput = (gradleDependencyTreeOutput, projectType) => {
     let shavedOutput = gradleDependencyTreeOutput.split('\n');
     if (projectType === 'maven') {
@@ -335,5 +349,7 @@ module.exports = {
     computeRelationToLastElement,
     addIndentation,
     computeLevel,
-    computeIndentation
+    computeIndentation,
+    shaveDependencyType,
+    preParser
 };

package/dist/scaAnalysis/python/analysis.js

@@ -1,6 +1,7 @@
 "use strict";
 const multiReplace = require('string-multiple-replace');
 const fs = require('fs');
+const i18n = require('i18n');
 const readAndParseProjectFile = file => {
     const filePath = filePathForWindows(file + '/Pipfile');
     const pipFile = fs.readFileSync(filePath, 'utf8');
@@ -18,11 +19,45 @@ const readAndParseLockFile = file => {
     delete parsedPipLock['default'];
     return parsedPipLock;
 };
-const getPythonDeps = config => {
+const readLockFile = file => {
+    const filePath = filePathForWindows(file + '/Pipfile.lock');
+    const lockFile = fs.readFileSync(filePath, 'utf8');
+    let parsedPipLock = JSON.parse(lockFile);
+    return parsedPipLock['default'];
+};
+const scaPythonParser = pythonDependencies => {
+    let pythonParsedDeps = {};
+    for (let key in pythonDependencies) {
+        pythonParsedDeps[key] = {};
+        pythonParsedDeps[key].version = pythonDependencies[key].version.replace('==', '');
+        pythonParsedDeps[key].group = null;
+        pythonParsedDeps[key].name = key;
+        pythonParsedDeps[key].isProduction = true;
+        pythonParsedDeps[key].dependencies = [];
+        pythonParsedDeps[key].directDependency = true;
+    }
+    return pythonParsedDeps;
+};
+const checkForCorrectFiles = languageFiles => {
+    if (!languageFiles.includes('Pipfile.lock')) {
+        throw new Error(i18n.__('languageAnalysisHasNoLockFile', 'python'));
+    }
+    if (!languageFiles.includes('Pipfile')) {
+        throw new Error(i18n.__('languageAnalysisProjectFileError', 'python'));
+    }
+};
+const getPythonDeps = (config, languageFiles) => {
     try {
-        const parseProject = readAndParseProjectFile(config.file);
-        const parsePip = readAndParseLockFile(config.file);
-        return { pipfileLock: parsePip, pipfilDependanceies: parseProject };
+        if (config.experimental) {
+            let pythonLockFileContents = readLockFile(config.file);
+            return scaPythonParser(pythonLockFileContents);
+        }
+        else {
+            checkForCorrectFiles(languageFiles);
+            const parseProject = readAndParseProjectFile(config.file);
+            const parsePip = readAndParseLockFile(config.file);
+            return { pipfileLock: parsePip, pipfilDependanceies: parseProject };
+        }
     }
     catch (err) {
         console.log(err.message.toString());
@@ -37,6 +72,9 @@ const filePathForWindows = path => {
 };
 module.exports = {
     getPythonDeps,
+    scaPythonParser,
+    readAndParseLockFile,
     readAndParseProjectFile,
-    readAndParseLockFile
+    checkForCorrectFiles,
+    readLockFile
 };

package/dist/scaAnalysis/python/index.js

@@ -1,9 +1,14 @@
 "use strict";
 const { createPythonTSMessage } = require('../common/formatMessage');
-const { getPythonDeps } = require('./analysis');
+const { getPythonDeps, secondaryParser } = require('./analysis');
 const pythonAnalysis = (config, languageFiles) => {
     const pythonDeps = getPythonDeps(config, languageFiles.PYTHON);
-    return createPythonTSMessage(pythonDeps);
+    if (config.experimental) {
+        return pythonDeps;
+    }
+    else {
+        return createPythonTSMessage(pythonDeps);
+    }
 };
 module.exports = {
     pythonAnalysis

package/dist/scaAnalysis/ruby/analysis.js

@@ -1,5 +1,6 @@
 "use strict";
 const fs = require('fs');
+const i18n = require('i18n');
 const readAndParseGemfile = file => {
     const gemFile = fs.readFileSync(file + '/Gemfile', 'utf8');
     const rubyArray = gemFile.split('\n');
@@ -188,15 +189,23 @@ const buildSourceDependencyWithVersion = (whitespaceRegx, dependencyRegEx, line,
     }
     return dependencies;
 };
-const getRubyDeps = config => {
+const getRubyDeps = (config, languageFiles) => {
     try {
+        checkForCorrectFiles(languageFiles);
         const parsedGem = readAndParseGemfile(config.file);
         const parsedLock = readAndParseGemLockFile(config.file);
         return { gemfilesDependanceies: parsedGem, gemfileLock: parsedLock };
     }
     catch (err) {
-        console.log(err.message);
-        process.exit(1);
+        throw err;
+    }
+};
+const checkForCorrectFiles = languageFiles => {
+    if (!languageFiles.includes('Gemfile.lock')) {
+        throw new Error(i18n.__('languageAnalysisHasNoLockFile', 'ruby'));
+    }
+    if (!languageFiles.includes('Gemfile')) {
+        throw new Error(i18n.__('languageAnalysisProjectFileError', 'ruby'));
     }
 };
 const trimWhiteSpace = string => {
@@ -214,5 +223,6 @@ module.exports = {
     getVersion,
     getPatchLevel,
     formatSourceArr,
-    getSourceArray
+    getSourceArray,
+    checkForCorrectFiles
 };

package/dist/scan/formatScanOutput.js

@@ -53,12 +53,12 @@ function formatScanOutput(scanResults) {
             });
             let learnRow = [];
             let adviceRow = [];
+            const headerColour = chalk_1.default.hex(entry.colour);
             const headerRow = [
-                chalk_1.default
-                    .hex(entry.colour)
-                    .bold(`CONTRAST-${count.toString().padStart(3, '0')}`),
-                chalk_1.default.hex(entry.colour).bold('-'),
-                chalk_1.default.hex(entry.colour).bold(`[${entry.severity}] ${entry.ruleId}`) +
+                headerColour(`CONTRAST-${count.toString().padStart(3, '0')}`),
+                headerColour(`-`),
+                headerColour(`[${entry.severity}] `) +
+                    headerColour.bold(`${entry.ruleId}`) +
                     entry.message
             ];
             const codePath = entry.codePath?.replace(/^@/, '');
@@ -90,6 +90,7 @@ function formatScanOutput(scanResults) {
         });
     }
     printVulnInfo(projectOverview);
+    return projectOverview;
 }
 exports.formatScanOutput = formatScanOutput;
 function printVulnInfo(projectOverview) {

package/dist/scan/populateProjectIdAndProjectName.js

@@ -25,6 +25,11 @@ const createProjectId = async (config, client) => {
             process.exit(1);
             return;
         }
+        if (res.statusCode === 429) {
+            console.log(i18n.__('exceededFreeTier'));
+            process.exit(1);
+            return;
+        }
         if (res.statusCode === 201) {
             console.log(i18n.__('projectCreatedScan'));
             if (config.verbose) {

package/dist/scan/scan.js

@@ -45,6 +45,10 @@ const sendScan = async (config) => {
                     oraWrapper_1.default.failSpinner(startUploadSpinner, i18n_1.default.__('uploadingScanFail'));
                     console.log(i18n_1.default.__('genericServiceError', res.statusCode));
                 }
+                if (res.statusCode === 429) {
+                    console.log(i18n_1.default.__('exceededFreeTier'));
+                    process.exit(1);
+                }
                 if (res.statusCode === 403) {
                     console.log(i18n_1.default.__('permissionsError'));
                     process.exit(1);

package/dist/scan/scanConfig.js

@@ -1,13 +1,13 @@
 "use strict";
 const paramHandler = require('../utils/paramsUtil/paramHandler');
 const constants = require('../../src/constants.js');
-const parsedCLIOptions = require('../../src/utils/parsedCLIOptions');
 const path = require('path');
 const { supportedLanguagesScan } = require('../constants/constants');
 const i18n = require('i18n');
 const { scanUsageGuide } = require('./help');
-const getScanConfig = argv => {
-    let scanParams = parsedCLIOptions.getCommandLineArgsCustom(argv, constants.commandLineDefinitions.scanOptionDefinitions);
+const parsedCLIOptions = require('../utils/parsedCLIOptions');
+const getScanConfig = async (contrastConf, command, argv) => {
+    let scanParams = await parsedCLIOptions.getCommandLineArgsCustom(contrastConf, command, argv, constants.commandLineDefinitions.scanOptionDefinitions);
     if (scanParams.help) {
         printHelpMessage();
         process.exit(0);

package/dist/scan/scanResults.js

@@ -5,10 +5,14 @@ const oraFunctions = require('../utils/oraWrapper');
 const _ = require('lodash');
 const i18n = require('i18n');
 const oraWrapper = require('../utils/oraWrapper');
+const readLine = require('readline');
 const getScanId = async (config, codeArtifactId, client) => {
     return client
         .getScanId(config, codeArtifactId)
         .then(res => {
+        if (res.statusCode == 429) {
+            throw new Error(i18n.__('exceededFreeTier'));
+        }
         return res.body.id;
     })
         .catch(err => {
@@ -61,12 +65,43 @@ const returnScanResults = async (config, codeArtifactId, newProject, timeout, st
             let endTime = new Date() - startTime;
             if (requestUtils.millisToSeconds(endTime) > timeout) {
                 oraFunctions.failSpinner(startScanSpinner, 'Contrast Scan timed out at the specified ' + timeout + ' seconds.');
-                console.log('Please try again, allowing more time.');
-                process.exit(1);
+                if (!config.isCI) {
+                    const retry = await retryScanPrompt();
+                    timeout = retry.timeout;
+                }
             }
         }
     }
 };
+const retryScanPrompt = async () => {
+    const rl = readLine.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    return new Promise((resolve, reject) => {
+        requestUtils.timeOutError(30000, reject);
+        rl.question('🔁 Do you want to continue waiting on Scan? [Y/N]\n', async (input) => {
+            if (input.toLowerCase() === 'yes' || input.toLowerCase() === 'y') {
+                console.log('Continuing wait for Scan');
+                rl.close();
+                resolve({ timeout: 300 });
+            }
+            else if (input.toLowerCase() === 'no' ||
+                input.toLowerCase() === 'n') {
+                rl.close();
+                console.log('Contrast Scan Retry Cancelled: Exiting');
+                resolve(process.exit(1));
+            }
+            else {
+                rl.close();
+                console.log('Invalid Input: Exiting');
+                resolve(process.exit(1));
+            }
+        });
+    }).catch(e => {
+        throw e;
+    });
+};
 const returnScanResultsInstances = async (config, scanId) => {
     const client = commonApi.getHttpClient(config);
     let result;
@@ -89,5 +124,6 @@ module.exports = {
     getScanId: getScanId,
     returnScanResults: returnScanResults,
     pollScanResults: pollScanResults,
-    returnScanResultsInstances: returnScanResultsInstances
+    returnScanResultsInstances: returnScanResultsInstances,
+    retryScanPrompt
 };

package/dist/telemetry/telemetry.js

@@ -0,0 +1,137 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sha1Base64Value = exports.findParamValueFromArgs = exports.paramExists = exports.obfuscateParams = exports.sendTelemetryRequest = exports.sendTelemetryConfigAsObject = exports.sendTelemetryConfigAsConfObj = exports.TELEMETRY_CLI_TIME_TO_AUTH_EVENT = exports.TELEMETRY_CLI_COMMANDS_EVENT = void 0;
+const commonApi_1 = require("../utils/commonApi");
+const crypto = __importStar(require("crypto"));
+exports.TELEMETRY_CLI_COMMANDS_EVENT = 'CLI_COMMANDS';
+exports.TELEMETRY_CLI_TIME_TO_AUTH_EVENT = 'CLI_TIME_TO_AUTH';
+const sendTelemetryConfigAsConfObj = async (config, command, argv, result, language) => {
+    const hostParam = '--host';
+    const hostParamAlias = '-h';
+    const orgIdParam = '--organization-id';
+    const orgIdParamAlias = '-o';
+    const authParam = '--authorization';
+    const apiKeyParam = '--api-key';
+    let configToUse;
+    if ((0, exports.paramExists)(argv, hostParam, hostParamAlias) &&
+        (0, exports.paramExists)(argv, orgIdParam, orgIdParamAlias) &&
+        (0, exports.paramExists)(argv, authParam, null) &&
+        (0, exports.paramExists)(argv, apiKeyParam, null)) {
+        configToUse = {
+            host: (0, exports.findParamValueFromArgs)(argv, hostParam, hostParamAlias),
+            organizationId: (0, exports.findParamValueFromArgs)(argv, orgIdParam, orgIdParamAlias),
+            authorization: (0, exports.findParamValueFromArgs)(argv, authParam, null),
+            apiKey: (0, exports.findParamValueFromArgs)(argv, apiKeyParam, null)
+        };
+    }
+    else if (config &&
+        config.get('host') &&
+        config.get('organizationId') &&
+        config.get('authorization') &&
+        config.get('apiKey')) {
+        configToUse = {
+            host: config.get('host')?.slice(0, -1),
+            organizationId: config.get('organizationId'),
+            authorization: config.get('authorization'),
+            apiKey: config.get('apiKey')
+        };
+    }
+    else {
+        return;
+    }
+    return await (0, exports.sendTelemetryConfigAsObject)(configToUse, command, argv, result, language);
+};
+exports.sendTelemetryConfigAsConfObj = sendTelemetryConfigAsConfObj;
+const sendTelemetryConfigAsObject = async (config, command, argv, result, language) => {
+    const obfuscatedParams = (0, exports.obfuscateParams)(argv);
+    const requestBody = {
+        event: exports.TELEMETRY_CLI_COMMANDS_EVENT,
+        details: {
+            ip_address: '',
+            account_name: '',
+            account_host: '',
+            company_domain: '',
+            command: `contrast ${command} ${obfuscatedParams}`,
+            app_id: config && config.applicationId
+                ? (0, exports.sha1Base64Value)(config.applicationId)
+                : 'undefined',
+            project_id: config && config.projectId
+                ? (0, exports.sha1Base64Value)(config.projectId)
+                : 'undefined',
+            language: language,
+            result: result,
+            additional_info: '',
+            timestamp: new Date().toUTCString()
+        }
+    };
+    return await (0, exports.sendTelemetryRequest)(config, requestBody);
+};
+exports.sendTelemetryConfigAsObject = sendTelemetryConfigAsObject;
+const sendTelemetryRequest = async (config, requestBody) => {
+    const client = (0, commonApi_1.getHttpClient)(config);
+    return client
+        .postTelemetry(config, requestBody)
+        .then((res) => {
+        if (res.statusCode !== 200 && config.debug === true) {
+            console.log('Telemetry failed to send with status', res.statusCode);
+        }
+        return { statusCode: res.statusCode, statusMessage: res.statusMessage };
+    })
+        .catch((err) => {
+        return;
+    });
+};
+exports.sendTelemetryRequest = sendTelemetryRequest;
+const obfuscateParams = (argv) => {
+    return argv
+        .join(' ')
+        .replace(/--(authorization [A-Z0-9]+)/gi, '--authorization *****')
+        .replace(/-(o [A-Z0-9-]+)/gi, '-o *****')
+        .replace(/--(organization-id [A-Z0-9-]+)/gi, '--organization-id *****')
+        .replace(/--(api-key [A-Z0-9]+)/gi, '--api-key *****');
+};
+exports.obfuscateParams = obfuscateParams;
+const paramExists = (argv, param, paramAlias) => {
+    return argv.find((arg) => arg === param || arg === paramAlias);
+};
+exports.paramExists = paramExists;
+const findParamValueFromArgs = (argv, param, paramAlias) => {
+    let paramAsValue;
+    argv.forEach((arg, index) => {
+        if (arg === param ||
+            (arg === paramAlias &&
+                argv[index + 1] !== undefined &&
+                argv[index + 1] !== null)) {
+            paramAsValue = argv[index + 1];
+        }
+    });
+    return paramAsValue;
+};
+exports.findParamValueFromArgs = findParamValueFromArgs;
+const sha1Base64Value = (value) => {
+    return crypto.createHash('sha1').update(value).digest('base64');
+};
+exports.sha1Base64Value = sha1Base64Value;

package/dist/utils/getConfig.js

@@ -10,8 +10,8 @@ const localConfig = (name, version) => {
         configName: name
     });
     config.set('version', version);
-    if (process.env.CONTRAST_CODSEC_DISABLE_UPDATE_MESSAGE) {
-        config.set('updateMessageHidden', JSON.parse(process.env.CONTRAST_CODSEC_DISABLE_UPDATE_MESSAGE.toLowerCase()));
+    if (process.env.CONTRAST_CODSEC_CI) {
+        config.set('isCI', JSON.parse(process.env.CONTRAST_CODSEC_CI.toLowerCase()));
     }
     if (!config.has('host')) {
         config.set('host', 'https://ce.contrastsecurity.com/');

package/dist/utils/parsedCLIOptions.js

@@ -1,6 +1,7 @@
 "use strict";
 const commandLineArgs = require('command-line-args');
-const getCommandLineArgsCustom = (parameterList, optionDefinitions) => {
+const { sendTelemetryConfigAsConfObj } = require('../telemetry/telemetry');
+const getCommandLineArgsCustom = async (contrastConf, command, parameterList, optionDefinitions) => {
     try {
         return commandLineArgs(optionDefinitions, {
             argv: parameterList,
@@ -10,6 +11,7 @@ const getCommandLineArgsCustom = (parameterList, optionDefinitions) => {
         });
     }
     catch (e) {
+        await sendTelemetryConfigAsConfObj(contrastConf, command, parameterList, 'FAILURE', 'undefined');
         console.log(e.message.toString());
         process.exit(1);
     }

package/dist/utils/requestUtils.js

@@ -11,8 +11,14 @@ const millisToSeconds = millis => {
 const sleep = ms => {
     return new Promise(resolve => setTimeout(resolve, ms));
 };
+const timeOutError = (ms, reject) => {
+    return setTimeout(() => {
+        reject(new Error(`No input detected after 30s`));
+    }, ms);
+};
 module.exports = {
     sendRequest: sendRequest,
     sleep: sleep,
-    millisToSeconds: millisToSeconds
+    millisToSeconds: millisToSeconds,
+    timeOutError: timeOutError
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrast/contrast",
-  "version": "1.0.10",
+  "version": "1.0.11",
   "description": "Contrast Security's command line tool",
   "main": "dist/index.js",
   "bin": {