snyk 1.1069.0 → 1.1071.0

package/dist/cli/263.index.js

@@ -196409,7 +196409,6 @@ exports.sbtDependencyGraphPluginNameNew = 'addDependencyTreePlugin';
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.buildArgs = exports.inspect = void 0;
-const tslib_1 = __webpack_require__(70655);
 const path = __webpack_require__(85622);
 const fs = __webpack_require__(35747);
 const semver = __webpack_require__(36625);
@@ -196424,113 +196423,107 @@ const version_1 = __webpack_require__(16478);
 const tmp = __webpack_require__(15743);
 tmp.setGracefulCleanup();
 const packageFormatVersion = 'mvn:0.0.1';
-function inspect(root, targetFile, options) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        if (!options) {
-            options = { dev: false };
-        }
-        const isCoursierPresent = yield (0, plugin_search_1.isPluginInstalled)(root, targetFile, constants_1.sbtCoursierPluginName);
-        const isSbtDependencyGraphPresent = yield (0, plugin_search_1.isPluginInstalled)(root, targetFile, constants_1.sbtDependencyGraphPluginName);
-        const isNewSbtDependencyGraphPresent = yield (0, plugin_search_1.isPluginInstalled)(root, targetFile, constants_1.sbtDependencyGraphPluginNameNew);
-        debug(`isCoursierPresent: ${isCoursierPresent}, isSbtDependencyGraphPresent: ${isSbtDependencyGraphPresent},
+async function inspect(root, targetFile, options) {
+    if (!options) {
+        options = { dev: false };
+    }
+    const isCoursierPresent = await (0, plugin_search_1.isPluginInstalled)(root, targetFile, constants_1.sbtCoursierPluginName);
+    const isSbtDependencyGraphPresent = await (0, plugin_search_1.isPluginInstalled)(root, targetFile, constants_1.sbtDependencyGraphPluginName);
+    const isNewSbtDependencyGraphPresent = await (0, plugin_search_1.isPluginInstalled)(root, targetFile, constants_1.sbtDependencyGraphPluginNameNew);
+    debug(`isCoursierPresent: ${isCoursierPresent}, isSbtDependencyGraphPresent: ${isSbtDependencyGraphPresent},
   isNewSbtDependencyGraphPresent: ${isNewSbtDependencyGraphPresent}`);
-        // If coursier is present, use it because it gives different results to sbt dependencyTree
-        let result;
-        if (isCoursierPresent) {
-            try {
-                options.useCoursier = true;
-                result = yield legacyInspect(root, targetFile, options);
-                return result;
-            }
-            catch (err) {
-                debug('Coursier failed with error: ', err);
-            }
+    // If coursier is present, use it because it gives different results to sbt dependencyTree
+    let result;
+    if (isCoursierPresent) {
+        try {
+            options.useCoursier = true;
+            result = await legacyInspect(root, targetFile, options);
+            return result;
         }
-        // TODO:Legacy path creates a large output that can cause RangeError in bigger projects
-        // We would prefer to use plugin inspect by default but currently it requires sbt-dep-graph plugin
-        if (isSbtDependencyGraphPresent) {
-            try {
-                debug('Applying plugin inspect');
-                result = yield pluginInspect(root, targetFile, options);
-            }
-            catch (err) {
-                debug('pluginInspect failed with error: ', err);
-            }
-            if (result) {
-                result.package.packageFormatVersion = packageFormatVersion;
-                return result;
-            }
+        catch (err) {
+            debug('Coursier failed with error: ', err);
         }
-        options.useCoursier = false;
+    }
+    // TODO:Legacy path creates a large output that can cause RangeError in bigger projects
+    // We would prefer to use plugin inspect by default but currently it requires sbt-dep-graph plugin
+    if (isSbtDependencyGraphPresent) {
         try {
-            result = yield legacyInspect(root, targetFile, options);
-            return result;
+            debug('Applying plugin inspect');
+            result = await pluginInspect(root, targetFile, options);
         }
         catch (err) {
-            const hintMsg = buildHintMessage(options);
-            err.message = err.message + '\n' + hintMsg;
-            throw new Error(err);
+            debug('pluginInspect failed with error: ', err);
         }
-    });
+        if (result) {
+            result.package.packageFormatVersion = packageFormatVersion;
+            return result;
+        }
+    }
+    options.useCoursier = false;
+    try {
+        result = await legacyInspect(root, targetFile, options);
+        return result;
+    }
+    catch (err) {
+        const hintMsg = buildHintMessage(options);
+        err.message = err.message + '\n' + hintMsg;
+        throw new Error(err);
+    }
 }
 exports.inspect = inspect;
-function legacyInspect(root, targetFile, options) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const targetFilePath = path.dirname(path.resolve(root, targetFile));
-        if (!fs.existsSync(targetFilePath)) {
-            debug(`build.sbt not found at location: ${targetFilePath}. This may result in no dependencies`);
-        }
-        const useCoursier = options.useCoursier;
-        const sbtArgs = buildArgs(options.args, useCoursier);
-        debug(`running command: sbt ${sbtArgs.join(' ')}`);
-        const result = {
-            sbtOutput: yield subProcess.execute('sbt', sbtArgs, {
-                cwd: targetFilePath,
-            }),
-            coursier: useCoursier,
-        };
-        const packageName = path.basename(root);
-        const packageVersion = '0.0.0';
-        const depTree = parser.parse(result.sbtOutput, packageName, packageVersion, result.coursier);
-        depTree.packageFormatVersion = packageFormatVersion;
-        return {
-            plugin: {
-                name: 'bundled:sbt',
-                runtime: 'unknown',
-            },
-            package: depTree,
-        };
-    });
+async function legacyInspect(root, targetFile, options) {
+    const targetFilePath = path.dirname(path.resolve(root, targetFile));
+    if (!fs.existsSync(targetFilePath)) {
+        debug(`build.sbt not found at location: ${targetFilePath}. This may result in no dependencies`);
+    }
+    const useCoursier = options.useCoursier;
+    const sbtArgs = buildArgs(options.args, useCoursier);
+    debug(`running command: sbt ${sbtArgs.join(' ')}`);
+    const result = {
+        sbtOutput: await subProcess.execute('sbt', sbtArgs, {
+            cwd: targetFilePath,
+        }),
+        coursier: useCoursier,
+    };
+    const packageName = path.basename(root);
+    const packageVersion = '0.0.0';
+    const depTree = parser.parse(result.sbtOutput, packageName, packageVersion, result.coursier);
+    depTree.packageFormatVersion = packageFormatVersion;
+    return {
+        plugin: {
+            name: 'bundled:sbt',
+            runtime: 'unknown',
+        },
+        package: depTree,
+    };
 }
-function injectSbtScript(sbtPluginPath, targetFolderPath) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        try {
-            // We could be running from a bundled CLI generated by `pkg`.
-            // The Node filesystem in that case is not real: https://github.com/zeit/pkg#snapshot-filesystem
-            // Copying the injectable script into a temp file.
-            let projectFolderPath = path.resolve(targetFolderPath, 'project/');
-            debug(`injectSbtScript: injecting snyk sbt plugin "${sbtPluginPath}" in "${projectFolderPath}"`);
-            if (!fs.existsSync(projectFolderPath)) {
-                debug(`injectSbtScript: "${projectFolderPath}" does not exist`);
-                projectFolderPath = path.resolve(targetFolderPath, '..', 'project/');
-                debug(`injectSbtScript: will try "${projectFolderPath}"`);
-            }
-            const tmpSbtPlugin = tmp.fileSync({
-                postfix: '-SnykSbtPlugin.scala',
-                dir: projectFolderPath,
-            });
-            fs.createReadStream(sbtPluginPath).pipe(fs.createWriteStream(tmpSbtPlugin.name));
-            debug(`successfully injected plugin at "${tmpSbtPlugin.name}"`);
-            return { path: tmpSbtPlugin.name, remove: tmpSbtPlugin.removeCallback };
-        }
-        catch (error) {
-            error.message =
-                error.message +
-                    '\n\n' +
-                    'Failed to create a temporary file to host Snyk script for SBT build analysis.';
-            throw error;
-        }
-    });
+async function injectSbtScript(sbtPluginPath, targetFolderPath) {
+    try {
+        // We could be running from a bundled CLI generated by `pkg`.
+        // The Node filesystem in that case is not real: https://github.com/zeit/pkg#snapshot-filesystem
+        // Copying the injectable script into a temp file.
+        let projectFolderPath = path.resolve(targetFolderPath, 'project/');
+        debug(`injectSbtScript: injecting snyk sbt plugin "${sbtPluginPath}" in "${projectFolderPath}"`);
+        if (!fs.existsSync(projectFolderPath)) {
+            debug(`injectSbtScript: "${projectFolderPath}" does not exist`);
+            projectFolderPath = path.resolve(targetFolderPath, '..', 'project/');
+            debug(`injectSbtScript: will try "${projectFolderPath}"`);
+        }
+        const tmpSbtPlugin = tmp.fileSync({
+            postfix: '-SnykSbtPlugin.scala',
+            dir: projectFolderPath,
+        });
+        fs.createReadStream(sbtPluginPath).pipe(fs.createWriteStream(tmpSbtPlugin.name));
+        debug(`successfully injected plugin at "${tmpSbtPlugin.name}"`);
+        return { path: tmpSbtPlugin.name, remove: tmpSbtPlugin.removeCallback };
+    }
+    catch (error) {
+        error.message =
+            error.message +
+                '\n\n' +
+                'Failed to create a temporary file to host Snyk script for SBT build analysis.';
+        throw error;
+    }
 }
 function generateSbtPluginPath(sbtVersion) {
     let pluginName = 'SnykSbtPlugin-1.2x.scala';
@@ -196548,59 +196541,57 @@ function generateSbtPluginPath(sbtVersion) {
         throw new Error(`Cannot locate ${pluginName} script`);
     }
 }
-function pluginInspect(root, targetFile, options) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        let injectedScript;
-        try {
-            const targetFolderPath = path.dirname(path.resolve(root, targetFile));
-            const sbtArgs = buildArgs(options.args, false, true);
-            const sbtVersion = yield (0, version_1.getSbtVersion)(root, targetFile);
-            const sbtPluginPath = generateSbtPluginPath(sbtVersion);
-            const packageName = path.basename(root);
-            const packageVersion = '1.0.0';
-            injectedScript = yield injectSbtScript(sbtPluginPath, targetFolderPath);
-            debug('injectedScript.path: ' + injectedScript.path);
-            debug('args passed to plugin inspect: ', sbtArgs.join(' '));
-            const stdout = yield subProcess.execute('sbt', sbtArgs, {
-                cwd: targetFolderPath,
-            });
-            return {
-                plugin: {
-                    name: 'snyk:sbt',
-                    runtime: 'unknown',
-                    meta: {
-                        versionBuildInfo: {
-                            metaBuildVersion: {
-                                sbtVersion,
-                            },
+async function pluginInspect(root, targetFile, options) {
+    let injectedScript;
+    try {
+        const targetFolderPath = path.dirname(path.resolve(root, targetFile));
+        const sbtArgs = buildArgs(options.args, false, true);
+        const sbtVersion = await (0, version_1.getSbtVersion)(root, targetFile);
+        const sbtPluginPath = generateSbtPluginPath(sbtVersion);
+        const packageName = path.basename(root);
+        const packageVersion = '1.0.0';
+        injectedScript = await injectSbtScript(sbtPluginPath, targetFolderPath);
+        debug('injectedScript.path: ' + injectedScript.path);
+        debug('args passed to plugin inspect: ', sbtArgs.join(' '));
+        const stdout = await subProcess.execute('sbt', sbtArgs, {
+            cwd: targetFolderPath,
+        });
+        return {
+            plugin: {
+                name: 'snyk:sbt',
+                runtime: 'unknown',
+                meta: {
+                    versionBuildInfo: {
+                        metaBuildVersion: {
+                            sbtVersion,
                         },
                     },
                 },
-                package: parser.parseSbtPluginResults(stdout, packageName, packageVersion),
-            };
-        }
-        catch (error) {
-            debug('Failed to produce dependency tree with custom snyk plugin due to error: ' +
-                error.message);
-            return null;
-        }
-        finally {
-            // in case of subProcess.execute failing, perform cleanup here, as putting it after `getInjectScriptPath` might
-            // not be executed because of `sbt` failing
-            if (injectedScript && injectedScript.remove) {
-                try {
-                    injectedScript.remove();
-                    debug(`Removed the snyk sbt plugin at '${injectedScript.path}'`);
-                }
-                catch (error) {
-                    // NOTE(alexmu): we don't want to kill the whole run because we can still fall back to the legacy
-                    // method, but at least tell the user to clean up after the CLI :(.
-                    // tslint:disable-next-line:no-console
-                    console.warn(`Failed to remove the snyk sbt plugin file at '${injectedScript.path}'`);
-                }
+            },
+            package: parser.parseSbtPluginResults(stdout, packageName, packageVersion),
+        };
+    }
+    catch (error) {
+        debug('Failed to produce dependency tree with custom snyk plugin due to error: ' +
+            error.message);
+        return null;
+    }
+    finally {
+        // in case of subProcess.execute failing, perform cleanup here, as putting it after `getInjectScriptPath` might
+        // not be executed because of `sbt` failing
+        if (injectedScript && injectedScript.remove) {
+            try {
+                injectedScript.remove();
+                debug(`Removed the snyk sbt plugin at '${injectedScript.path}'`);
+            }
+            catch (error) {
+                // NOTE(alexmu): we don't want to kill the whole run because we can still fall back to the legacy
+                // method, but at least tell the user to clean up after the CLI :(.
+                // tslint:disable-next-line:no-console
+                console.warn(`Failed to remove the snyk sbt plugin file at '${injectedScript.path}'`);
             }
         }
-    });
+    }
 }
 function buildHintMessage(options) {
     const dgArgs = '`sbt ' + buildArgs(options.args, false).join(' ') + '`';
@@ -196729,7 +196720,6 @@ function walkInTree(toNode, fromNode) {
     delete toNode.parent;
 }
 function getPackageNameAndVersion(packageDependency) {
-    let splited;
     let version;
     let app;
     if (packageDependency.indexOf('(evicted by:') > -1) {
@@ -196738,7 +196728,7 @@ function getPackageNameAndVersion(packageDependency) {
     if (packageDependency.indexOf('->') > -1) {
         return null;
     }
-    splited = packageDependency.split(':');
+    const splited = packageDependency.split(':');
     version = splited[splited.length - 1];
     app = splited[0] + ':' + splited[1];
     app = app.split('\t').join('');
@@ -196851,8 +196841,7 @@ function parseSbtPluginResults(sbtOutput, packageName, packageVersion) {
 exports.parseSbtPluginResults = parseSbtPluginResults;
 const PRODUCTION_SCOPES = ['compile', 'runtime', 'provided'];
 function parseSbtPluginProjectResultToDepTree(projectKey, sbtProjectOutput) {
-    const pkgs = Object.keys(sbtProjectOutput.modules)
-        .filter((module) => {
+    const pkgs = Object.keys(sbtProjectOutput.modules).filter((module) => {
         return sbtProjectOutput.modules[module].configurations.some((c) => PRODUCTION_SCOPES.includes(c));
     });
     const getDependenciesFor = (name) => {
@@ -196864,7 +196853,8 @@ function parseSbtPluginProjectResultToDepTree(projectKey, sbtProjectOutput) {
         }
         const dependencies = {};
         for (const subDepName of sbtProjectOutput.dependencies[name]) {
-            if (pkgs.indexOf(subDepName) > -1) { // dependency is in production configuration
+            if (pkgs.indexOf(subDepName) > -1) {
+                // dependency is in production configuration
                 dependencies[subDepName] = getDependenciesFor(subDepName);
             }
         }
@@ -196887,44 +196877,38 @@ function parseSbtPluginProjectResultToDepTree(projectKey, sbtProjectOutput) {
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.isPluginInstalled = void 0;
-const tslib_1 = __webpack_require__(70655);
 const path = __webpack_require__(85622);
 const fs = __webpack_require__(35747);
 const os = __webpack_require__(12087);
 const semver = __webpack_require__(36625);
 const version_1 = __webpack_require__(16478);
-function isPluginInstalled(root, targetFile, plugin) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const searchGlobally = yield searchGlobalFiles(root, targetFile, plugin);
-        return searchGlobally || searchProjectFiles(root, targetFile, plugin);
-    });
+async function isPluginInstalled(root, targetFile, plugin) {
+    const searchGlobally = await searchGlobalFiles(root, targetFile, plugin);
+    return searchGlobally || searchProjectFiles(root, targetFile, plugin);
 }
 exports.isPluginInstalled = isPluginInstalled;
 // search project and project/project relative to the root
 function searchProjectFiles(root, targetFile, plugin) {
     const basePath = path.dirname(path.resolve(root, targetFile));
-    const sbtFileList = sbtFiles(path.join(basePath, 'project'))
-        .concat(sbtFiles(path.join(basePath, 'project', 'project')));
+    const sbtFileList = sbtFiles(path.join(basePath, 'project')).concat(sbtFiles(path.join(basePath, 'project', 'project')));
     const searchResults = sbtFileList.map((file) => {
         return searchWithFs(file, plugin);
     });
     return searchResults.filter(Boolean).length > 0;
 }
 // search globally installed plugins (~/.sbt)
-function searchGlobalFiles(root, targetFile, plugin) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const homedir = os.homedir();
-        const sbtVersion = yield (0, version_1.getSbtVersion)(root, targetFile);
-        // https://www.scala-sbt.org/1.x/docs/Using-Plugins.html#Global+plugins
-        const pluginsPath = semver.lt(sbtVersion, '1.0.0') ?
-            path.join(homedir, '.sbt', '0.13', 'plugins') :
-            path.join(homedir, '.sbt', '1.0', 'plugins');
-        const sbtFileList = sbtFiles(pluginsPath);
-        const searchResults = sbtFileList.map((file) => {
-            return searchWithFs(file, plugin);
-        });
-        return searchResults.filter(Boolean).length > 0;
+async function searchGlobalFiles(root, targetFile, plugin) {
+    const homedir = os.homedir();
+    const sbtVersion = await (0, version_1.getSbtVersion)(root, targetFile);
+    // https://www.scala-sbt.org/1.x/docs/Using-Plugins.html#Global+plugins
+    const pluginsPath = semver.lt(sbtVersion, '1.0.0')
+        ? path.join(homedir, '.sbt', '0.13', 'plugins')
+        : path.join(homedir, '.sbt', '1.0', 'plugins');
+    const sbtFileList = sbtFiles(pluginsPath);
+    const searchResults = sbtFileList.map((file) => {
+        return searchWithFs(file, plugin);
     });
+    return searchResults.filter(Boolean).length > 0;
 }
 // provide a list of .sbt files in the specified directory
 function sbtFiles(basePath) {
@@ -196996,7 +196980,10 @@ const execute = (command, args, options) => {
         });
         proc.stderr.on('data', (data) => {
             out.stderr = out.stderr + data;
-            data.toString().split('\n').forEach((str) => {
+            data
+                .toString()
+                .split('\n')
+                .forEach((str) => {
                 debugLogging(str);
             });
         });
@@ -197019,7 +197006,9 @@ const execute = (command, args, options) => {
 exports.execute = execute;
 function kill(id, out) {
     return () => {
-        out.stderr = out.stderr + 'Process timed out. To set longer timeout run with `PROC_TIMEOUT=value_in_ms`\n';
+        out.stderr =
+            out.stderr +
+                'Process timed out. To set longer timeout run with `PROC_TIMEOUT=value_in_ms`\n';
         return treeKill(id);
     };
 }
@@ -197030,8 +197019,6 @@ function kill(id, out) {
 /***/ 856:
 /***/ ((__unused_webpack_module, exports) => {
 
-"use strict";
-
 exports.parse = (lines) => {
     function addHiddenProperties(scope, props) {
         for (const p of Object.keys(props)) {
@@ -197057,7 +197044,7 @@ exports.parse = (lines) => {
         let count = 0;
         for (const i of Object.keys(line)) {
             const ch = line[i];
-            if ((ch === '\t')) {
+            if (ch === '\t') {
                 count += 1;
             }
             else if (/[^\s]/.test(ch)) {
@@ -197117,61 +197104,59 @@ exports.toJSON = (tree) => {
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.getSbtVersion = void 0;
-const tslib_1 = __webpack_require__(70655);
 const fs = __webpack_require__(35747);
 const path = __webpack_require__(85622);
 const subProcess = __webpack_require__(98262);
 const debugModule = __webpack_require__(15158);
 const debug = debugModule('snyk-sbt-plugin');
-function getSbtVersion(root, targetFile) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        try {
-            let buildPropsPath = path.join(root, path.dirname(targetFile), 'project/build.properties');
-            debug(`getSbtVersion: buildPropsPath=${buildPropsPath}`);
-            if (!fs.existsSync(buildPropsPath)) {
-                // NOTE(alexmu): We've seen this fail with the wrong path.
-                // If the path we derived above doesn't exist, we try to build a more sensible one.
-                // targetFile could be a path, so we need to call resolve()
-                debug(`getSbtVersion: "${buildPropsPath}" doesn't exist`);
-                const resolvedPath = path.resolve(root, targetFile);
-                const targetFilePath = path.dirname(resolvedPath);
-                buildPropsPath = path.resolve(targetFilePath, 'project/build.properties');
-            }
-            if (!fs.existsSync(buildPropsPath)) {
-                // NOTE(alexmu): Some projects don't have proper subproject structures,
-                // e.g. don't have a project/ subfolder. This breaks snyk's assumptions
-                // so we try to work around it here.
-                debug(`getSbtVersion: "${buildPropsPath}" does not exist`);
-                const resolvedPath = path.resolve(root, '..', targetFile);
-                const targetFilePath = path.dirname(resolvedPath);
-                buildPropsPath = path.resolve(targetFilePath, 'project/build.properties');
-                debug(`getSbtVersion: will try "${buildPropsPath}"`);
-            }
-            return fs
-                .readFileSync(buildPropsPath, 'utf-8')
-                .split('\n') // split into lines
-                .find((line) => !!line.match(/sbt\.version\s*=/)) // locate version line
-                .split(/=\s*/)[1]
-                .trim(); // return only the version
-        }
-        catch (err) {
-            debug('Failed to get sbt version from project/build.properties: ' + err.message);
-        }
-        try {
-            const stdout = yield subProcess.execute('sbt', ['--version'], {});
-            return stdout.split('\n')
-                .find((line) => !!line.match(/sbt script version/))
-                .split(':')[1]
-                .trim();
-        }
-        catch (err) {
-            debug('Failed to get sbt version sbt --version' + err.message);
+async function getSbtVersion(root, targetFile) {
+    try {
+        let buildPropsPath = path.join(root, path.dirname(targetFile), 'project/build.properties');
+        debug(`getSbtVersion: buildPropsPath=${buildPropsPath}`);
+        if (!fs.existsSync(buildPropsPath)) {
+            // NOTE(alexmu): We've seen this fail with the wrong path.
+            // If the path we derived above doesn't exist, we try to build a more sensible one.
+            // targetFile could be a path, so we need to call resolve()
+            debug(`getSbtVersion: "${buildPropsPath}" doesn't exist`);
+            const resolvedPath = path.resolve(root, targetFile);
+            const targetFilePath = path.dirname(resolvedPath);
+            buildPropsPath = path.resolve(targetFilePath, 'project/build.properties');
+        }
+        if (!fs.existsSync(buildPropsPath)) {
+            // NOTE(alexmu): Some projects don't have proper subproject structures,
+            // e.g. don't have a project/ subfolder. This breaks snyk's assumptions
+            // so we try to work around it here.
+            debug(`getSbtVersion: "${buildPropsPath}" does not exist`);
+            const resolvedPath = path.resolve(root, '..', targetFile);
+            const targetFilePath = path.dirname(resolvedPath);
+            buildPropsPath = path.resolve(targetFilePath, 'project/build.properties');
+            debug(`getSbtVersion: will try "${buildPropsPath}"`);
         }
-        // should never get here, but if it does
-        // assume sbt 1.0.0 for the purposes of copying the correct scala script and global plugin search
-        debug('Assuming sbt version is 1.0.0');
-        return '1.0.0';
-    });
+        return fs
+            .readFileSync(buildPropsPath, 'utf-8')
+            .split('\n') // split into lines
+            .find((line) => !!line.match(/sbt\.version\s*=/)) // locate version line
+            .split(/=\s*/)[1]
+            .trim(); // return only the version
+    }
+    catch (err) {
+        debug('Failed to get sbt version from project/build.properties: ' + err.message);
+    }
+    try {
+        const stdout = await subProcess.execute('sbt', ['--version'], {});
+        return stdout
+            .split('\n')
+            .find((line) => !!line.match(/sbt script version/))
+            .split(':')[1]
+            .trim();
+    }
+    catch (err) {
+        debug('Failed to get sbt version sbt --version' + err.message);
+    }
+    // should never get here, but if it does
+    // assume sbt 1.0.0 for the purposes of copying the correct scala script and global plugin search
+    debug('Assuming sbt version is 1.0.0');
+    return '1.0.0';
 }
 exports.getSbtVersion = getSbtVersion;
 //# sourceMappingURL=version.js.map