@contrast/contrast 1.0.7 → 1.0.10

package/dist/scaAnalysis/java/analysis.js

@@ -5,7 +5,7 @@ const i18n = require('i18n');
 const fs = require('fs');
 const MAVEN = 'maven';
 const GRADLE = 'gradle';
-const determineProjectTypeAndCwd = (files, projectPath) => {
+const determineProjectTypeAndCwd = (files, file) => {
     const projectData = {};
     if (files[0].includes('pom.xml')) {
         projectData.projectType = MAVEN;
@@ -13,9 +13,9 @@ const determineProjectTypeAndCwd = (files, projectPath) => {
     else if (files[0].includes('build.gradle')) {
         projectData.projectType = GRADLE;
     }
-    projectData.cwd = projectPath
-        ? projectPath.replace('pom.xml', '').replace('build.gradle', '')
-        : projectPath;
+    projectData.cwd = file
+        ? file.replace('pom.xml', '').replace('build.gradle', '')
+        : file;
     return projectData;
 };
 const buildMaven = (config, projectData, timeout) => {
@@ -86,7 +86,7 @@ const getJavaBuildDeps = (config, files) => {
         projectType: undefined
     };
     try {
-        const projectData = determineProjectTypeAndCwd(files, config.projectPath);
+        const projectData = determineProjectTypeAndCwd(files, config.file);
         if (projectData.projectType === MAVEN) {
             output.mvnDependancyTreeOutput = buildMaven(config, projectData, timeout);
         }

package/dist/scaAnalysis/javascript/analysis.js

@@ -0,0 +1,107 @@
+"use strict";
+const fs = require('fs');
+const yarnParser = require('@yarnpkg/lockfile');
+const yaml = require('js-yaml');
+const i18n = require('i18n');
+const { formatKey } = require('../../audit/nodeAnalysisEngine/parseYarn2LockFileContents');
+const readFile = async (config, languageFiles, nameOfFile) => {
+    const index = languageFiles.findIndex(v => v.includes(nameOfFile));
+    if (config.file) {
+        return fs.readFileSync(config.file.concat(languageFiles[index]), 'utf8');
+    }
+    else {
+        throw new Error('could not find file');
+    }
+};
+const readYarn = async (config, languageFiles, nameOfFile) => {
+    let yarn = {
+        yarnVersion: 1,
+        rawYarnLockFileContents: ''
+    };
+    try {
+        let rawYarnLockFileContents = await readFile(config, languageFiles, nameOfFile);
+        yarn.rawYarnLockFileContents = rawYarnLockFileContents;
+        if (!yarn.rawYarnLockFileContents.includes('lockfile v1') ||
+            yarn.rawYarnLockFileContents.includes('__metadata')) {
+            yarn.rawYarnLockFileContents = yaml.load(rawYarnLockFileContents);
+            yarn.yarnVersion = 2;
+        }
+        return yarn;
+    }
+    catch (err) {
+        throw new Error(i18n.__('nodeReadYarnLockFileError') + `${err.message}`);
+    }
+};
+const parseNpmLockFile = async (js) => {
+    try {
+        js.npmLockFile = JSON.parse(js.rawLockFileContents);
+        if (js.npmLockFile && js.npmLockFile.lockfileVersion > 1) {
+            const listOfTopDep = Object.keys(js.npmLockFile.dependencies);
+            Object.entries(js.npmLockFile.dependencies).forEach(([objKey, value]) => {
+                if (value.requires) {
+                    const listOfRequiresDep = Object.keys(value.requires);
+                    listOfRequiresDep.forEach(dep => {
+                        if (!listOfTopDep.includes(dep)) {
+                            addDepToLockFile(js, value['requires'], dep);
+                        }
+                    });
+                }
+                if (value.dependencies) {
+                    Object.entries(value.dependencies).forEach(([objChildKey, childValue]) => {
+                        if (childValue.requires) {
+                            const listOfRequiresDep = Object.keys(childValue.requires);
+                            listOfRequiresDep.forEach(dep => {
+                                if (!listOfTopDep.includes(dep)) {
+                                    addDepToLockFile(js, childValue['requires'], dep);
+                                }
+                            });
+                        }
+                    });
+                }
+            });
+            return js.npmLockFile;
+        }
+        else {
+            return js.npmLockFile;
+        }
+    }
+    catch (err) {
+        throw new Error(i18n.__('NodeParseNPM') + `${err.message}`);
+    }
+};
+const addDepToLockFile = (js, depObj, key) => {
+    return (js.npmLockFile.dependencies[key] = { version: depObj[key] });
+};
+const parseYarnLockFile = async (js) => {
+    try {
+        js.yarn.yarnLockFile = {};
+        if (js.yarn.yarnVersion === 1) {
+            js.yarn.yarnLockFile = yarnParser.parse(js.yarn.rawYarnLockFileContents);
+            delete js.yarn.rawYarnLockFileContents;
+            return js;
+        }
+        else {
+            js.yarn.yarnLockFile['object'] = js.yarn.rawYarnLockFileContents;
+            delete js.yarn.yarnLockFile['object'].__metadata;
+            js.yarn.yarnLockFile['type'] = 'success';
+            Object.entries(js.yarn.rawYarnLockFileContents).forEach(([key, value]) => {
+                const rawKeyNames = key.split(',');
+                const keyNames = formatKey(rawKeyNames);
+                keyNames.forEach(name => {
+                    js.yarn.yarnLockFile.object[name] = value;
+                });
+            });
+            return js;
+        }
+    }
+    catch (err) {
+        throw new Error(i18n.__('NodeParseYarn', js.yarn.yarnVersion) + `${err.message}`);
+    }
+};
+module.exports = {
+    readYarn,
+    parseYarnLockFile,
+    parseNpmLockFile,
+    readFile,
+    formatKey
+};

package/dist/scaAnalysis/javascript/index.js

@@ -0,0 +1,53 @@
+"use strict";
+const analysis = require('./analysis');
+const i18n = require('i18n');
+const formatMessage = require('../common/formatMessage');
+const jsAnalysis = async (config, languageFiles) => {
+    checkForCorrectFiles(languageFiles);
+    if (!config.file.endsWith('/')) {
+        config.file = config.file.concat('/');
+    }
+    return buildNodeTree(config, languageFiles.JAVASCRIPT);
+};
+const buildNodeTree = async (config, files) => {
+    let analysis = await readFiles(config, files);
+    const rawNode = await parseFiles(config, files, analysis);
+    return formatMessage.createJavaScriptTSMessage(rawNode);
+};
+const readFiles = async (config, files) => {
+    let js = {};
+    js.packageJSON = JSON.parse(await analysis.readFile(config, files, 'package.json'));
+    if (files.includes('package-lock.json')) {
+        js.rawLockFileContents = await analysis.readFile(config, files, 'package-lock.json');
+    }
+    if (files.includes('yarn.lock')) {
+        js.yarn = {};
+        js.yarn = await analysis.readYarn(config, files, 'yarn.lock');
+    }
+    return js;
+};
+const parseFiles = async (config, files, js) => {
+    if (files.includes('package-lock.json')) {
+        js.npmLockFile = await analysis.parseNpmLockFile(js);
+    }
+    if (files.includes('yarn.lock')) {
+        js = await analysis.parseYarnLockFile(js);
+    }
+    return js;
+};
+const checkForCorrectFiles = languageFiles => {
+    if (languageFiles.JAVASCRIPT.includes('package-lock.json') &&
+        languageFiles.JAVASCRIPT.includes('yarn.lock')) {
+        throw new Error(i18n.__('languageAnalysisHasMultipleLockFiles', 'javascript'));
+    }
+    if (!languageFiles.JAVASCRIPT.includes('package-lock.json') &&
+        !languageFiles.JAVASCRIPT.includes('yarn.lock')) {
+        throw new Error(i18n.__('languageAnalysisHasNoLockFile', 'javascript'));
+    }
+    if (!languageFiles.JAVASCRIPT.includes('package.json')) {
+        throw new Error(i18n.__('languageAnalysisHasNoPackageJsonFile'));
+    }
+};
+module.exports = {
+    jsAnalysis
+};

package/dist/scaAnalysis/php/analysis.js

@@ -0,0 +1,70 @@
+"use strict";
+const fs = require('fs');
+const i18n = require('i18n');
+const _ = require('lodash');
+const readFile = (config, nameOfFile) => {
+    if (config.file) {
+        try {
+            return fs.readFileSync(config.file + '/' + nameOfFile);
+        }
+        catch (error) {
+            console.log('Unable to find file');
+            console.log(error);
+        }
+    }
+};
+const parseProjectFiles = php => {
+    try {
+        php.composerJSON.dependencies = php.composerJSON.require;
+        php.composerJSON.devDependencies = php.composerJSON['require-dev'];
+        php.lockFile = php.rawLockFileContents;
+        let packages = _.keyBy(php.lockFile.packages, 'name');
+        let packagesDev = _.keyBy(php.lockFile['packages-dev'], 'name');
+        php.lockFile.dependencies = _.merge(packages, packagesDev);
+        const listOfTopDep = Object.keys(php.lockFile.dependencies);
+        Object.entries(php.lockFile.dependencies).forEach(([key, value]) => {
+            if (value.require) {
+                const listOfRequiresDep = Object.keys(value.require);
+                listOfRequiresDep.forEach(dep => {
+                    if (!listOfTopDep.includes(dep)) {
+                        addChildDepToLockFileAsOwnObj(php, value['require'], dep);
+                    }
+                });
+            }
+            if (value['require-dev']) {
+                const listOfRequiresDep = Object.keys(value['require-dev']);
+                listOfRequiresDep.forEach(dep => {
+                    if (!listOfTopDep.includes(dep)) {
+                        addChildDepToLockFileAsOwnObj(php, value['require-dev'], dep);
+                    }
+                });
+            }
+        });
+        formatParentDepToLockFile(php);
+        delete php.rawLockFileContents;
+        return php;
+    }
+    catch (err) {
+        return console.log(i18n.__('phpParseComposerLock', php) + `${err.message}`);
+    }
+};
+function addChildDepToLockFileAsOwnObj(php, depObj, key) {
+    php.lockFile.dependencies[key] = { version: depObj[key] };
+}
+function formatParentDepToLockFile(php) {
+    for (const [key, value] of Object.entries(php.lockFile.dependencies)) {
+        let requires = {};
+        for (const [childKey, childValue] of Object.entries(value)) {
+            if (childKey === 'require' || childKey === 'require-dev') {
+                requires = _.merge(requires, childValue);
+                php.lockFile.dependencies[key].requires = requires;
+                delete php.lockFile.dependencies[key].require;
+                delete php.lockFile.dependencies[key]['require-dev'];
+            }
+        }
+    }
+}
+module.exports = {
+    parseProjectFiles,
+    readFile
+};

package/dist/scaAnalysis/php/index.js

@@ -0,0 +1,17 @@
+"use strict";
+const { readFile, parseProjectFiles } = require('./analysis');
+const { createPhpTSMessage } = require('../common/formatMessage');
+const phpAnalysis = (config, files) => {
+    let analysis = readFiles(config, files.PHP);
+    const phpDep = parseProjectFiles(analysis);
+    return createPhpTSMessage(phpDep);
+};
+const readFiles = (config, files) => {
+    let php = {};
+    php.composerJSON = JSON.parse(readFile(config, 'composer.json'));
+    php.rawLockFileContents = JSON.parse(readFile(config, 'composer.lock'));
+    return php;
+};
+module.exports = {
+    phpAnalysis
+};

package/dist/scaAnalysis/python/analysis.js

@@ -1,8 +1,8 @@
 "use strict";
 const multiReplace = require('string-multiple-replace');
 const fs = require('fs');
-const readAndParseProjectFile = projectPath => {
-    const filePath = filePathForWindows(projectPath + '/Pipfile');
+const readAndParseProjectFile = file => {
+    const filePath = filePathForWindows(file + '/Pipfile');
     const pipFile = fs.readFileSync(filePath, 'utf8');
     const matcherObj = { '"': '' };
     const sequencer = ['"'];
@@ -10,18 +10,19 @@ const readAndParseProjectFile = projectPath => {
     const pythonArray = parsedPipfile.split('\n');
     return pythonArray.filter(element => element !== '' && !element.includes('#'));
 };
-const readAndParseLockFile = projectPath => {
-    const filePath = filePathForWindows(projectPath + '/Pipfile.lock');
+const readAndParseLockFile = file => {
+    const filePath = filePathForWindows(file + '/Pipfile.lock');
     const lockFile = fs.readFileSync(filePath, 'utf8');
     let parsedPipLock = JSON.parse(lockFile);
     parsedPipLock['defaults'] = parsedPipLock['default'];
+    delete parsedPipLock['default'];
     return parsedPipLock;
 };
 const getPythonDeps = config => {
     try {
-        const parseProject = readAndParseProjectFile(config.projectPath);
-        const parsePip = readAndParseLockFile(config.projectPath);
-        return { pipfileLock: parseProject, pipfilDependanceies: parsePip };
+        const parseProject = readAndParseProjectFile(config.file);
+        const parsePip = readAndParseLockFile(config.file);
+        return { pipfileLock: parsePip, pipfilDependanceies: parseProject };
     }
     catch (err) {
         console.log(err.message.toString());

package/dist/scaAnalysis/ruby/analysis.js

@@ -1,8 +1,7 @@
 "use strict";
 const fs = require('fs');
-const readAndParseGemfile = projectPath => {
-    const fileName = filePathForWindows(projectPath + '/Gemfile');
-    const gemFile = fs.readFileSync(fileName, 'utf8');
+const readAndParseGemfile = file => {
+    const gemFile = fs.readFileSync(file + '/Gemfile', 'utf8');
     const rubyArray = gemFile.split('\n');
     let filteredRubyDep = rubyArray.filter(element => {
         return (!element.includes('#') &&
@@ -14,9 +13,8 @@ const readAndParseGemfile = projectPath => {
     }
     return filteredRubyDep;
 };
-const readAndParseGemLockFile = projectPath => {
-    const fileName = filePathForWindows(projectPath + '/Gemfile.lock');
-    const lockFile = fs.readFileSync(fileName, 'utf8');
+const readAndParseGemLockFile = file => {
+    const lockFile = fs.readFileSync(file + '/Gemfile.lock', 'utf8');
     const dependencyRegEx = /^\s*([A-Za-z0-9.!@#$%\-^&*_+]*)\s*(\((.*?)\))/;
     const lines = lockFile.split('\n');
     return {
@@ -26,7 +24,7 @@ const readAndParseGemLockFile = projectPath => {
     };
 };
 const nonDependencyKeys = (line, sourceObject) => {
-    const GEMFILE_KEY_VALUE = /^\s*([^:(]*)\s*\s*(.*)/;
+    const GEMFILE_KEY_VALUE = /^\s*([^:(]*)\s*\:*\s*(.*)/;
     let parts = GEMFILE_KEY_VALUE.exec(line);
     let key = parts[1].trim();
     let value = parts[2] || '';
@@ -164,7 +162,7 @@ const getSourceArray = (lines, dependencyRegEx) => {
                 }
                 if ((currentWS === 4 && nexlineWS === 4) ||
                     (currentWS === 6 && nexlineWS === 4) ||
-                    nexlineWS === '') {
+                    nexlineWS == '') {
                     let newObj = {};
                     newObj = JSON.parse(JSON.stringify(sourceObject));
                     sources.push(newObj);
@@ -192,8 +190,8 @@ const buildSourceDependencyWithVersion = (whitespaceRegx, dependencyRegEx, line,
 };
 const getRubyDeps = config => {
     try {
-        const parsedGem = readAndParseGemfile(config.projectPath);
-        const parsedLock = readAndParseGemLockFile(config.projectPath);
+        const parsedGem = readAndParseGemfile(config.file);
+        const parsedLock = readAndParseGemLockFile(config.file);
         return { gemfilesDependanceies: parsedGem, gemfileLock: parsedLock };
     }
     catch (err) {
@@ -204,12 +202,6 @@ const getRubyDeps = config => {
 const trimWhiteSpace = string => {
     return string.replace(/\s+/g, '');
 };
-const filePathForWindows = path => {
-    if (process.platform === 'win32') {
-        path = path.replace(/\//g, '\\');
-    }
-    return path;
-};
 module.exports = {
     getRubyDeps,
     readAndParseGemfile,

package/dist/scaAnalysis/ruby/index.js

@@ -1,8 +1,8 @@
 "use strict";
-const { getRubyDeps } = require('./analysis');
+const analysis = require('./analysis');
 const { createRubyTSMessage } = require('../common/formatMessage');
 const rubyAnalysis = (config, languageFiles) => {
-    const rubyDeps = getRubyDeps(config, languageFiles.RUBY);
+    const rubyDeps = analysis.getRubyDeps(config, languageFiles.RUBY);
     return createRubyTSMessage(rubyDeps);
 };
 module.exports = {

package/dist/scan/autoDetection.js

@@ -1,8 +1,8 @@
 "use strict";
 const i18n = require('i18n');
 const fileFinder = require('./fileUtils');
-const languageResolver = require('../audit/languageAnalysisEngine/reduceIdentifiedLanguages');
 const rootFile = require('../audit/languageAnalysisEngine/getProjectRootFilenames');
+const path = require('path');
 const autoDetectFileAndLanguage = async (configToUse) => {
     const entries = await fileFinder.findFile();
     if (entries.length === 1) {
@@ -24,30 +24,20 @@ const autoDetectFileAndLanguage = async (configToUse) => {
         errorOnFileDetection(entries);
     }
 };
-const autoDetectAuditFilesAndLanguages = async () => {
+const autoDetectAuditFilesAndLanguages = async (filePath) => {
     let languagesFound = [];
-    console.log(i18n.__('searchingAuditFileDirectory', process.cwd()));
-    await fileFinder.findFilesJava(languagesFound);
-    await fileFinder.findFilesJavascript(languagesFound);
-    await fileFinder.findFilesPython(languagesFound);
-    await fileFinder.findFilesGo(languagesFound);
-    await fileFinder.findFilesPhp(languagesFound);
-    await fileFinder.findFilesRuby(languagesFound);
-    if (languagesFound.length === 1) {
+    console.log(i18n.__('searchingAuditFileDirectory', filePath));
+    await fileFinder.findFilesJava(languagesFound, filePath);
+    await fileFinder.findFilesJavascript(languagesFound, filePath);
+    await fileFinder.findFilesPython(languagesFound, filePath);
+    await fileFinder.findFilesGo(languagesFound, filePath);
+    await fileFinder.findFilesPhp(languagesFound, filePath);
+    await fileFinder.findFilesRuby(languagesFound, filePath);
+    await fileFinder.findFilesDotNet(languagesFound, filePath);
+    if (languagesFound) {
         return languagesFound;
     }
-    else {
-        console.log('found multiple languages, please specify one using --file to run SCA analysis');
-    }
-};
-const manualDetectAuditFilesAndLanguages = projectPath => {
-    let projectRootFilenames = rootFile.getProjectRootFilenames(projectPath);
-    let identifiedLanguages = languageResolver.deduceLanguageScaAnalysis(projectRootFilenames);
-    if (Object.keys(identifiedLanguages).length === 0) {
-        console.log(i18n.__('languageAnalysisNoLanguage', projectPath));
-        return [];
-    }
-    return [identifiedLanguages];
+    return [];
 };
 const hasWhiteSpace = s => {
     const filename = s.split('/').pop();
@@ -88,6 +78,5 @@ module.exports = {
     autoDetectFileAndLanguage,
     errorOnFileDetection,
     autoDetectAuditFilesAndLanguages,
-    errorOnAuditFileDetection,
-    manualDetectAuditFilesAndLanguages
+    errorOnAuditFileDetection
 };

package/dist/scan/fileUtils.js

@@ -10,72 +10,90 @@ const findFile = async () => {
         onlyFiles: true
     });
 };
-const findFilesJava = async (languagesFound) => {
+const findFilesJava = async (languagesFound, filePath) => {
     const result = await fg(['**/pom.xml', '**/build.gradle', '**/build.gradle.kts'], {
         dot: false,
         deep: 1,
-        onlyFiles: true
+        onlyFiles: true,
+        cwd: filePath ? filePath : process.cwd()
     });
     if (result.length > 0) {
         return languagesFound.push({ JAVA: result });
     }
     return languagesFound;
 };
-const findFilesJavascript = async (languagesFound) => {
-    const result = await fg(['**/package.json', '**/yarn.lock', '**/package.lock.json'], {
+const findFilesJavascript = async (languagesFound, filePath) => {
+    const result = await fg(['**/package.json', '**/yarn.lock', '**/package-lock.json'], {
         dot: false,
         deep: 1,
-        onlyFiles: true
+        onlyFiles: true,
+        cwd: filePath ? filePath : process.cwd()
     });
     if (result.length > 0) {
         return languagesFound.push({ JAVASCRIPT: result });
     }
     return languagesFound;
 };
-const findFilesPython = async (languagesFound) => {
+const findFilesPython = async (languagesFound, filePath) => {
     const result = await fg(['**/Pipfile.lock', '**/Pipfile'], {
         dot: false,
         deep: 3,
-        onlyFiles: true
+        onlyFiles: true,
+        cwd: filePath ? filePath : process.cwd()
     });
     if (result.length > 0) {
         return languagesFound.push({ PYTHON: result });
     }
     return languagesFound;
 };
-const findFilesGo = async (languagesFound) => {
+const findFilesGo = async (languagesFound, filePath) => {
     const result = await fg(['**/go.mod'], {
         dot: false,
         deep: 3,
-        onlyFiles: true
+        onlyFiles: true,
+        cwd: filePath ? filePath : process.cwd()
     });
     if (result.length > 0) {
         return languagesFound.push({ GO: result });
     }
     return languagesFound;
 };
-const findFilesRuby = async (languagesFound) => {
+const findFilesRuby = async (languagesFound, filePath) => {
     const result = await fg(['**/Gemfile', '**/Gemfile.lock'], {
         dot: false,
         deep: 3,
-        onlyFiles: true
+        onlyFiles: true,
+        cwd: filePath ? filePath : process.cwd()
     });
     if (result.length > 0) {
         return languagesFound.push({ RUBY: result });
     }
     return languagesFound;
 };
-const findFilesPhp = async (languagesFound) => {
+const findFilesPhp = async (languagesFound, filePath) => {
     const result = await fg(['**/composer.json', '**/composer.lock'], {
         dot: false,
         deep: 3,
-        onlyFiles: true
+        onlyFiles: true,
+        cwd: filePath ? filePath : process.cwd()
     });
     if (result.length > 0) {
         return languagesFound.push({ PHP: result });
     }
     return languagesFound;
 };
+const findFilesDotNet = async (languagesFound, filePath) => {
+    const result = await fg(['**/*.csproj', '**/packages.lock.json'], {
+        dot: false,
+        deep: 3,
+        onlyFiles: true,
+        cwd: filePath ? filePath : process.cwd()
+    });
+    if (result.length > 0) {
+        return languagesFound.push({ DOTNET: result });
+    }
+    return languagesFound;
+};
 const checkFilePermissions = file => {
     let readableFile = false;
     try {
@@ -92,7 +110,18 @@ const fileExists = path => {
 };
 const fileIsEmpty = path => {
     if (fileExists(path) && checkFilePermissions(path)) {
-        return fs.readFileSync(path).length === 0;
+        try {
+            return fs.readFileSync(path).length === 0;
+        }
+        catch (e) {
+            if (e.message.toString().includes('illegal operation on a directory, read')) {
+                console.log('file provided cannot be a directory');
+            }
+            else {
+                console.log(e.message.toString());
+            }
+            process.exit(0);
+        }
     }
     return false;
 };
@@ -106,5 +135,6 @@ module.exports = {
     findFilesGo,
     findFilesPhp,
     findFilesRuby,
+    findFilesDotNet,
     fileIsEmpty
 };

package/dist/scan/formatScanOutput.js

@@ -25,8 +25,9 @@ function formatScanOutput(scanResults) {
         console.log(chalk_1.default.bold(message));
         console.log();
         let defaultView = getDefaultView(scanResultsInstances.content);
-        let count = defaultView.length;
+        let count = 0;
         defaultView.forEach(entry => {
+            count++;
             let table = new cli_table3_1.default({
                 chars: {
                     top: '',
@@ -84,7 +85,6 @@ function formatScanOutput(scanResults) {
                 ];
                 table.push(learnRow);
             }
-            count--;
             console.log(table.toString());
             console.log();
         });
@@ -149,7 +149,7 @@ function getDefaultView(content) {
         groupTypeResults.push(groupResultsObj);
         assignBySeverity(resultEntry, groupResultsObj);
     });
-    return (0, lodash_1.sortBy)(groupTypeResults, ['priority']).reverse();
+    return (0, lodash_1.sortBy)(groupTypeResults, ['priority']);
 }
 exports.getDefaultView = getDefaultView;
 function editVulName(message) {

package/dist/scan/scanConfig.js

@@ -3,7 +3,7 @@ const paramHandler = require('../utils/paramsUtil/paramHandler');
 const constants = require('../../src/constants.js');
 const parsedCLIOptions = require('../../src/utils/parsedCLIOptions');
 const path = require('path');
-const { supportedLanguages } = require('../audit/languageAnalysisEngine/constants');
+const { supportedLanguagesScan } = require('../constants/constants');
 const i18n = require('i18n');
 const { scanUsageGuide } = require('./help');
 const getScanConfig = argv => {
@@ -15,7 +15,7 @@ const getScanConfig = argv => {
     const paramsAuth = paramHandler.getAuth(scanParams);
     if (scanParams.language) {
         scanParams.language = scanParams.language.toUpperCase();
-        if (!Object.values(supportedLanguages).includes(scanParams.language)) {
+        if (!Object.values(supportedLanguagesScan).includes(scanParams.language)) {
             console.log(`Did not recognise --language ${scanParams.language}`);
             console.log(i18n.__('constantsHowToRunDev3'));
             process.exit(1);

package/dist/utils/commonApi.js

@@ -18,7 +18,7 @@ const handleResponseErrors = (res, api) => {
         maxAppError();
     }
     else {
-        genericError();
+        genericError(res);
     }
 };
 const getProtocol = host => {

package/dist/utils/filterProjectPath.js

@@ -1,5 +1,6 @@
 "use strict";
 const path = require('path');
+const child_process = require('child_process');
 function resolveFilePath(filepath) {
     if (filepath[0] === '~') {
         return path.join(process.env.HOME, filepath.slice(1));
@@ -7,11 +8,15 @@ function resolveFilePath(filepath) {
     return filepath;
 }
 const returnProjectPath = () => {
-    if (process.env.PWD !== (undefined || null || 'undefined')) {
+    if (process.platform == 'win32') {
+        let winPath = child_process.execSync('cd').toString();
+        return winPath.replace(/\//g, '\\').trim();
+    }
+    else if (process.env.PWD !== (undefined || null || 'undefined')) {
         return process.env.PWD;
     }
     else {
-        return process.argv[process.argv.indexOf('--project_path') + 1];
+        return process.argv[process.argv.indexOf('--file') + 1];
     }
 };
 module.exports = {