@appland/scanner 1.65.0 → 1.68.0

package/CHANGELOG.md

@@ -1,3 +1,41 @@
+# [@appland/scanner-v1.68.0](https://github.com/applandinc/appmap-js/compare/@appland/scanner-v1.67.0...@appland/scanner-v1.68.0) (2022-08-19)
+
+
+### Bug Fixes
+
+* Allow rule doc to be missing ([85a22fc](https://github.com/applandinc/appmap-js/commit/85a22fcaf777ab3794300d3ad52057be6ace4a87))
+
+
+### Features
+
+* Enhanced breakpoints ([b338bc9](https://github.com/applandinc/appmap-js/commit/b338bc9c1beebf3fbc78fb57bb72e4738c0ed5e6))
+* Interactive rule evaluator ([d0a0846](https://github.com/applandinc/appmap-js/commit/d0a08466ed0e92484a4c195c74cbb737a2cb40d6))
+
+# [@appland/scanner-v1.67.0](https://github.com/applandinc/appmap-js/compare/@appland/scanner-v1.66.0...@appland/scanner-v1.67.0) (2022-08-10)
+
+
+### Bug Fixes
+
+* Fix Options loading from dir-based rules ([f58ce49](https://github.com/applandinc/appmap-js/commit/f58ce49f22ba4d649e8886d76373cf23d6614b37))
+
+
+### Features
+
+* Ignore schema info tables in too-many-joins ([0cb387d](https://github.com/applandinc/appmap-js/commit/0cb387d74aa7e6edda5e24a88d07fa65b3900966))
+
+# [@appland/scanner-v1.66.0](https://github.com/applandinc/appmap-js/compare/@appland/scanner-v1.65.0...@appland/scanner-v1.66.0) (2022-08-08)
+
+
+### Bug Fixes
+
+* Fix rule doc ([b99b6ae](https://github.com/applandinc/appmap-js/commit/b99b6aec90186bef312d04fb4f4c95f9b1ee62d5))
+
+
+### Features
+
+* Add deprecated-crypto-algorithm to default rule set ([3034489](https://github.com/applandinc/appmap-js/commit/303448974a73637493a72bea7ab8cfb28ccc8b10))
+* Detect deprecated crypto algorithm ([a17a537](https://github.com/applandinc/appmap-js/commit/a17a537334771a9f2cd64fa73c2396e517ff82ea))
+
 # [@appland/scanner-v1.65.0](https://github.com/applandinc/appmap-js/compare/@appland/scanner-v1.64.0...@appland/scanner-v1.65.0) (2022-08-08)
 
 

package/built/cli/scan/breakpoint.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BreakOnCodeObject = exports.BreakOnLabel = exports.BreakOnEvent = exports.BreakOnCounter = void 0;
+class BreakOnCounter {
+    constructor(counter) {
+        this.counter = counter;
+    }
+    condition(context) {
+        return this.counter === context.counter;
+    }
+    toString() {
+        return `(${this.counter})`;
+    }
+}
+exports.BreakOnCounter = BreakOnCounter;
+class BreakOnEvent {
+    constructor(eventName) {
+        this.eventName = makeRegularExpression(eventName);
+    }
+    condition(context) {
+        return this.eventName.test(context.eventName);
+    }
+    toString() {
+        return this.eventName.toString();
+    }
+}
+exports.BreakOnEvent = BreakOnEvent;
+class BreakOnLabel {
+    constructor(label) {
+        this.label = makeRegularExpression(label);
+    }
+    condition(context) {
+        if (!context.event)
+            return false;
+        return !![...context.event.codeObject.labels].find((label) => this.label.test(label));
+    }
+    toString() {
+        return this.label.toString();
+    }
+}
+exports.BreakOnLabel = BreakOnLabel;
+class BreakOnCodeObject {
+    constructor(codeObject) {
+        this.codeObject = makeRegularExpression(codeObject);
+    }
+    condition(context) {
+        if (!context.event)
+            return false;
+        return this.codeObject.test(context.event.codeObject.fqid);
+    }
+    toString() {
+        return this.codeObject.toString();
+    }
+}
+exports.BreakOnCodeObject = BreakOnCodeObject;
+function escapeRegexp(expr) {
+    return new RegExp(expr.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&'));
+}
+function makeRegularExpression(expr) {
+    if (expr.length < 2)
+        return escapeRegexp(expr);
+    if (expr.startsWith('/') && expr.endsWith('/'))
+        return new RegExp(expr);
+    return escapeRegexp(expr);
+}

package/built/cli/scan/command.js

@@ -22,11 +22,16 @@ const singleScan_1 = __importDefault(require("./singleScan"));
 const watchScan_1 = __importDefault(require("./watchScan"));
 const configurationProvider_1 = require("../../configuration/configurationProvider");
 const handleWorkingDirectory_1 = require("../handleWorkingDirectory");
+const interactiveScan_1 = __importDefault(require("./interactiveScan"));
 exports.default = {
     command: 'scan',
     describe: 'Scan AppMaps for code behavior findings',
     builder(args) {
         (0, scanArgs_1.default)(args);
+        args.option('interactive', {
+            describe: 'scan in interactive mode',
+            alias: 'i',
+        });
         args.option('appmap-file', {
             describe: 'single file to scan, or repeat this option to scan multiple specific files',
             alias: 'f',
@@ -50,7 +55,7 @@ exports.default = {
     handler(options) {
         return __awaiter(this, void 0, void 0, function* () {
             let { appmapDir } = options;
-            const { appmapFile, config, directory, verbose: isVerbose, all: reportAllFindings, watch, app: appIdArg, apiKey, ide, reportFile, } = options;
+            const { appmapFile, directory, interactive, config: configFile, verbose: isVerbose, all: reportAllFindings, watch, app: appIdArg, apiKey, ide, reportFile, } = options;
             if (isVerbose) {
                 (0, util_1.verbose)(true);
             }
@@ -64,33 +69,38 @@ exports.default = {
             if (reportAllFindings && watch) {
                 throw new errors_1.ValidationError(`Don't use --all with --watch, because in watch mode all findings are reported`);
             }
-            if (appIdArg && watch) {
-                throw new errors_1.ValidationError(`Don't use --app with --watch, because in watch mode all findings are reported`);
-            }
             if (!appmapFile && !appmapDir) {
                 appmapDir = (yield (0, appmapDirFromConfig_1.appmapDirFromConfig)()) || '.';
             }
             if (appmapDir)
                 yield (0, validateFile_1.default)('directory', appmapDir);
+            let appId = appIdArg;
+            if (!reportAllFindings)
+                appId = yield (0, resolveAppId_1.default)(appIdArg, appmapDir);
             if (watch) {
                 const watchAppMapDir = appmapDir;
-                return (0, watchScan_1.default)({ appmapDir: watchAppMapDir, configFile: config });
+                return (0, watchScan_1.default)({ appId, appmapDir: watchAppMapDir, configFile });
             }
             else {
-                let appId = appIdArg;
-                if (!reportAllFindings) {
-                    appId = yield (0, resolveAppId_1.default)(appIdArg, appmapDir);
+                const configuration = yield (0, configurationProvider_1.parseConfigFile)(configFile);
+                if (interactive) {
+                    return (0, interactiveScan_1.default)({
+                        appmapFile,
+                        appmapDir,
+                        configuration,
+                    });
+                }
+                else {
+                    return (0, singleScan_1.default)({
+                        appmapFile,
+                        appmapDir,
+                        configuration,
+                        reportAllFindings,
+                        appId,
+                        ide,
+                        reportFile,
+                    });
                 }
-                const configData = yield (0, configurationProvider_1.parseConfigFile)(config);
-                return (0, singleScan_1.default)({
-                    appmapFile,
-                    appmapDir,
-                    configData,
-                    reportAllFindings,
-                    appId,
-                    ide,
-                    reportFile,
-                });
             }
         });
     },

package/built/cli/scan/interactiveScan.js

@@ -0,0 +1,34 @@
+"use strict";
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const configurationProvider_1 = require("../../configuration/configurationProvider");
+const util_1 = require("../../rules/lib/util");
+const validateFile_1 = __importDefault(require("../validateFile"));
+const scanContext_1 = __importDefault(require("./ui/scanContext"));
+const initial_1 = __importDefault(require("./ui/state/initial"));
+function interactiveScan(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { appmapFile, appmapDir, configuration } = options;
+        const checks = yield (0, configurationProvider_1.loadConfig)(configuration);
+        const files = yield (0, util_1.collectAppMapFiles)(appmapFile, appmapDir);
+        yield Promise.all(files.map((file) => __awaiter(this, void 0, void 0, function* () { return (0, validateFile_1.default)('file', file); })));
+        const context = new scanContext_1.default(checks, files);
+        let state = initial_1.default;
+        while (state) {
+            const newState = yield state(context);
+            state = newState;
+        }
+    });
+}
+exports.default = interactiveScan;

package/built/cli/scan/singleScan.js

@@ -12,10 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const util_1 = require("util");
 const promises_1 = require("fs/promises");
-const glob_1 = require("glob");
-const validateFile_1 = __importDefault(require("../validateFile"));
 const scanner_1 = __importDefault(require("./scanner"));
 const errors_1 = require("../../errors");
 const findings_1 = require("../../findings");
@@ -23,19 +20,14 @@ const findingsReport_1 = __importDefault(require("../../report/findingsReport"))
 const summaryReport_1 = __importDefault(require("../../report/summaryReport"));
 const formatReport_1 = require("./formatReport");
 const telemetry_1 = __importDefault(require("../../telemetry"));
+const util_1 = require("../../rules/lib/util");
+const validateFile_1 = __importDefault(require("../validateFile"));
 function singleScan(options) {
     return __awaiter(this, void 0, void 0, function* () {
-        const { appmapFile, appmapDir, configData, reportAllFindings, appId, ide, reportFile } = options;
-        let files = [];
-        if (appmapDir) {
-            const glob = (0, util_1.promisify)(glob_1.glob);
-            files = yield glob(`${appmapDir}/**/*.appmap.json`);
-        }
-        if (appmapFile) {
-            files = typeof appmapFile === 'string' ? [appmapFile] : appmapFile;
-            yield Promise.all(files.map((file) => __awaiter(this, void 0, void 0, function* () { return (0, validateFile_1.default)('file', file); })));
-        }
-        const scanner = yield (0, scanner_1.default)(reportAllFindings, configData, files).catch((error) => {
+        const { appmapFile, appmapDir, configuration, reportAllFindings, appId, ide, reportFile } = options;
+        const files = yield (0, util_1.collectAppMapFiles)(appmapFile, appmapDir);
+        yield Promise.all(files.map((file) => __awaiter(this, void 0, void 0, function* () { return (0, validateFile_1.default)('file', file); })));
+        const scanner = yield (0, scanner_1.default)(reportAllFindings, configuration, files).catch((error) => {
             throw new errors_1.ValidationError(error.message + '\nUse --all to perform an offline scan.');
         });
         const startTime = Date.now();

package/built/cli/scan/ui/interactiveProgess.js

@@ -0,0 +1,147 @@
+"use strict";
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = __importDefault(require("events"));
+class InteractiveProgress extends events_1.default {
+    constructor() {
+        super();
+        this.breakpoints = [];
+        this.depth = 0;
+        this.counter = 0;
+        this.initialize();
+    }
+    initialize() {
+        this.depth = 0;
+        this.counter = 0;
+    }
+    addBreakpoint(breakpoint) {
+        this.breakpoints.push(breakpoint);
+    }
+    removeBreakpoint(breakpoint) {
+        this.breakpoints = this.breakpoints.filter((b) => b !== breakpoint);
+    }
+    get prefix() {
+        const counterStr = `(${this.counter}) `;
+        return (counterStr + '  '.repeat(this.depth).padStart(10 + this.depth * 2 - counterStr.length, ' '));
+    }
+    resume() {
+        if (!this.breakpointResolver)
+            return;
+        this.breakpointResolver();
+        this.breakpointResolver = undefined;
+    }
+    breakOn(eventName, variables) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const context = Object.assign({ eventName, appMap: this.appMap, appMapFileName: this.appMapFileName, check: this.check, scope: this.scope, counter: this.counter, depth: this.depth }, variables);
+            const hitBreakpoint = this.breakpoints.find((b) => b.condition(context));
+            if (!hitBreakpoint)
+                return;
+            this.emit('breakpoint', hitBreakpoint, context);
+            return new Promise((resolve) => {
+                this.breakpointResolver = resolve;
+            });
+        });
+    }
+    beginAppMap(appMapFileName, appMap) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log(`${this.prefix}beginAppMap: ${appMapFileName}`);
+            this.depth += 1;
+            this.appMapFileName = appMapFileName;
+            this.appMap = appMap;
+            yield this.breakOn('beginAppMap', {});
+            this.counter += 1;
+        });
+    }
+    beginCheck(check) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log(`${this.prefix}beginCheck: ${check}`);
+            this.depth += 1;
+            this.check = check;
+            yield this.breakOn('beginCheck', {});
+            this.counter += 1;
+        });
+    }
+    filterScope(scopeName, scope) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log(`${this.prefix}filterScope: ${scopeName} ${scope}`);
+            yield this.breakOn('filterScope', {});
+            this.counter += 1;
+        });
+    }
+    enterScope(scope) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log(`${this.prefix}enterScope: ${scope}`);
+            this.depth += 1;
+            this.scope = scope;
+            yield this.breakOn('enterScope', {});
+            this.counter += 1;
+        });
+    }
+    filterEvent(event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log(`${this.prefix}filterEvent: ${event}`);
+            this.event = event;
+            yield this.breakOn('filterEvent', { event });
+            this.event = undefined;
+            this.counter += 1;
+        });
+    }
+    matchResult(event, matchResult) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log(`${this.prefix}matchResult: ${matchResult}`);
+            this.event = event;
+            yield this.breakOn('matchResult', { matchResult });
+            this.event = undefined;
+            this.counter += 1;
+        });
+    }
+    matchEvent(event, _appMapIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log(`${this.prefix}matchEvent: ${event}`);
+            this.event = event;
+            yield this.breakOn('matchEvent', {});
+            this.event = undefined;
+            this.counter += 1;
+        });
+    }
+    leaveScope() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.depth -= 1;
+            console.log(`${this.prefix}leaveScope`);
+            yield this.breakOn('leaveScope', {});
+            this.scope = undefined;
+            this.counter += 1;
+        });
+    }
+    endCheck() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.depth -= 1;
+            console.log(`${this.prefix}endCheck`);
+            yield this.breakOn('endCheck', {});
+            this.check = undefined;
+            this.counter += 1;
+        });
+    }
+    endAppMap() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.depth -= 1;
+            console.log(`${this.prefix}endAppMap`);
+            yield this.breakOn('endAppMap', {});
+            this.appMap = undefined;
+            this.appMapFileName = undefined;
+            this.counter += 1;
+        });
+    }
+}
+exports.default = InteractiveProgress;

package/built/cli/scan/ui/scanContext.js

@@ -0,0 +1,67 @@
+"use strict";
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const models_1 = require("@appland/models");
+const console_1 = require("console");
+const events_1 = __importDefault(require("events"));
+const promises_1 = require("fs/promises");
+const appMapIndex_1 = __importDefault(require("../../../appMapIndex"));
+const ruleChecker_1 = __importDefault(require("../../../ruleChecker"));
+const interactiveProgess_1 = __importDefault(require("./interactiveProgess"));
+class ScanContext extends events_1.default {
+    constructor(checks, files) {
+        super();
+        this.checks = checks;
+        this.files = files;
+        this.isScanning = false;
+        this.progress = new interactiveProgess_1.default();
+        this.checker = new ruleChecker_1.default(this.progress);
+        this.progress.on('breakpoint', (breakpoint) => {
+            this.emit('breakpoint', breakpoint);
+        });
+    }
+    scan() {
+        if (this.isScanning) {
+            this.progress.resume();
+        }
+        else {
+            this.progress.initialize();
+            this.doScan();
+        }
+    }
+    doScan() {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, console_1.assert)(!this.isScanning, 'Scanning already in progress');
+            this.isScanning = true;
+            const findings = [];
+            for (let fileIndex = 0; fileIndex < this.files.length; fileIndex++) {
+                const fileName = this.files[fileIndex];
+                const appMapData = yield (0, promises_1.readFile)(fileName, 'utf8');
+                const appMap = (0, models_1.buildAppMap)(appMapData).normalize().build();
+                const appMapIndex = new appMapIndex_1.default(appMap);
+                yield this.progress.beginAppMap(fileName, appMap);
+                for (let checkIndex = 0; checkIndex < this.checks.length; checkIndex++) {
+                    const check = this.checks[checkIndex];
+                    yield this.progress.beginCheck(check);
+                    yield this.checker.check(fileName, appMapIndex, check, findings);
+                    yield this.progress.endCheck();
+                }
+                yield this.progress.endAppMap();
+            }
+            this.isScanning = false;
+            this.emit('complete', findings);
+        });
+    }
+}
+exports.default = ScanContext;

package/built/cli/scan/ui/state/addBreakpoint.js

@@ -0,0 +1,120 @@
+"use strict";
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const readline_1 = require("readline");
+const breakpoint_1 = require("../../breakpoint");
+const userInteraction_1 = __importDefault(require("../userInteraction"));
+const scan_1 = __importDefault(require("./scan"));
+const history = [];
+function addBreakpoint(context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const onCounter = () => __awaiter(this, void 0, void 0, function* () {
+            const { sequenceNumber } = yield userInteraction_1.default.prompt({
+                name: 'sequenceNumber',
+                type: 'number',
+                message: 'Sequence number:',
+            });
+            return new breakpoint_1.BreakOnCounter(Number(sequenceNumber));
+        });
+        const onEventName = () => __awaiter(this, void 0, void 0, function* () {
+            const { eventName } = yield userInteraction_1.default.prompt({
+                name: 'eventName',
+                type: 'input',
+                message: 'Event name:',
+            });
+            return new breakpoint_1.BreakOnEvent(eventName);
+        });
+        const onLabel = () => __awaiter(this, void 0, void 0, function* () {
+            const { labelName } = yield userInteraction_1.default.prompt({
+                name: 'labelName',
+                type: 'input',
+                message: 'Event label:',
+            });
+            return new breakpoint_1.BreakOnLabel(labelName);
+        });
+        const onCodeObject = () => __awaiter(this, void 0, void 0, function* () {
+            let codeObjectName;
+            if (!context.progress.appMap) {
+                codeObjectName = (yield userInteraction_1.default.prompt({
+                    name: 'codeObjectName',
+                    type: 'input',
+                    message: 'Code object:',
+                }))['codeObjectName'];
+            }
+            else {
+                let codeObjectIds = [];
+                const collectCodeObjectNames = (codeObject) => {
+                    codeObjectIds.push(codeObject.fqid);
+                };
+                context.progress.appMap.classMap.visit(collectCodeObjectNames);
+                codeObjectIds = codeObjectIds.sort();
+                const codeObjectCompleter = (line) => {
+                    let options = codeObjectIds.filter((id) => id.startsWith(line));
+                    if (options.length === 0)
+                        options = codeObjectIds
+                            .filter((id) => id.includes(line))
+                            .map((id) => id.slice(id.indexOf(line)));
+                    return [options, line];
+                };
+                codeObjectName = yield new Promise((resolve, _reject) => {
+                    const rl = (0, readline_1.createInterface)({
+                        input: process.stdin,
+                        output: process.stdout,
+                        completer: codeObjectCompleter,
+                        history,
+                        historySize: 1000,
+                        removeHistoryDuplicates: true,
+                        prompt: 'Code object: ',
+                        tabSize: 4,
+                    });
+                    let response = '';
+                    rl.on('line', (data) => {
+                        response = data;
+                        rl.close();
+                    });
+                    rl.on('close', () => {
+                        resolve(response);
+                    });
+                    rl.prompt();
+                });
+            }
+            if (codeObjectName && codeObjectName !== '')
+                return new breakpoint_1.BreakOnCodeObject(codeObjectName);
+        });
+        const choices = {
+            'break at sequence number': onCounter,
+            'break on label': onLabel,
+            'break on code object': onCodeObject,
+            'break on event name': onEventName,
+            quit: null,
+        };
+        userInteraction_1.default.progress(`Choose a breakpoint type, and enter the criteria.`);
+        userInteraction_1.default.progress(`NOTE: label, code object, and event name breakpoints can be regular expressions.`);
+        userInteraction_1.default.progress(`      To enter a regular expression, use the syntax: /expr/`);
+        const { action: actionName } = yield userInteraction_1.default.prompt({
+            name: 'action',
+            type: 'list',
+            message: 'How would you like to proceed?:',
+            choices: Object.keys(choices),
+        });
+        const action = choices[actionName];
+        if (!action)
+            return scan_1.default;
+        const breakpoint = yield action();
+        if (breakpoint)
+            context.progress.addBreakpoint(breakpoint);
+        return scan_1.default;
+    });
+}
+exports.default = addBreakpoint;

package/built/cli/scan/ui/state/eval.js

@@ -0,0 +1,41 @@
+"use strict";
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/naming-convention */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const userInteraction_1 = __importDefault(require("../userInteraction"));
+const hitBreakpoint_1 = __importDefault(require("./hitBreakpoint"));
+const util_1 = require("util");
+function initial(context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { expression } = yield userInteraction_1.default.prompt({
+            name: 'expression',
+            type: 'input',
+            message: 'Enter expression:',
+        });
+        let result;
+        try {
+            result = ((check, appMap, scope, event) => {
+                return eval(expression);
+            })(context.progress.check, context.progress.appMap, context.progress.scope, context.progress.event);
+        }
+        catch (err) {
+            console.log(err);
+        }
+        if (result)
+            console.log((0, util_1.inspect)(result));
+        return hitBreakpoint_1.default;
+    });
+}
+exports.default = initial;

package/built/cli/scan/ui/state/hint.js

@@ -0,0 +1,23 @@
+"use strict";
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const userInteraction_1 = __importDefault(require("../userInteraction"));
+const hitBreakpoint_1 = __importDefault(require("./hitBreakpoint"));
+function hint(_context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        userInteraction_1.default.progress([`Some suggested expressions:`, 'appMap', 'check', 'event', 'scope'].join('\n'));
+        return hitBreakpoint_1.default;
+    });
+}
+exports.default = hint;