@sasjs/cli 6.7.0 → 6.8.0

package/build/commands/logcheck/spec/logCheckConfig.spec.js

@@ -75,16 +75,21 @@ describe('parseLogCheckSection', function () {
             maxWarnings: 4,
             ignoreCodes: ['49-169'],
             ignorePaths: ['sasjsresults/legacy'],
-            folder: 'logs'
+            folder: 'logs',
+            autoCheck: true
         });
         expect(config).toEqual({
             failOn: 'warning',
             maxWarnings: 4,
             ignoreCodes: ['49-169'],
             ignorePaths: ['sasjsresults/legacy'],
-            folder: 'logs'
+            folder: 'logs',
+            autoCheck: true
         });
     });
+    it('refuses an autoCheck that is not a boolean', function () {
+        expect(function () { return (0, logCheckConfig_1.parseLogCheckSection)({ autoCheck: 'yes' }); }).toThrow('must be true or false');
+    });
     it('refuses a failOn that is not one of the four policies', function () {
         expect(function () { return (0, logCheckConfig_1.parseLogCheckSection)({ failOn: 'warnings' }); }).toThrow('must be one of error, warning, note, never');
     });
@@ -150,6 +155,54 @@ describe('readLogCheckConfig', function () {
             }
         });
     }); });
+    it('reads the config from the SASjs convention, sasjs/sasjsconfig.json', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var folder, config;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, tempFolder()];
+                case 1:
+                    folder = _a.sent();
+                    process.projectDir = folder;
+                    return [4 /*yield*/, fs_1.promises.mkdir(path_1.default.join(folder, 'sasjs'))];
+                case 2:
+                    _a.sent();
+                    return [4 /*yield*/, fs_1.promises.writeFile(path_1.default.join(folder, 'sasjs', 'sasjsconfig.json'), JSON.stringify({ logCheck: { failOn: 'warning', autoCheck: true } }))];
+                case 3:
+                    _a.sent();
+                    return [4 /*yield*/, (0, logCheckConfig_1.readLogCheckConfig)()];
+                case 4:
+                    config = _a.sent();
+                    expect(config.failOn).toEqual('warning');
+                    expect(config.autoCheck).toBeTrue();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('prefers sasjs/sasjsconfig.json when a root file also exists', 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.mkdir(path_1.default.join(folder, 'sasjs'))];
+                case 2:
+                    _b.sent();
+                    return [4 /*yield*/, fs_1.promises.writeFile(path_1.default.join(folder, 'sasjs', 'sasjsconfig.json'), JSON.stringify({ logCheck: { failOn: 'note' } }))];
+                case 3:
+                    _b.sent();
+                    return [4 /*yield*/, fs_1.promises.writeFile(path_1.default.join(folder, 'sasjsconfig.json'), JSON.stringify({ logCheck: { failOn: 'never' } }))];
+                case 4:
+                    _b.sent();
+                    _a = expect;
+                    return [4 /*yield*/, (0, logCheckConfig_1.readLogCheckConfig)()];
+                case 5:
+                    _a.apply(void 0, [(_b.sent()).failOn]).toEqual('note');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('reads the section from the top level of the config', function () { return __awaiter(void 0, void 0, void 0, function () {
         var _a;
         return __generator(this, function (_b) {
@@ -227,6 +280,14 @@ describe('readLogCheckConfig', function () {
         });
     }); });
 });
+describe('configCandidates', function () {
+    it('tries the SASjs convention before the project root', function () {
+        expect((0, logCheckConfig_1.configCandidates)(path_1.default.join('some', 'project'))).toEqual([
+            path_1.default.join('some', 'project', 'sasjs', 'sasjsconfig.json'),
+            path_1.default.join('some', 'project', 'sasjsconfig.json')
+        ]);
+    });
+});
 describe('mergeConfig', function () {
     var base = __assign(__assign({}, types_1.defaultLogCheckConfig), { ignoreCodes: ['49-169'], ignorePaths: ['legacy'] });
     it('prefers the command line over the file', function () {

package/build/commands/logcheck/types.d.ts

@@ -41,6 +41,14 @@ export interface LogCheckConfig {
      * against the project folder.
      */
     folder?: string;
+    /**
+     * Whether the commands that receive a SAS log (`run`, `request`, `job
+     * execute`, `flow execute`) fail on it as well as reporting it. Off by
+     * default: those commands' exit codes are already load-bearing in pipelines,
+     * and a job that prints a notable note is not a failed job. `--logcheck` and
+     * `--no-logcheck` override it per run.
+     */
+    autoCheck?: boolean;
 }
 export declare const defaultLogCheckConfig: LogCheckConfig;
 /** Counts of the issues a log carries, after suppression. */

package/build/commands/request/request.js

@@ -35,6 +35,31 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -145,7 +170,7 @@ function runSasJob(target, isLocal, sasJobLocation, dataFilePath, configFilePath
                                     case 4:
                                         _a.sent();
                                         _a.label = 5;
-                                    case 5: return [4 /*yield*/, saveLogFile(sasjs, sasJobLocation, logFile, jobPath)];
+                                    case 5: return [4 /*yield*/, saveLogFile(sasjs, sasJobLocation, logFile, jobPath, true)];
                                     case 6:
                                         _a.sent();
                                         result = true;
@@ -170,33 +195,47 @@ function runSasJob(target, isLocal, sasJobLocation, dataFilePath, configFilePath
         });
     });
 }
-var saveLogFile = function (sasjs, sasJobLocation, logFile, jobPath) { return __awaiter(void 0, void 0, void 0, function () {
-    var sasRequests, currentRequestLog, logPath, timestamp, filename;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                sasRequests = sasjs.getSasRequests();
-                currentRequestLog = sasRequests.find(function (x) { return x.serviceLink === sasJobLocation; });
-                if (!(currentRequestLog && jobPath)) return [3 /*break*/, 4];
-                if (!!logFile) return [3 /*break*/, 2];
-                return [4 /*yield*/, (0, utils_2.isSASjsProject)()];
-            case 1:
-                logPath = (_a.sent())
-                    ? path_1.default.join(process.sasjsConstants.buildDestinationResultsFolder, 'requests')
-                    : process.projectDir;
-                timestamp = (0, utils_1.generateTimestamp)();
-                filename = sasJobLocation.split('/').pop() // always use forward slash in SAS Drive
-                ;
-                logFile = path_1.default.join(logPath, "".concat(filename, "-").concat(timestamp, ".log"));
-                _a.label = 2;
-            case 2: return [4 /*yield*/, (0, utils_2.saveLog)(currentRequestLog.logFile, logFile, jobPath || '', false)];
-            case 3:
-                _a.sent();
-                _a.label = 4;
-            case 4: return [2 /*return*/];
-        }
+var saveLogFile = function (sasjs_1, sasJobLocation_1, logFile_1, jobPath_1) {
+    var args_1 = [];
+    for (var _i = 4; _i < arguments.length; _i++) {
+        args_1[_i - 4] = arguments[_i];
+    }
+    return __awaiter(void 0, __spreadArray([sasjs_1, sasJobLocation_1, logFile_1, jobPath_1], __read(args_1), false), void 0, function (sasjs, sasJobLocation, logFile, jobPath, check) {
+        var sasRequests, currentRequestLog, logPath, timestamp, filename;
+        if (check === void 0) { check = false; }
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    sasRequests = sasjs.getSasRequests();
+                    currentRequestLog = sasRequests.find(function (x) { return x.serviceLink === sasJobLocation; });
+                    if (!(currentRequestLog && jobPath)) return [3 /*break*/, 5];
+                    if (!!logFile) return [3 /*break*/, 2];
+                    return [4 /*yield*/, (0, utils_2.isSASjsProject)()];
+                case 1:
+                    logPath = (_a.sent())
+                        ? path_1.default.join(process.sasjsConstants.buildDestinationResultsFolder, 'requests')
+                        : process.projectDir;
+                    timestamp = (0, utils_1.generateTimestamp)();
+                    filename = sasJobLocation.split('/').pop() // always use forward slash in SAS Drive
+                    ;
+                    logFile = path_1.default.join(logPath, "".concat(filename, "-").concat(timestamp, ".log"));
+                    _a.label = 2;
+                case 2: return [4 /*yield*/, (0, utils_2.saveLog)(currentRequestLog.logFile, logFile, jobPath || '', false)
+                    // after the write, not before: a request that fails the check is the one
+                    // whose log is wanted on disk
+                ];
+                case 3:
+                    _a.sent();
+                    if (!check) return [3 /*break*/, 5];
+                    return [4 /*yield*/, (0, utils_2.checkLog)(currentRequestLog.logFile, sasJobLocation)];
+                case 4:
+                    _a.sent();
+                    _a.label = 5;
+                case 5: return [2 /*return*/];
+            }
+        });
     });
-}); };
+};
 /**
  * Writes output to the file
  * @param outputPathParam path to output file

package/build/commands/request/requestCommand.js

@@ -58,6 +58,7 @@ var targetCommand_1 = require("../../types/command/targetCommand");
 var utils_2 = require("../../utils");
 var request_1 = require("./request");
 var getLogFilePath_1 = require("../../utils/getLogFilePath");
+var logcheck_1 = require("../../utils/logcheck");
 var syntax = 'request <sasProgramPath> [options]';
 var usage = 'sasjs request <sasProgramPath> --data <path-to-datafile> --config <path-to-configfile> --target <target-name> --output <path-to-outputfile> --log <path-to-logfile>';
 var description = "Lets the user run a SAS job against a specified target.\n" +
@@ -104,6 +105,11 @@ var RequestCommand = /** @class */ (function (_super) {
                     type: 'string',
                     alias: 'o',
                     description: 'path where output of the finished job execution will be saved.'
+                },
+                logcheck: {
+                    type: 'boolean',
+                    default: undefined,
+                    description: 'Check the SAS log this request received, and fail when logCheck in sasjsconfig.json says so. --no-logcheck switches both the report and the verdict off.'
                 }
             },
             syntax: syntax,
@@ -117,7 +123,9 @@ var RequestCommand = /** @class */ (function (_super) {
             var _a, target, isLocal, jobPath, log, output, authConfig, _b, e_1, _c, sasProgramPath, data, config;
             return __generator(this, function (_d) {
                 switch (_d.label) {
-                    case 0: return [4 /*yield*/, this.getTargetInfo()];
+                    case 0:
+                        (0, logcheck_1.setLogCheckMode)((0, logcheck_1.logCheckModeOf)(this.parsed.logcheck));
+                        return [4 /*yield*/, this.getTargetInfo()];
                     case 1:
                         _a = _d.sent(), target = _a.target, isLocal = _a.isLocal;
                         jobPath = (0, utils_2.prefixAppLoc)(target.appLoc, process.currentDir);
@@ -152,6 +160,8 @@ var RequestCommand = /** @class */ (function (_super) {
                                 return command_1.ReturnCode.Success;
                             })
                                 .catch(function (err) {
+                                if ((0, logcheck_1.isLogCheckFailure)(err))
+                                    return command_1.ReturnCode.LogCheckError;
                                 (0, utils_2.displayError)(err, 'An error has occurred when running your SAS job.');
                                 return command_1.ReturnCode.InternalError;
                             })];

package/build/commands/request/spec/requestCommand.spec.js

@@ -100,6 +100,7 @@ var utils_1 = require("@sasjs/utils");
 var configUtils = __importStar(require("../../../utils/config"));
 var setConstantsUtils = __importStar(require("../../../utils/setConstants"));
 var command_1 = require("../../../types/command");
+var logcheck_1 = require("../../../utils/logcheck");
 var defaultArgs = ['node', 'sasjs'];
 var target = new utils_1.Target({
     name: 'test',
@@ -116,6 +117,45 @@ describe('RequestCommand', function () {
     beforeEach(function () {
         setupMocks();
     });
+    afterEach(function () { return (0, logcheck_1.setLogCheckMode)('auto'); });
+    it('should return the logcheck code when the log check failed the request', 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(requestModule, 'runSasJob')
+                        .mockImplementation(function () { return Promise.reject(new logcheck_1.LogCheckFailure('1 error')); });
+                    command = new requestCommand_1.RequestCommand(__spreadArray(__spreadArray([], __read(defaultArgs), false), [
+                        'request',
+                        sasProgramPath
+                    ], false));
+                    _a = expect;
+                    return [4 /*yield*/, command.execute()];
+                case 1:
+                    _a.apply(void 0, [_b.sent()]).toEqual(command_1.ReturnCode.LogCheckError);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should switch the log check off for --no-logcheck', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var command;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    command = new requestCommand_1.RequestCommand(__spreadArray(__spreadArray([], __read(defaultArgs), false), [
+                        'request',
+                        sasProgramPath,
+                        '--no-logcheck'
+                    ], false));
+                    return [4 /*yield*/, command.execute()];
+                case 1:
+                    _a.sent();
+                    expect((0, logcheck_1.getLogCheckMode)()).toEqual('off');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('should parse sasjs request command', function () { return __awaiter(void 0, void 0, void 0, function () {
         var args, command, targetInfo;
         return __generator(this, function (_a) {

package/build/commands/run/run.d.ts

@@ -6,6 +6,4 @@ import { Target } from '@sasjs/utils';
  * @param {boolean} compile - compiles sas file present at 'filePath' before running code.
  * @param {string} logFile - (Optional) Path to log file.
  */
-export declare function runSasCode(target: Target, filePath: string, compile?: boolean, logFile?: string, source?: string): Promise<{
-    log: any;
-}>;
+export declare function runSasCode(target: Target, filePath: string, compile?: boolean, logFile?: string, source?: string): Promise<any>;

package/build/commands/run/run.js

@@ -74,6 +74,7 @@ var utils_2 = require("../../utils/");
 var axios_1 = __importDefault(require("axios"));
 var saveLog_1 = require("../../utils/saveLog");
 var parseSourceFile_1 = require("../../utils/parseSourceFile");
+var logcheck_1 = require("../../utils/logcheck");
 /**
  * Runs SAS code from a given file on the specified target.
  * @param {Target} target - the target to run the SAS code on.
@@ -83,7 +84,7 @@ var parseSourceFile_1 = require("../../utils/parseSourceFile");
  */
 function runSasCode(target_1, filePath_1) {
     return __awaiter(this, arguments, void 0, function (target, filePath, compile, logFile, source) {
-        var isTempFile, sasFilePath, sasFileContent, linesToExecute, macroVars, macroVarStatements, _a;
+        var isTempFile, sasFilePath, sasFileContent, linesToExecute, macroVars, macroVarStatements, result, _a;
         var _b;
         var _c;
         if (compile === void 0) { compile = false; }
@@ -137,12 +138,26 @@ function runSasCode(target_1, filePath_1) {
                     }
                     return [3 /*break*/, 17];
                 case 11: return [4 /*yield*/, executeOnSasViya(filePath, target, linesToExecute, logFile)];
-                case 12: return [2 /*return*/, _d.sent()];
+                case 12:
+                    result = _d.sent();
+                    return [3 /*break*/, 17];
                 case 13: return [4 /*yield*/, executeOnSas9(target, linesToExecute, logFile)];
-                case 14: return [2 /*return*/, _d.sent()];
+                case 14:
+                    result = _d.sent();
+                    return [3 /*break*/, 17];
                 case 15: return [4 /*yield*/, executeOnSasJS(filePath, target, linesToExecute, logFile)];
-                case 16: return [2 /*return*/, _d.sent()];
-                case 17: return [2 /*return*/];
+                case 16:
+                    result = _d.sent();
+                    _d.label = 17;
+                case 17: 
+                // Only a run that claims to have worked is worth checking: an executor that
+                // threw has already written the log it failed on, truncated at the failure.
+                return [4 /*yield*/, (0, logcheck_1.checkLog)(result === null || result === void 0 ? void 0 : result.log, path_1.default.basename(filePath))];
+                case 18:
+                    // Only a run that claims to have worked is worth checking: an executor that
+                    // threw has already written the log it failed on, truncated at the failure.
+                    _d.sent();
+                    return [2 /*return*/, result];
             }
         });
     });

package/build/commands/run/runCommand.js

@@ -55,6 +55,7 @@ exports.RunCommand = void 0;
 var command_1 = require("../../types/command");
 var targetCommand_1 = require("../../types/command/targetCommand");
 var utils_1 = require("../../utils");
+var logcheck_1 = require("../../utils/logcheck");
 var run_1 = require("./run");
 var syntax = 'run <sasFilePath> [options]';
 var usage = 'sasjs run <sasFilePath> --target <target-name>';
@@ -103,6 +104,11 @@ var RunCommand = /** @class */ (function (_super) {
                     type: 'string',
                     alias: 's',
                     description: 'Path to an input JSON containing job variables.'
+                },
+                logcheck: {
+                    type: 'boolean',
+                    default: undefined,
+                    description: 'Check the SAS log this command received, and fail when logCheck in sasjsconfig.json says so. --no-logcheck switches both the report and the verdict off.'
                 }
             },
             syntax: syntax,
@@ -120,11 +126,14 @@ var RunCommand = /** @class */ (function (_super) {
                     case 1:
                         target = (_b.sent()).target;
                         _a = this.parsed, sasFilePath = _a.sasFilePath, compile = _a.compile, log = _a.log, source = _a.source;
+                        (0, logcheck_1.setLogCheckMode)((0, logcheck_1.logCheckModeOf)(this.parsed.logcheck));
                         return [4 /*yield*/, (0, run_1.runSasCode)(target, sasFilePath, compile, log, source)
                                 .then(function () {
                                 return command_1.ReturnCode.Success;
                             })
                                 .catch(function (err) {
+                                if ((0, logcheck_1.isLogCheckFailure)(err))
+                                    return command_1.ReturnCode.LogCheckError;
                                 (0, utils_1.displayError)(err, 'An error has occurred when running your SAS code.');
                                 return command_1.ReturnCode.InternalError;
                             })];

package/build/commands/run/spec/runCommand.spec.js

@@ -100,6 +100,7 @@ var utils_1 = require("@sasjs/utils");
 var configUtils = __importStar(require("../../../utils/config"));
 var setConstantsUtils = __importStar(require("../../../utils/setConstants"));
 var command_1 = require("../../../types/command");
+var logcheck_1 = require("../../../utils/logcheck");
 var defaultArgs = ['node', 'sasjs', 'run'];
 var target = new utils_1.Target({
     name: 'test',
@@ -114,6 +115,55 @@ describe('RunCommand', function () {
     beforeEach(function () {
         setupMocks();
     });
+    afterEach(function () { return (0, logcheck_1.setLogCheckMode)('auto'); });
+    it('should return the logcheck code when the log check failed the run', 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(runModule, 'runSasCode')
+                        .mockImplementation(function () { return Promise.reject(new logcheck_1.LogCheckFailure('2 errors')); });
+                    command = new runCommand_1.RunCommand(__spreadArray(__spreadArray([], __read(defaultArgs), false), [sasFilePath], false));
+                    _a = expect;
+                    return [4 /*yield*/, command.execute()];
+                case 1:
+                    _a.apply(void 0, [_b.sent()]).toEqual(command_1.ReturnCode.LogCheckError);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should switch the log check off for --no-logcheck', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var command;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    command = new runCommand_1.RunCommand(__spreadArray(__spreadArray([], __read(defaultArgs), false), [
+                        sasFilePath,
+                        '--no-logcheck'
+                    ], false));
+                    return [4 /*yield*/, command.execute()];
+                case 1:
+                    _a.sent();
+                    expect((0, logcheck_1.getLogCheckMode)()).toEqual('off');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should switch the log check on for --logcheck', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var command;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    command = new runCommand_1.RunCommand(__spreadArray(__spreadArray([], __read(defaultArgs), false), [sasFilePath, '--logcheck'], false));
+                    return [4 /*yield*/, command.execute()];
+                case 1:
+                    _a.sent();
+                    expect((0, logcheck_1.getLogCheckMode)()).toEqual('on');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('should parse sasjs run command', function () { return __awaiter(void 0, void 0, void 0, function () {
         return __generator(this, function (_a) {
             switch (_a.label) {

package/build/utils/index.d.ts

@@ -3,6 +3,7 @@ export * from './config';
 export * from './displayResult';
 export * from './file';
 export * from './loadEnvVariables';
+export * from './logcheck';
 export * from './saveLog';
 export * from './setConstants';
 export * from './setProjectDir';

package/build/utils/index.js

@@ -19,6 +19,7 @@ __exportStar(require("./config"), exports);
 __exportStar(require("./displayResult"), exports);
 __exportStar(require("./file"), exports);
 __exportStar(require("./loadEnvVariables"), exports);
+__exportStar(require("./logcheck"), exports);
 __exportStar(require("./saveLog"), exports);
 __exportStar(require("./setConstants"), exports);
 __exportStar(require("./setProjectDir"), exports);

package/build/utils/logcheck.d.ts

@@ -0,0 +1,44 @@
+/**
+ * How the log a command just received is treated.
+ *
+ * `auto` decides from `logCheck.autoCheck` in the project config, which is off
+ * by default; `on` and `off` are the `--logcheck` / `--no-logcheck` flags. The
+ * distinction matters because the two halves of the behaviour are separate:
+ * reporting what SAS printed is always worth doing, while changing the exit
+ * code of a command whose status a pipeline already trusts is not something to
+ * do behind a project's back.
+ */
+export type LogCheckMode = 'auto' | 'on' | 'off';
+export declare const setLogCheckMode: (value: LogCheckMode) => void;
+export declare const getLogCheckMode: () => LogCheckMode;
+/** Reads a tri-state yargs boolean: absent is `undefined`, not `false`. */
+export declare const logCheckModeOf: (flag: unknown) => LogCheckMode;
+/**
+ * A run whose log broke the policy, once `autoCheck` or `--logcheck` asked for
+ * the verdict to count.
+ *
+ * It is an error rather than a return value because it is raised several
+ * frames below the command, from whichever executor received the log, and the
+ * command is the only place that can turn it into an exit code.
+ */
+export declare class LogCheckFailure extends Error {
+    /**
+     * Marker rather than `instanceof`: the CLI is compiled to a target where a
+     * subclass of a built-in loses its prototype chain, so `instanceof` answers
+     * false in the built artefact while answering true under the test transform.
+     * The flag is read by {@link isLogCheckFailure} and cannot be faked by an
+     * unrelated error.
+     */
+    readonly logCheckFailure = true;
+    constructor(message: string);
+}
+export declare const isLogCheckFailure: (error: unknown) => error is LogCheckFailure;
+/**
+ * Reports the issues in a log a command just received, and throws when the
+ * policy says the run should fail.
+ *
+ * Nothing is printed for a clean log: the commands this runs inside already
+ * 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>;