@sasjs/cli 6.8.1 → 6.8.3

package/build/commands/flow/execute.d.ts

@@ -1,3 +1,41 @@
 import { AuthConfig, Target } from '@sasjs/utils';
 import SASjs from '@sasjs/adapter/node';
+import { FlowWave } from '../../types';
+/**
+ * A flow that finished without every job succeeding.
+ *
+ * It carries the jobs that did not, so the command can say which ones rather
+ * than reporting a JavaScript fault two frames later - which is what happened
+ * when `execute()` resolved `false` instead and the command called `.replace`
+ * on it.
+ *
+ * The marker flag rather than `instanceof`: this package compiles to es5, where
+ * a subclass of a built-in loses its prototype chain and `instanceof` answers
+ * false in the built artefact.
+ */
+export declare class FlowExecutionError extends Error {
+    readonly flowFailure = true;
+    readonly csvFilePath?: string;
+    /**
+     * @param message what did not succeed.
+     * @param csvFilePath the flow results file, which records every job and its
+     *   outcome. It is the diagnostic for a failed run, so it belongs in the
+     *   message: without it the failure path says less than the success path,
+     *   which prints the same path.
+     */
+    constructor(message: string, csvFilePath?: string);
+}
+export declare const isFlowFailure: (error: unknown) => error is FlowExecutionError;
+/**
+ * Names the jobs that did not succeed, so the message a pipeline sees is about
+ * the flow rather than about the code that reported it.
+ *
+ * A job with no status never ran - its flow was failed by a predecessor - and is
+ * left out. The test is against `undefined` rather than truthiness: a status
+ * constant added later that happens to be falsy would otherwise be dropped from
+ * the message, and the message is the whole diagnosis.
+ */
+export declare const describeFailedJobs: (flows: {
+    [key: string]: FlowWave;
+}) => string;
 export declare function execute(target: Target, sasjs: SASjs, authConfig: AuthConfig, source: string, logFolder?: string, csvFile?: string, streamLog?: boolean): Promise<unknown>;

package/build/commands/flow/execute.js

@@ -1,4 +1,19 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -50,10 +65,71 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeFailedJobs = exports.isFlowFailure = exports.FlowExecutionError = void 0;
 exports.execute = execute;
 var displayResult_1 = require("../../utils/displayResult");
 var examples_1 = __importDefault(require("./internal/examples"));
 var internal_1 = require("./internal");
+var flow_1 = require("../../types/flow");
+/**
+ * A flow that finished without every job succeeding.
+ *
+ * It carries the jobs that did not, so the command can say which ones rather
+ * than reporting a JavaScript fault two frames later - which is what happened
+ * when `execute()` resolved `false` instead and the command called `.replace`
+ * on it.
+ *
+ * The marker flag rather than `instanceof`: this package compiles to es5, where
+ * a subclass of a built-in loses its prototype chain and `instanceof` answers
+ * false in the built artefact.
+ */
+var FlowExecutionError = /** @class */ (function (_super) {
+    __extends(FlowExecutionError, _super);
+    /**
+     * @param message what did not succeed.
+     * @param csvFilePath the flow results file, which records every job and its
+     *   outcome. It is the diagnostic for a failed run, so it belongs in the
+     *   message: without it the failure path says less than the success path,
+     *   which prints the same path.
+     */
+    function FlowExecutionError(message, csvFilePath) {
+        var _this = _super.call(this, csvFilePath
+            ? "".concat(message, " The flow results were written to ").concat(csvFilePath, ".")
+            : message) || this;
+        _this.flowFailure = true;
+        _this.name = 'FlowExecutionError';
+        _this.csvFilePath = csvFilePath;
+        return _this;
+    }
+    return FlowExecutionError;
+}(Error));
+exports.FlowExecutionError = FlowExecutionError;
+var isFlowFailure = function (error) {
+    return (error === null || error === void 0 ? void 0 : error.flowFailure) === true;
+};
+exports.isFlowFailure = isFlowFailure;
+/**
+ * Names the jobs that did not succeed, so the message a pipeline sees is about
+ * the flow rather than about the code that reported it.
+ *
+ * A job with no status never ran - its flow was failed by a predecessor - and is
+ * left out. The test is against `undefined` rather than truthiness: a status
+ * constant added later that happens to be falsy would otherwise be dropped from
+ * the message, and the message is the whole diagnosis.
+ */
+var describeFailedJobs = function (flows) {
+    var failed = Object.values(flows).flatMap(function (flow) {
+        return flow.jobs
+            .filter(function (job) {
+            return job.status !== undefined && job.status !== flow_1.FlowWaveJobStatus.Success;
+        })
+            .map(function (job) { return "".concat(job.location, " (").concat(job.status, ")"); });
+    });
+    return failed.length
+        ? "The flow did not complete with all jobs successful: ".concat(failed.join(', '), ".")
+        : 'The flow did not complete with all jobs successful.';
+};
+exports.describeFailedJobs = describeFailedJobs;
 function execute(target_1, sasjs_1, authConfig_1, source_1, logFolder_1, csvFile_1) {
     return __awaiter(this, arguments, void 0, function (target, sasjs, authConfig, source, logFolder, csvFile, streamLog) {
         var _this = this;
@@ -146,10 +222,13 @@ function execute(target_1, sasjs_1, authConfig_1, source_1, logFolder_1, csvFile
                                                     reject(flowStatus.message);
                                                 _b = (0, internal_1.allFlowsCompleted)(flows), completed = _b.completed, completedWithAllSuccess = _b.completedWithAllSuccess;
                                                 if (completed) {
+                                                    // a flow that did not succeed is a failure of the flow, not of the CLI:
+                                                    // reject with what did not run, so the command can report it and exit
+                                                    // with a code that means "the flow failed"
                                                     if (completedWithAllSuccess)
                                                         resolve(csvFileRealPath);
                                                     else
-                                                        resolve(false);
+                                                        reject(new FlowExecutionError((0, exports.describeFailedJobs)(flows), csvFileRealPath));
                                                 }
                                                 return [2 /*return*/];
                                         }

package/build/commands/flow/flowCommand.d.ts

@@ -4,6 +4,6 @@ import { ReturnCode } from '../../types/command';
 import { TargetCommand } from '../../types/command/targetCommand';
 export declare class FlowCommand extends TargetCommand {
     constructor(args: string[]);
-    execute(): Promise<ReturnCode>;
-    executeFlow(target: Target, sasjs: SASjs, authConfig: AuthConfig): Promise<ReturnCode>;
+    execute(): Promise<ReturnCode.Success | ReturnCode.InvalidCommand | ReturnCode.InternalError | ReturnCode.LogCheckError | ReturnCode.FlowError>;
+    executeFlow(target: Target, sasjs: SASjs, authConfig: AuthConfig): Promise<ReturnCode.Success | ReturnCode.InternalError | ReturnCode.LogCheckError | ReturnCode.FlowError>;
 }

package/build/commands/flow/flowCommand.js

@@ -67,7 +67,8 @@ var FlowSubCommand;
 })(FlowSubCommand || (FlowSubCommand = {}));
 var syntax = 'flow <subCommand> [options]';
 var usage = 'sasjs flow <execute> --source <flowPath> [options]';
-var description = 'Performs operations on flows of jobs.';
+var description = 'Performs operations on flows of jobs.\n' +
+    'Exits non-zero when a flow does not complete: 6 when a job did not succeed, 2 when the flow could not be executed at all.';
 var examples = [
     {
         command: 'sasjs flow execute --source /local/flow.json --logFolder /local/log/folder --csvFile /local/some.csv --target myTarget --streamLog',
@@ -163,6 +164,14 @@ var FlowCommand = /** @class */ (function (_super) {
                         return [4 /*yield*/, (0, execute_1.execute)(target, sasjs, authConfig, source, logFolder, csvFile, streamLog)
                                 .then(function (csvFilePath) {
                                 var _a;
+                                // execute() resolves a path or rejects. Anything else is a contract
+                                // violation, and reporting it as a successful flow would hide it - the
+                                // shape that used to arrive here was `false` for a failed flow, which is
+                                // what turned a failure into a TypeError
+                                if (typeof csvFilePath !== 'string') {
+                                    (0, utils_1.displayError)(new Error("The flow reported completion without a CSV path (resolved ".concat(typeof csvFilePath, ").")), 'An error has occurred when executing this flow.');
+                                    return command_1.ReturnCode.InternalError;
+                                }
                                 var pathSepRegExp = new RegExp(path_1.default.sep.replace(/\\/g, '\\\\'), 'g');
                                 (_a = process.logger) === null || _a === void 0 ? void 0 : _a.info("CSV file located at: ".concat(csvFilePath.replace(pathSepRegExp, '/')));
                                 return command_1.ReturnCode.Success;
@@ -170,6 +179,10 @@ var FlowCommand = /** @class */ (function (_super) {
                                 .catch(function (err) {
                                 if ((0, logcheck_1.isLogCheckFailure)(err))
                                     return command_1.ReturnCode.LogCheckError;
+                                if ((0, execute_1.isFlowFailure)(err)) {
+                                    (0, utils_1.displayError)(err, 'The flow did not complete successfully.');
+                                    return command_1.ReturnCode.FlowError;
+                                }
                                 (0, utils_1.displayError)(err, 'An error has occurred when executing this flow.');
                                 return command_1.ReturnCode.InternalError;
                             })];

package/build/commands/flow/spec/flow.spec.js

@@ -207,9 +207,104 @@ describe('sasjs flow', function () {
                 }
             });
         }); });
+        it('rejects with the failing job rather than resolving a value', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var flows, error;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        flows = {
+                            flow1: {
+                                jobs: [{ location: 'goodJob' }, { location: 'badJob' }],
+                                predecessors: []
+                            }
+                        };
+                        setupMocks(flows, 'badJob');
+                        return [4 /*yield*/, executeFlowWrapper().catch(function (thrown) { return thrown; })
+                            // the marker, not `instanceof`: the built artefact is es5, where an Error
+                            // subclass loses its prototype chain, so the assertion has to be the one
+                            // that holds in both places
+                        ];
+                    case 1:
+                        error = _a.sent();
+                        // the marker, not `instanceof`: the built artefact is es5, where an Error
+                        // subclass loses its prototype chain, so the assertion has to be the one
+                        // that holds in both places
+                        expect((0, execute_1.isFlowFailure)(error)).toBe(true);
+                        expect(error.message).toEqual('The flow did not complete with all jobs successful: badJob (failure).');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('rejects with a flow error a caller can recognise', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var flows;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        flows = {
+                            flow1: { jobs: [{ location: 'badJob' }], predecessors: [] }
+                        };
+                        setupMocks(flows, 'badJob');
+                        return [4 /*yield*/, expect(executeFlowWrapper()).rejects.toSatisfy(execute_1.isFlowFailure)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+});
+describe('FlowExecutionError', function () {
+    it('carries the flow results path, and says where they are', function () {
+        var error = new execute_1.FlowExecutionError('The flow did not complete with all jobs successful: /b (failure).', '/project/sasjsresults/flow-results.csv');
+        expect(error.csvFilePath).toEqual('/project/sasjsresults/flow-results.csv');
+        expect(error.message).toEqual('The flow did not complete with all jobs successful: /b (failure). ' +
+            'The flow results were written to /project/sasjsresults/flow-results.csv.');
+        expect((0, execute_1.isFlowFailure)(error)).toBe(true);
+    });
+    it('says nothing about a path it was not given', function () {
+        expect(new execute_1.FlowExecutionError('The flow failed.').message).toEqual('The flow failed.');
+    });
+});
+describe('describeFailedJobs', function () {
+    it('names every job that did not succeed, across flows', function () {
+        var flows = {
+            flow1: {
+                jobs: [
+                    { location: '/a', status: flow_1.FlowWaveJobStatus.Success },
+                    { location: '/b', status: flow_1.FlowWaveJobStatus.Failure }
+                ]
+            },
+            flow2: {
+                jobs: [{ location: '/c', status: flow_1.FlowWaveJobStatus.Failure }]
+            }
+        };
+        expect((0, execute_1.describeFailedJobs)(flows)).toEqual('The flow did not complete with all jobs successful: /b (failure), /c (failure).');
+    });
+    it('leaves out jobs that did not run', function () {
+        var flows = {
+            flow1: {
+                jobs: [
+                    { location: '/never-ran' },
+                    { location: '/b', status: flow_1.FlowWaveJobStatus.Failure }
+                ]
+            }
+        };
+        expect((0, execute_1.describeFailedJobs)(flows)).toEqual('The flow did not complete with all jobs successful: /b (failure).');
+    });
+    it('names a job whose status is falsy rather than dropping it', function () {
+        // a status constant added later could be falsy; truthiness would silently
+        // omit that job from the only diagnosis the caller gets
+        var flows = {
+            flow1: { jobs: [{ location: '/zero', status: 0 }] }
+        };
+        expect((0, execute_1.describeFailedJobs)(flows)).toEqual('The flow did not complete with all jobs successful: /zero (0).');
+    });
+    it('states the failure without a list when no job carries a status', function () {
+        var flows = { flow1: { jobs: [{ location: '/a' }] } };
+        expect((0, execute_1.describeFailedJobs)(flows)).toEqual('The flow did not complete with all jobs successful.');
     });
 });
-var setupMocks = function (flows) {
+var setupMocks = function (flows, failingJob) {
     jest.restoreAllMocks();
     jest.mock('../internal/validateParams');
     jest.mock('../internal/executeFlow');
@@ -223,9 +318,14 @@ var setupMocks = function (flows) {
     jest.spyOn(executeFlowModule, 'executeFlow').mockImplementation(function (flow) { return __awaiter(void 0, void 0, void 0, function () {
         return __generator(this, function (_a) {
             flow.execution = 'started';
-            flow.jobs.forEach(function (job) { return (job.status = flow_1.FlowWaveJobStatus.Success); });
+            flow.jobs.forEach(function (job) {
+                job.status =
+                    job.location === failingJob
+                        ? flow_1.FlowWaveJobStatus.Failure
+                        : flow_1.FlowWaveJobStatus.Success;
+            });
             return [2 /*return*/, {
-                    jobStatus: true,
+                    jobStatus: !failingJob,
                     flowStatus: { terminate: false, message: '' }
                 }];
         });

package/build/commands/flow/spec/flowCommand.spec.js

@@ -95,6 +95,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var executeModule = __importStar(require("../execute"));
+var execute_1 = require("../execute");
 var flowCommand_1 = require("../flowCommand");
 var utils_1 = require("@sasjs/utils");
 var configUtils = __importStar(require("../../../utils/config"));
@@ -264,6 +265,54 @@ describe('FlowCommand', function () {
             }
         });
     }); });
+    it('should return the flow code when the flow did not succeed', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var command, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    jest
+                        .spyOn(executeModule, 'execute')
+                        .mockImplementation(function () {
+                        return Promise.reject(new execute_1.FlowExecutionError('badJob (failure)'));
+                    });
+                    command = new flowCommand_1.FlowCommand(__spreadArray(__spreadArray([], __read(defaultArgs), false), [
+                        'flow',
+                        'execute',
+                        '--source',
+                        source
+                    ], false));
+                    _a = expect;
+                    return [4 /*yield*/, command.execute()];
+                case 1:
+                    _a.apply(void 0, [_b.sent()]).toEqual(command_1.ReturnCode.FlowError);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should treat a resolve without a CSV path as an internal error', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var command, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    // execute() resolves a path or rejects; anything else is a contract
+                    // violation, and must not be reported as a green flow
+                    jest
+                        .spyOn(executeModule, 'execute')
+                        .mockImplementation(function () { return Promise.resolve(false); });
+                    command = new flowCommand_1.FlowCommand(__spreadArray(__spreadArray([], __read(defaultArgs), false), [
+                        'flow',
+                        'execute',
+                        '--source',
+                        source
+                    ], false));
+                    _a = expect;
+                    return [4 /*yield*/, command.execute()];
+                case 1:
+                    _a.apply(void 0, [_b.sent()]).toEqual(command_1.ReturnCode.InternalError);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('should log the error and return the error code when execution is unsuccessful', function () { return __awaiter(void 0, void 0, void 0, function () {
         var args, command, returnCode;
         return __generator(this, function (_a) {

package/build/commands/fs/fsCommand.js

@@ -332,17 +332,23 @@ var FSCommand = /** @class */ (function (_super) {
                                 return __generator(this, function (_c) {
                                     switch (_c.label) {
                                         case 0: return [4 /*yield*/, (0, utils_1.saveLog)(log, path_1.default.join(outputFolder, 'deploy.log'), '', false)
-                                            // after the log file is written: a deploy whose log fails the check is
-                                            // the deploy whose record someone needs to read
+                                            // After the log file is written: a deploy whose log fails the check is
+                                            // the deploy whose record someone needs to read. Fatal, because a
+                                            // deploy that aborted still has to fail the build - reporting it and
+                                            // then printing "successfully deployed" is the bug in sasjs/cli#1535.
                                         ];
                                         case 1:
                                             _c.sent();
-                                            // after the log file is written: a deploy whose log fails the check is
-                                            // the deploy whose record someone needs to read
-                                            return [4 /*yield*/, (0, logcheck_1.checkLog)(log, 'fs deploy')];
+                                            // After the log file is written: a deploy whose log fails the check is
+                                            // the deploy whose record someone needs to read. Fatal, because a
+                                            // deploy that aborted still has to fail the build - reporting it and
+                                            // then printing "successfully deployed" is the bug in sasjs/cli#1535.
+                                            return [4 /*yield*/, (0, logcheck_1.checkLog)(log, 'fs deploy', { fatal: true })];
                                         case 2:
-                                            // after the log file is written: a deploy whose log fails the check is
-                                            // the deploy whose record someone needs to read
+                                            // After the log file is written: a deploy whose log fails the check is
+                                            // the deploy whose record someone needs to read. Fatal, because a
+                                            // deploy that aborted still has to fail the build - reporting it and
+                                            // then printing "successfully deployed" is the bug in sasjs/cli#1535.
                                             _c.sent();
                                             return [2 /*return*/];
                                     }

package/build/commands/fs/spec/fsCommand.spec.js

@@ -103,6 +103,8 @@ var FileModule = __importStar(require("@sasjs/utils/file"));
 var configUtils = __importStar(require("../../../utils/config"));
 var setConstantsUtils = __importStar(require("../../../utils/setConstants"));
 var executeCodeModule = __importStar(require("../internal/executeCode"));
+var logcheckModule = __importStar(require("../../../utils/logcheck"));
+var logcheck_1 = require("../../../utils/logcheck");
 var defaultArgs = ['node', 'sasjs', 'fs'];
 var target = new utils_1.Target({
     name: 'test',
@@ -227,6 +229,28 @@ describe('FSCommand', function () {
                 }
             });
         }); });
+        it('should return the logcheck code when the deploy log fails the check', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var returnCode;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        jest
+                            .spyOn(logcheckModule, 'checkLog')
+                            .mockImplementation(function () {
+                            return Promise.reject(new logcheck_1.LogCheckFailure('2 errors'));
+                        });
+                        return [4 /*yield*/, executeCommandWrapper([
+                                'deploy',
+                                'localFolder',
+                                'remoteFolder'
+                            ])];
+                    case 1:
+                        returnCode = _a.sent();
+                        expect(returnCode).toEqual(command_1.ReturnCode.LogCheckError);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
     });
     describe('sync', function () {
         beforeEach(function () {
@@ -335,6 +359,102 @@ describe('FSCommand', function () {
                 }
             });
         }); });
+        it('should return the logcheck code when the sync log fails the check', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var returnCode;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        jest
+                            .spyOn(logcheckModule, 'checkLog')
+                            .mockImplementation(function () {
+                            return Promise.reject(new logcheck_1.LogCheckFailure('1 error'));
+                        });
+                        jest.spyOn(FSModule, 'extractHashArray').mockImplementationOnce(function () { return []; });
+                        return [4 /*yield*/, executeCommandWrapper([
+                                'sync',
+                                '-l',
+                                'localFolder',
+                                '-r',
+                                'remoteFolder'
+                            ])];
+                    case 1:
+                        returnCode = _a.sent();
+                        expect(returnCode).toEqual(command_1.ReturnCode.LogCheckError);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe('log check mode', function () {
+        beforeEach(function () {
+            process.logger = new utils_1.Logger(utils_1.LogLevel.Off);
+            jest.spyOn(process.logger, 'info');
+            setupMocks();
+            jest
+                .spyOn(FSModule, 'generateCompileProgram')
+                .mockImplementation(function () { return Promise.resolve(''); });
+            jest
+                .spyOn(FileModule, 'createFile')
+                .mockImplementation(function () { return Promise.resolve(); });
+            jest
+                .spyOn(executeCodeModule, 'executeCode')
+                .mockImplementation(function () { return Promise.resolve({ log: '' }); });
+            jest
+                .spyOn(logcheckModule, 'checkLog')
+                .mockImplementation(function () { return Promise.resolve(); });
+        });
+        it('should switch the log check on for --logcheck', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var spy;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        spy = jest.spyOn(logcheckModule, 'setLogCheckMode');
+                        return [4 /*yield*/, executeCommandWrapper([
+                                'deploy',
+                                'localFolder',
+                                'remoteFolder',
+                                '--logcheck'
+                            ])];
+                    case 1:
+                        _a.sent();
+                        expect(spy).toHaveBeenCalledWith('on');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should switch the log check off for --no-logcheck', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var spy;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        spy = jest.spyOn(logcheckModule, 'setLogCheckMode');
+                        return [4 /*yield*/, executeCommandWrapper([
+                                'deploy',
+                                'localFolder',
+                                'remoteFolder',
+                                '--no-logcheck'
+                            ])];
+                    case 1:
+                        _a.sent();
+                        expect(spy).toHaveBeenCalledWith('off');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should leave the log check on auto when no flag is given', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var spy;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        spy = jest.spyOn(logcheckModule, 'setLogCheckMode');
+                        return [4 /*yield*/, executeCommandWrapper(['deploy', 'localFolder', 'remoteFolder'])];
+                    case 1:
+                        _a.sent();
+                        expect(spy).toHaveBeenCalledWith('auto');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
     });
     describe('invalid subCommand', function () {
         it('should return ReturnCode.InvalidCommand when subCommand is unknown', function () { return __awaiter(void 0, void 0, void 0, function () {

package/build/commands/job/internal/execute/viya.js

@@ -68,7 +68,7 @@ var utils_4 = require("../utils");
  */
 function executeJobViya(sasjs, authConfig, jobPath, target, waitForJob, output, logFile, statusFile, ignoreWarnings, source, streamLog) {
     return __awaiter(this, void 0, void 0, function () {
-        var pollOptions, result, startTime, contextName, macroVars, submittedJob, endTime, outputJson, currentDirPath, outputPath, folderPath, parentFolderPath, logObj, logUrl, logCount, logData, error_1;
+        var pollOptions, result, startTime, contextName, macroVars, submittedJob, endTime, wantsVerdict, outputJson, currentDirPath, outputPath, folderPath, parentFolderPath, error_1, logObj, logUrl, logCount, logData, error_2;
         var _this = this;
         var _a, _b;
         return __generator(this, function (_c) {
@@ -176,15 +176,18 @@ function executeJobViya(sasjs, authConfig, jobPath, target, waitForJob, output,
                     _c.sent();
                     _c.label = 8;
                 case 8:
-                    if (!(submittedJob && submittedJob.links)) return [3 /*break*/, 22];
+                    if (!(submittedJob && submittedJob.links)) return [3 /*break*/, 28];
                     if (!result)
                         result = true;
-                    if (!(output || logFile)) return [3 /*break*/, 21];
-                    _c.label = 9;
+                    return [4 /*yield*/, (0, logcheck_1.logCheckWantsVerdict)()];
                 case 9:
-                    _c.trys.push([9, 20, , 21]);
+                    wantsVerdict = _c.sent();
+                    if (!output) return [3 /*break*/, 18];
+                    _c.label = 10;
+                case 10:
+                    _c.trys.push([10, 17, , 18]);
                     outputJson = JSON.stringify(submittedJob, null, 2);
-                    if (!(typeof output === 'string')) return [3 /*break*/, 14];
+                    if (!(typeof output === 'string')) return [3 /*break*/, 15];
                     currentDirPath = path_1.default.isAbsolute(output)
                         ? ''
                         : process.projectDir;
@@ -195,55 +198,71 @@ function executeJobViya(sasjs, authConfig, jobPath, target, waitForJob, output,
                     folderPath.pop();
                     parentFolderPath = folderPath.join(path_1.default.sep);
                     return [4 /*yield*/, (0, utils_2.folderExists)(parentFolderPath)];
-                case 10:
-                    if (!!(_c.sent())) return [3 /*break*/, 12];
-                    return [4 /*yield*/, (0, utils_2.createFolder)(parentFolderPath)];
                 case 11:
+                    if (!!(_c.sent())) return [3 /*break*/, 13];
+                    return [4 /*yield*/, (0, utils_2.createFolder)(parentFolderPath)];
+                case 12:
                     _c.sent();
-                    _c.label = 12;
-                case 12: return [4 /*yield*/, (0, utils_2.createFile)(outputPath, outputJson)];
-                case 13:
+                    _c.label = 13;
+                case 13: return [4 /*yield*/, (0, utils_2.createFile)(outputPath, outputJson)];
+                case 14:
                     _c.sent();
                     (0, displayResult_1.displaySuccess)("Output saved to: ".concat(outputPath));
-                    return [3 /*break*/, 15];
-                case 14:
+                    return [3 /*break*/, 16];
+                case 15:
                     if (output) {
                         // log job object to the console
                         ;
                         (process.logger || console).log(outputJson);
                     }
-                    _c.label = 15;
-                case 15:
-                    if (!(logFile && !pollOptions.streamLog)) return [3 /*break*/, 19];
+                    _c.label = 16;
+                case 16:
+                    result = submittedJob;
+                    return [3 /*break*/, 18];
+                case 17:
+                    error_1 = _c.sent();
+                    // handle use case when submitted job can't be parsed
+                    result = false;
+                    (0, displayResult_1.displayError)(null, 'An error has occurred when parsing an output of the job.');
+                    return [3 /*break*/, 18];
+                case 18:
+                    if (!(!pollOptions.streamLog && (Boolean(logFile) || wantsVerdict))) return [3 /*break*/, 27];
                     logObj = submittedJob.links.find(function (link) { return link.rel === 'log' && link.method === 'GET'; });
-                    if (!logObj) return [3 /*break*/, 19];
+                    if (!logObj) return [3 /*break*/, 26];
+                    _c.label = 19;
+                case 19:
+                    _c.trys.push([19, 24, , 25]);
                     logUrl = target.serverUrl + logObj.href;
                     logCount = submittedJob.logStatistics.lineCount;
                     return [4 /*yield*/, (0, fetchLogFileContent_1.fetchLogFileContent)(sasjs, authConfig.access_token, logUrl, logCount)];
-                case 16:
+                case 20:
                     logData = _c.sent();
+                    if (!logFile) return [3 /*break*/, 22];
                     return [4 /*yield*/, (0, utils_4.saveLog)(logData, logFile, jobPath)];
-                case 17:
+                case 21:
                     _c.sent();
-                    return [4 /*yield*/, (0, logcheck_1.checkLog)(typeof logData === 'string' ? logData : (0, utils_1.parseLogLines)(logData), jobPath)];
-                case 18:
+                    _c.label = 22;
+                case 22: return [4 /*yield*/, (0, logcheck_1.checkLog)(typeof logData === 'string' ? logData : (0, utils_1.parseLogLines)(logData), jobPath)];
+                case 23:
                     _c.sent();
-                    _c.label = 19;
-                case 19:
-                    result = submittedJob;
-                    return [3 /*break*/, 21];
-                case 20:
-                    error_1 = _c.sent();
-                    // A log-check failure is the verdict the caller asked for, not a parse
-                    // error: swallowing it here printed "Logcheck failed" and then exited 0,
-                    // which is the green pipeline the feature exists to prevent.
-                    if ((0, logcheck_1.isLogCheckFailure)(error_1))
-                        throw error_1;
-                    // handle use case when submitted job can't be parsed
+                    return [3 /*break*/, 25];
+                case 24:
+                    error_2 = _c.sent();
+                    // the verdict the caller asked for, not a failed fetch
+                    if ((0, logcheck_1.isLogCheckFailure)(error_2))
+                        throw error_2;
                     result = false;
-                    (0, displayResult_1.displayError)(null, 'An error has occurred when parsing an output of the job.');
-                    return [3 /*break*/, 21];
-                case 21:
+                    (0, displayResult_1.displayError)(null, 'An error has occurred when retrieving the job log.');
+                    return [3 /*break*/, 25];
+                case 25: return [3 /*break*/, 27];
+                case 26:
+                    // A log was asked for and the job carries none. Staying quiet here is
+                    // the same "flag that does nothing" this block exists to remove: it
+                    // reaches the end with the job's own status and exits 0.
+                    result = false;
+                    (0, displayResult_1.displayError)(null, 'An error has occurred: the job returned no log to check or save.');
+                    _c.label = 27;
+                case 27:
                     // wait for job state and return status(0,1,2) based on it
                     if (waitForJob && submittedJob.state) {
                         switch (submittedJob.state) {
@@ -259,13 +278,13 @@ function executeJobViya(sasjs, authConfig, jobPath, target, waitForJob, output,
                                 break;
                         }
                     }
-                    return [3 /*break*/, 23];
-                case 22:
+                    return [3 /*break*/, 29];
+                case 28:
                     if (result) {
                         (0, utils_3.terminateProcess)(command_1.ReturnCode.InternalError);
                     }
-                    _c.label = 23;
-                case 23:
+                    _c.label = 29;
+                case 29:
                     (_b = process.logger) === null || _b === void 0 ? void 0 : _b.info("This job was executed in ".concat((endTime - startTime) / 1000, " seconds"));
                     return [2 /*return*/, result];
             }

package/build/commands/job/spec/execute.spec.js

@@ -82,6 +82,8 @@ var configUtils = __importStar(require("../../../utils/config"));
 var logcheckModule = __importStar(require("../../../utils/logcheck"));
 var fetchLogFileContentModule = __importStar(require("../../shared/fetchLogFileContent"));
 var logcheck_1 = require("../../../utils/logcheck");
+var jobUtils = __importStar(require("../internal/utils"));
+var displayResultModule = __importStar(require("../../../utils/displayResult"));
 var execute_1 = require("../internal/execute");
 var mocks_1 = require("./mocks");
 var sasjs = new node_1.default();
@@ -194,6 +196,92 @@ describe('executeJobViya', function () {
             }
         });
     }); });
+    it('fetches the log under --logcheck even when no log file was named', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var saveSpy, fetchSpy, failure;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    // otherwise the flag prints nothing and exits 0, which reads as a clean log
+                    jest.spyOn(logcheckModule, 'logCheckWantsVerdict').mockResolvedValue(true);
+                    saveSpy = jest.spyOn(jobUtils, 'saveLog').mockResolvedValue(undefined);
+                    jest.spyOn(sasjs, 'startComputeJob').mockResolvedValue({
+                        job: {
+                            state: 'completed',
+                            links: [{ rel: 'log', method: 'GET', href: '/log' }],
+                            logStatistics: { lineCount: 5 }
+                        }
+                    });
+                    fetchSpy = jest
+                        .spyOn(fetchLogFileContentModule, 'fetchLogFileContent')
+                        .mockResolvedValue('ERROR: deliberate');
+                    failure = new logcheck_1.LogCheckFailure('SAS log check failed for test/job');
+                    jest.spyOn(logcheckModule, 'checkLog').mockRejectedValue(failure);
+                    return [4 /*yield*/, expect((0, execute_1.executeJobViya)(sasjs, mocks_1.mockAuthConfig, 'test/job', target, true, false, undefined, undefined, false, undefined, false)).rejects.toBe(failure)];
+                case 1:
+                    _a.sent();
+                    expect(fetchSpy).toHaveBeenCalled();
+                    // the log was fetched for the verdict, not asked for: writing it would
+                    // leave a file in the project directory that nobody requested
+                    expect(saveSpy).not.toHaveBeenCalled();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('names the log fetch, not the job output, when the log cannot be retrieved', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var checkSpy, displaySpy, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    jest.spyOn(logcheckModule, 'logCheckWantsVerdict').mockResolvedValue(true);
+                    jest.spyOn(sasjs, 'startComputeJob').mockResolvedValue({
+                        job: {
+                            state: 'completed',
+                            links: [{ rel: 'log', method: 'GET', href: '/log' }],
+                            logStatistics: { lineCount: 5 }
+                        }
+                    });
+                    jest
+                        .spyOn(fetchLogFileContentModule, 'fetchLogFileContent')
+                        .mockRejectedValue(new Error('502 Bad Gateway'));
+                    checkSpy = jest.spyOn(logcheckModule, 'checkLog');
+                    displaySpy = jest.spyOn(displayResultModule, 'displayError');
+                    return [4 /*yield*/, (0, execute_1.executeJobViya)(sasjs, mocks_1.mockAuthConfig, 'test/job', target, false, false, undefined, undefined, false, undefined, false)];
+                case 1:
+                    result = _a.sent();
+                    expect(result).toBe(false);
+                    expect(checkSpy).not.toHaveBeenCalled();
+                    expect(displaySpy).toHaveBeenCalledWith(null, 'An error has occurred when retrieving the job log.');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('fails a verdict asked for from a job that carries no log link', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var fetchSpy, checkSpy, displaySpy, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    jest.spyOn(logcheckModule, 'logCheckWantsVerdict').mockResolvedValue(true);
+                    jest.spyOn(sasjs, 'startComputeJob').mockResolvedValue({
+                        job: {
+                            state: 'completed',
+                            links: [],
+                            logStatistics: { lineCount: 0 }
+                        }
+                    });
+                    fetchSpy = jest.spyOn(fetchLogFileContentModule, 'fetchLogFileContent');
+                    checkSpy = jest.spyOn(logcheckModule, 'checkLog');
+                    displaySpy = jest.spyOn(displayResultModule, 'displayError');
+                    return [4 /*yield*/, (0, execute_1.executeJobViya)(sasjs, mocks_1.mockAuthConfig, 'test/job', target, false, false, undefined, undefined, false, undefined, false)];
+                case 1:
+                    result = _a.sent();
+                    expect(result).toBe(false);
+                    expect(fetchSpy).not.toHaveBeenCalled();
+                    expect(checkSpy).not.toHaveBeenCalled();
+                    expect(displaySpy).toHaveBeenCalledWith(null, 'An error has occurred: the job returned no log to check or save.');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
 });
 describe('executeJobSasjs', function () {
     beforeEach(function () { return __awaiter(void 0, void 0, void 0, function () {

package/build/types/command/returnCode.d.ts

@@ -4,5 +4,6 @@ export declare enum ReturnCode {
     InternalError = 2,
     LintError = 3,
     AlreadyInitialised = 4,
-    LogCheckError = 5
+    LogCheckError = 5,
+    FlowError = 6
 }

package/build/types/command/returnCode.js

@@ -13,6 +13,10 @@ var ReturnCode;
     ReturnCode[ReturnCode["AlreadyInitialised"] = 4] = "AlreadyInitialised";
     // `logcheck` found issues at or above the configured failure policy. Kept
     // apart from LintError so a pipeline can tell a code-quality failure from a
-    // run that SAS complained about.
+    // run SAS complained about.
     ReturnCode[ReturnCode["LogCheckError"] = 5] = "LogCheckError";
+    // A flow finished without every job succeeding. Distinct from InternalError,
+    // which also covers a bad source file or an unreachable server, so a pipeline
+    // can tell "the flow failed" from "the CLI could not run the flow".
+    ReturnCode[ReturnCode["FlowError"] = 6] = "FlowError";
 })(ReturnCode || (exports.ReturnCode = ReturnCode = {}));

package/build/utils/logcheck.d.ts

@@ -32,6 +32,15 @@ export declare class LogCheckFailure extends Error {
     readonly logCheckFailure = true;
     constructor(message: string);
 }
+/**
+ * Whether a log reaching this command has to be fetched at all.
+ *
+ * Reporting is free once a command owns a log, but a command that never
+ * receives one - a Viya job run without `--log` - has to ask for it. It asks
+ * when the verdict counts: `--logcheck`, or `logCheck.autoCheck` in the project
+ * config. A check nobody asked for is not worth an extra request.
+ */
+export declare const logCheckWantsVerdict: () => Promise<boolean>;
 export declare const isLogCheckFailure: (error: unknown) => error is LogCheckFailure;
 /**
  * Reports the issues in a log a command just received, and throws when the
@@ -41,4 +50,6 @@ export declare const isLogCheckFailure: (error: unknown) => error is LogCheckFai
  * have their own success output, and a check that announces itself on every
  * green run is noise that gets switched off.
  */
-export declare const checkLog: (logText: string | undefined | null, label: string) => Promise<void>;
+export declare const checkLog: (logText: string | undefined | null, label: string, options?: {
+    fatal?: boolean;
+}) => Promise<void>;

package/build/utils/logcheck.js

@@ -90,7 +90,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkLog = exports.isLogCheckFailure = exports.LogCheckFailure = exports.logCheckModeOf = exports.getLogCheckMode = exports.setLogCheckMode = void 0;
+exports.checkLog = exports.isLogCheckFailure = exports.logCheckWantsVerdict = exports.LogCheckFailure = exports.logCheckModeOf = exports.getLogCheckMode = exports.setLogCheckMode = void 0;
 var logs_1 = require("@sasjs/utils/logs");
 var chalk_1 = __importDefault(require("chalk"));
 var collectLogs_1 = require("../commands/logcheck/collectLogs");
@@ -135,6 +135,36 @@ var LogCheckFailure = /** @class */ (function (_super) {
     return LogCheckFailure;
 }(Error));
 exports.LogCheckFailure = LogCheckFailure;
+/**
+ * Whether a log reaching this command has to be fetched at all.
+ *
+ * Reporting is free once a command owns a log, but a command that never
+ * receives one - a Viya job run without `--log` - has to ask for it. It asks
+ * when the verdict counts: `--logcheck`, or `logCheck.autoCheck` in the project
+ * config. A check nobody asked for is not worth an extra request.
+ */
+var logCheckWantsVerdict = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                if (mode === 'off')
+                    return [2 /*return*/, false];
+                if (mode === 'on')
+                    return [2 /*return*/, true];
+                _b.label = 1;
+            case 1:
+                _b.trys.push([1, 3, , 4]);
+                return [4 /*yield*/, (0, logCheckConfig_1.readLogCheckConfig)()];
+            case 2: return [2 /*return*/, (_b.sent()).autoCheck === true];
+            case 3:
+                _a = _b.sent();
+                return [2 /*return*/, false];
+            case 4: return [2 /*return*/];
+        }
+    });
+}); };
+exports.logCheckWantsVerdict = logCheckWantsVerdict;
 var isLogCheckFailure = function (error) {
     return (error === null || error === void 0 ? void 0 : error.logCheckFailure) === true;
 };
@@ -147,43 +177,50 @@ exports.isLogCheckFailure = isLogCheckFailure;
  * have their own success output, and a check that announces itself on every
  * green run is noise that gets switched off.
  */
-var checkLog = function (logText, label) { return __awaiter(void 0, void 0, void 0, function () {
-    var config, error_1, _a, issues, suppressed, counts, failing, totals, failure;
-    var _b;
-    return __generator(this, function (_c) {
-        switch (_c.label) {
-            case 0:
-                if (mode === 'off' || !logText)
+var checkLog = function (logText_1, label_1) {
+    var args_1 = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args_1[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, __spreadArray([logText_1, label_1], __read(args_1), false), void 0, function (logText, label, options) {
+        var config, error_1, _a, issues, suppressed, counts, failing, totals, failure;
+        var _b;
+        if (options === void 0) { options = {}; }
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    if (mode === 'off' || !logText)
+                        return [2 /*return*/];
+                    _c.label = 1;
+                case 1:
+                    _c.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, (0, logCheckConfig_1.readLogCheckConfig)()];
+                case 2:
+                    config = _c.sent();
+                    return [3 /*break*/, 4];
+                case 3:
+                    error_1 = _c.sent();
+                    // An automatic check must never break the command it is riding on: a
+                    // config it cannot read is worth a warning, not a failed run.
+                    (_b = process.logger) === null || _b === void 0 ? void 0 : _b.warn("Skipping the SAS log check: ".concat(error_1.message));
                     return [2 /*return*/];
-                _c.label = 1;
-            case 1:
-                _c.trys.push([1, 3, , 4]);
-                return [4 /*yield*/, (0, logCheckConfig_1.readLogCheckConfig)()];
-            case 2:
-                config = _c.sent();
-                return [3 /*break*/, 4];
-            case 3:
-                error_1 = _c.sent();
-                // An automatic check must never break the command it is riding on: a
-                // config it cannot read is worth a warning, not a failed run.
-                (_b = process.logger) === null || _b === void 0 ? void 0 : _b.warn("Skipping the SAS log check: ".concat(error_1.message));
-                return [2 /*return*/];
-            case 4:
-                _a = (0, collectLogs_1.partitionIssues)((0, logs_1.parseLog)(logText), config.ignoreCodes), issues = _a.issues, suppressed = _a.suppressed;
-                if (!issues.length)
+                case 4:
+                    _a = (0, collectLogs_1.partitionIssues)((0, logs_1.parseLog)(logText), config.ignoreCodes), issues = _a.issues, suppressed = _a.suppressed;
+                    if (!issues.length)
+                        return [2 /*return*/];
+                    counts = (0, collectLogs_1.countIssues)(issues);
+                    failing = options.fatal === true || mode === 'on' || config.autoCheck === true;
+                    totals = __assign(__assign({}, counts), { suppressed: suppressed.length, logs: 1, skipped: 0 });
+                    failure = failing ? (0, processLogCheck_1.describeFailure)(totals, config) : undefined;
+                    renderInline(label, issues, counts, suppressed.length, config, failure);
+                    if (failure) {
+                        throw new LogCheckFailure("SAS log check failed for ".concat(label, ": ").concat(failure));
+                    }
                     return [2 /*return*/];
-                counts = (0, collectLogs_1.countIssues)(issues);
-                failing = mode === 'on' || config.autoCheck === true;
-                totals = __assign(__assign({}, counts), { suppressed: suppressed.length, logs: 1, skipped: 0 });
-                failure = failing ? (0, processLogCheck_1.describeFailure)(totals, config) : undefined;
-                renderInline(label, issues, counts, suppressed.length, config, failure);
-                if (failure) {
-                    throw new LogCheckFailure("SAS log check failed for ".concat(label, ": ").concat(failure));
-                }
-                return [2 /*return*/];
-        }
+            }
+        });
     });
-}); };
+};
 exports.checkLog = checkLog;
 /**
  * The inline report: the heading, the issues, and the verdict when there is

package/build/utils/spec/logcheck.spec.js

@@ -208,6 +208,19 @@ describe('checkLog', function () {
             }
         });
     }); });
+    it('fails a command that cannot succeed on a bad log, whatever the config says', function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, withProject()];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, expect((0, logcheck_1.checkLog)(logWithError, 'fs deploy', { fatal: true })).rejects.toBeInstanceOf(logcheck_1.LogCheckFailure)];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('does not fail on a note under the default policy', function () { return __awaiter(void 0, void 0, void 0, function () {
         return __generator(this, function (_a) {
             switch (_a.label) {
@@ -269,6 +282,99 @@ describe('checkLog', function () {
         });
     }); });
 });
+describe('logCheckWantsVerdict', function () {
+    var originalProjectDir = process.projectDir;
+    var withProject = function (logCheck) { return __awaiter(void 0, void 0, void 0, function () {
+        var folder;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, tempFolder()];
+                case 1:
+                    folder = _a.sent();
+                    process.projectDir = folder;
+                    if (!(logCheck !== undefined)) return [3 /*break*/, 3];
+                    return [4 /*yield*/, fs_1.promises.writeFile(path_1.default.join(folder, 'sasjsconfig.json'), JSON.stringify({ logCheck: logCheck }))];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3: return [2 /*return*/];
+            }
+        });
+    }); };
+    afterEach(function () {
+        process.projectDir = originalProjectDir;
+        (0, logcheck_1.setLogCheckMode)('auto');
+    });
+    it('is true under --logcheck and false under --no-logcheck', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, withProject()];
+                case 1:
+                    _c.sent();
+                    (0, logcheck_1.setLogCheckMode)('on');
+                    _a = expect;
+                    return [4 /*yield*/, (0, logcheck_1.logCheckWantsVerdict)()];
+                case 2:
+                    _a.apply(void 0, [_c.sent()]).toBe(true);
+                    (0, logcheck_1.setLogCheckMode)('off');
+                    _b = expect;
+                    return [4 /*yield*/, (0, logcheck_1.logCheckWantsVerdict)()];
+                case 3:
+                    _b.apply(void 0, [_c.sent()]).toBe(false);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('follows autoCheck when the mode is auto', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, _b, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0: return [4 /*yield*/, withProject({ autoCheck: true })];
+                case 1:
+                    _d.sent();
+                    _a = expect;
+                    return [4 /*yield*/, (0, logcheck_1.logCheckWantsVerdict)()];
+                case 2:
+                    _a.apply(void 0, [_d.sent()]).toBe(true);
+                    return [4 /*yield*/, withProject()];
+                case 3:
+                    _d.sent();
+                    _b = expect;
+                    return [4 /*yield*/, (0, logcheck_1.logCheckWantsVerdict)()];
+                case 4:
+                    _b.apply(void 0, [_d.sent()]).toBe(false);
+                    return [4 /*yield*/, withProject({ autoCheck: false })];
+                case 5:
+                    _d.sent();
+                    _c = expect;
+                    return [4 /*yield*/, (0, logcheck_1.logCheckWantsVerdict)()];
+                case 6:
+                    _c.apply(void 0, [_d.sent()]).toBe(false);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('asks for no log when the config cannot be read', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var folder, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, tempFolder()];
+                case 1:
+                    folder = _b.sent();
+                    process.projectDir = folder;
+                    return [4 /*yield*/, fs_1.promises.writeFile(path_1.default.join(folder, 'sasjsconfig.json'), '{ "logCheck": ')];
+                case 2:
+                    _b.sent();
+                    _a = expect;
+                    return [4 /*yield*/, (0, logcheck_1.logCheckWantsVerdict)()];
+                case 3:
+                    _a.apply(void 0, [_b.sent()]).toBe(false);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
 describe('isLogCheckFailure', function () {
     it('recognises only its own error', function () {
         expect((0, logcheck_1.isLogCheckFailure)(new logcheck_1.LogCheckFailure('x'))).toBe(true);

package/package.json

@@ -123,5 +123,5 @@
     "ws": "8.21.0",
     "nanoid": "3.3.18"
   },
-  "version": "6.8.1"
+  "version": "6.8.3"
 }