snyk 1.776.0 → 1.777.0

package/dist/cli/exit-codes.d.ts

@@ -0,0 +1,5 @@
+export declare const EXIT_CODES: {
+    VULNS_FOUND: number;
+    ERROR: number;
+    NO_SUPPORTED_PROJECTS_DETECTED: number;
+};

package/dist/cli/index.js

@@ -27187,6 +27187,22 @@ function copy(str) {
 exports.copy = copy;
 
 
+/***/ }),
+
+/***/ 80079:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.EXIT_CODES = void 0;
+exports.EXIT_CODES = {
+    VULNS_FOUND: 1,
+    ERROR: 2,
+    NO_SUPPORTED_PROJECTS_DETECTED: 3,
+};
+
+
 /***/ }),
 
 /***/ 33402:
@@ -27195,6 +27211,28 @@ exports.copy = copy;
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
+const unexpected_error_1 = __webpack_require__(89088);
+const exit_codes_1 = __webpack_require__(80079);
+/**
+ * By using a dynamic import, we can add error handlers before evaluating any
+ * further modules. This way, if a module has errors, it'll be caught and
+ * handled as we expect.
+ */
+unexpected_error_1.callHandlingUnexpectedErrors(async () => {
+    const { main } = await Promise.resolve().then(() => __webpack_require__(64514));
+    await main();
+}, exit_codes_1.EXIT_CODES.ERROR);
+
+
+/***/ }),
+
+/***/ 64514:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.main = void 0;
 const Debug = __webpack_require__(15158);
 const pathLib = __webpack_require__(85622);
 // import args as a first internal module
@@ -27225,12 +27263,8 @@ const json_file_output_1 = __webpack_require__(83421);
 const empty_sarif_output_error_1 = __webpack_require__(53731);
 const invalid_detection_depth_value_1 = __webpack_require__(80401);
 const utils_1 = __webpack_require__(61721);
+const exit_codes_1 = __webpack_require__(80079);
 const debug = Debug('snyk');
-const EXIT_CODES = {
-    VULNS_FOUND: 1,
-    ERROR: 2,
-    NO_SUPPORTED_PROJECTS_DETECTED: 3,
-};
 async function runCommand(args) {
     const commandResult = await args.method(...args.options._);
     const res = analytics.addDataAndSend({
@@ -27264,19 +27298,19 @@ async function handleError(args, error) {
     var _a;
     spinner_1.spinner.clearAll();
     let command = 'bad-command';
-    let exitCode = EXIT_CODES.ERROR;
+    let exitCode = exit_codes_1.EXIT_CODES.ERROR;
     const noSupportedManifestsFound = (_a = error.message) === null || _a === void 0 ? void 0 : _a.includes('Could not detect supported target files in');
     const noSupportedSastFiles = error instanceof errors_1.NoSupportedSastFiles;
     const noSupportedIaCFiles = error.code === types_1.IaCErrorCodes.NoFilesToScanError;
     const noSupportedProjectsDetected = noSupportedManifestsFound || noSupportedSastFiles || noSupportedIaCFiles;
     if (noSupportedProjectsDetected) {
-        exitCode = EXIT_CODES.NO_SUPPORTED_PROJECTS_DETECTED;
+        exitCode = exit_codes_1.EXIT_CODES.NO_SUPPORTED_PROJECTS_DETECTED;
     }
     const vulnsFound = error.code === 'VULNS';
     if (vulnsFound) {
         // this isn't a bad command, so we won't record it as such
         command = args.command;
-        exitCode = EXIT_CODES.VULNS_FOUND;
+        exitCode = exit_codes_1.EXIT_CODES.VULNS_FOUND;
     }
     if (args.options.debug && !args.options.json) {
         const output = vulnsFound ? error.message : error.stack;
@@ -27365,7 +27399,7 @@ function checkRuntime() {
         console.error(`Node.js version ${process.versions.node} is an unsupported Node.js ` +
             `runtime! Supported runtime range is '${runtime.supportedRange}'`);
         console.error('Please upgrade your Node.js runtime. The last version of Snyk CLI that supports Node.js v8 is v1.454.0.');
-        process.exit(EXIT_CODES.ERROR);
+        process.exit(exit_codes_1.EXIT_CODES.ERROR);
     }
 }
 // Throw error if user specifies package file name as part of path,
@@ -27390,7 +27424,7 @@ async function main() {
     checkRuntime();
     let res;
     let failed = false;
-    let exitCode = EXIT_CODES.ERROR;
+    let exitCode = exit_codes_1.EXIT_CODES.ERROR;
     try {
         modes_1.modeValidation(globalArgs);
         // TODO: fix this, we do transformation to options and teh type doesn't reflect it
@@ -27457,6 +27491,7 @@ async function main() {
     }
     return res;
 }
+exports.main = main;
 function validateUnsupportedOptionCombinations(options) {
     const unsupportedAllProjectsCombinations = {
         'project-name': 'project-name',
@@ -27567,11 +27602,6 @@ function validateOutputFile(options, outputType, error) {
         throw error;
     }
 }
-main().catch((e) => {
-    console.error('Something unexpected went wrong: ', e.stack);
-    console.error('Exit code: ' + EXIT_CODES.ERROR);
-    process.exit(EXIT_CODES.ERROR);
-});
 
 
 /***/ }),
@@ -30229,6 +30259,80 @@ var SupportedCliCommands;
 })(SupportedCliCommands = exports.SupportedCliCommands || (exports.SupportedCliCommands = {}));
 
 
+/***/ }),
+
+/***/ 89088:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.callHandlingUnexpectedErrors = void 0;
+/**
+ * Ensures a given function does not throw any errors, including unexpected ones
+ * outside of its chain of execution.
+ *
+ * This function can only be used once in the same process. If you have multiple
+ * callables needing this, compose them into a single callable.
+ */
+async function callHandlingUnexpectedErrors(callable, exitCode) {
+    function handleUnexpectedError(reason) {
+        console.error('Something unexpected went wrong:', reason);
+        console.error('Exit code:', exitCode);
+        process.exit(exitCode);
+    }
+    /**
+     * As the only point we'll know if a given callable has unexpected errors is
+     * when NodeJS exits, we can't handle unexpected errors for more than one
+     * callable. We'll never know which callable an error came from.
+     */
+    if (process.listenerCount('uncaughtException') > 1) {
+        handleUnexpectedError(new Error('Cannot handle unexpected errors for more than one callable.'));
+    }
+    process.on('uncaughtException', handleUnexpectedError);
+    /**
+     * Since Node 15, 'unhandledRejection' without a handler causes an
+     * 'uncaughtException'. However, we also support Node 14 (as of writing)
+     * which doesn't have that behaviour. So we still need this handler for now.
+     */
+    process.on('unhandledRejection', handleUnexpectedError);
+    try {
+        await callable();
+    }
+    catch (e) {
+        handleUnexpectedError(e);
+    }
+    /**
+     * Do NOT remove any 'uncaughtException' and 'unhandledRejection' handlers.
+     * It may seem like we should after callable has done its thing. However,
+     * there's never a point when everything's "done". There's no guarantee that
+     * a callable hasn't created a chain of execution outside of its chain which
+     * might trigger an unexpected error.
+     *
+     * For example, we want to avoid this scenario:
+     *
+     * - Add Handler L for 'uncaughtException' and 'unhandledRejection'
+     * - Call Function A
+     * - Function A calls Function B, which returns Promise P.
+     * - Function A does not await Promise P
+     * - Function A returns.
+     * - Remove Handler L. <- Don't do this! Otherwise...
+     * - Some time passes...
+     * - Promise P rejects.
+     * - NodeJS has nothing left to execute.
+     * - NodeJS gathers all unhandled rejected promises.
+     * - There are no 'unhandledRejection' handlers.
+     * - For Node 15 and above:
+     *   - NodeJS triggers 'uncaughtException'
+     *   - There are no 'uncaughtException' handlers.
+     *   - NodeJS defaults to Exit Code 1. <- We want a different exit code.
+     * - For Node 14 and below:
+     *   - NodeJS logs a warning. <- We want the same behaviour across versions.
+     */
+}
+exports.callHandlingUnexpectedErrors = callHandlingUnexpectedErrors;
+
+
 /***/ }),
 
 /***/ 28137: