@memlab/cli 1.0.23 → 1.0.25

package/dist/lib/CLIUtils.js

@@ -0,0 +1,129 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.alignTextInBlock = exports.getBlankSpaceString = exports.argsToString = exports.filterAndGetUndefinedArgs = exports.READABLE_TEXT_WIDTH = exports.READABLE_CMD_FLAG_WIDTH = void 0;
+const string_width_1 = __importDefault(require("string-width"));
+const core_1 = require("@memlab/core");
+const OptionConstant_1 = __importDefault(require("../options/lib/OptionConstant"));
+const breakableSymbolOnRight = new Set([
+    ' ',
+    '\t',
+    ',',
+    '.',
+    ':',
+    ';',
+    '!',
+    '?',
+    ')',
+    ']',
+    '}',
+    '>',
+]);
+const breakableSymbolOnLeft = new Set([' ', '\t', '(', '[', '{', '<']);
+exports.READABLE_CMD_FLAG_WIDTH = 70;
+exports.READABLE_TEXT_WIDTH = 150;
+function filterAndGetUndefinedArgs(cliArgs) {
+    const ret = Object.create(null);
+    const memlabFBOptionNames = new Set(Object.values(Object.assign({}, OptionConstant_1.default.optionNames)));
+    for (const optionName of Object.keys(cliArgs)) {
+        if (optionName === '_') {
+            continue;
+        }
+        if (memlabFBOptionNames.has(optionName)) {
+            continue;
+        }
+        ret[optionName] = cliArgs[optionName];
+    }
+    return ret;
+}
+exports.filterAndGetUndefinedArgs = filterAndGetUndefinedArgs;
+function argsToString(args) {
+    let ret = '';
+    for (const optionName of Object.keys(args)) {
+        if (optionName === '_') {
+            continue;
+        }
+        const value = args[optionName];
+        if (value === true) {
+            ret += `--${optionName} `;
+        }
+        else if (Array.isArray(value)) {
+            value.forEach(v => {
+                ret += `--${optionName}=${v} `;
+            });
+        }
+        else {
+            ret += `--${optionName}=${value} `;
+        }
+    }
+    return ret.trim();
+}
+exports.argsToString = argsToString;
+function getBlankSpaceString(length) {
+    let ret = '';
+    for (let i = 0; i < length; ++i) {
+        ret += ' ';
+    }
+    return ret;
+}
+exports.getBlankSpaceString = getBlankSpaceString;
+function alignTextInBlock(text, options) {
+    var _a, _b;
+    const indent = (_a = options.leftIndent) !== null && _a !== void 0 ? _a : 0;
+    const maxLineWidth = Math.min(exports.READABLE_TEXT_WIDTH, (_b = options.lineLength) !== null && _b !== void 0 ? _b : process.stdout.columns);
+    if (indent < 0 || maxLineWidth <= 0 || indent >= maxLineWidth) {
+        throw core_1.utils.haltOrThrow('invalid indent or maximum line width');
+    }
+    const indentString = getBlankSpaceString(indent);
+    const inputLines = text.split('\n');
+    const outputLines = [];
+    while (inputLines.length > 0) {
+        const line = inputLines.shift();
+        // if the current line can fit in cmd row
+        if ((0, string_width_1.default)(indentString + line) <= maxLineWidth) {
+            outputLines.push(indentString + line);
+            continue;
+        }
+        // otherwise split the current line
+        const intendedSplitPoint = maxLineWidth - indent;
+        const splitLines = splitIntoReadableSubstrings(line, intendedSplitPoint);
+        const [firstLine, restLine] = splitLines;
+        outputLines.push(indentString + firstLine);
+        inputLines.unshift(restLine);
+    }
+    return outputLines.join('\n');
+}
+exports.alignTextInBlock = alignTextInBlock;
+function splitIntoReadableSubstrings(text, intendedSplitPoint) {
+    if (intendedSplitPoint >= text.length) {
+        return [text];
+    }
+    let splitPoint = intendedSplitPoint;
+    while (splitPoint > 0) {
+        const ch = text[splitPoint];
+        if (breakableSymbolOnLeft.has(ch)) {
+            break;
+        }
+        if (splitPoint - 1 > 0 &&
+            breakableSymbolOnRight.has(text[splitPoint - 1])) {
+            break;
+        }
+        --splitPoint;
+    }
+    if (splitPoint <= 0) {
+        splitPoint = intendedSplitPoint;
+    }
+    // if the second line starts with a ' ',
+    // skip the empty space
+    const firstLine = text.substring(0, splitPoint);
+    let secondLine = text.substring(splitPoint);
+    if (secondLine.startsWith(' ')) {
+        secondLine = secondLine.substring(1);
+    }
+    if (secondLine.length === 0) {
+        return [firstLine];
+    }
+    return [firstLine, secondLine];
+}

package/dist/options/MLClusteringOption.d.ts

@@ -13,6 +13,7 @@ import { BaseOption } from '@memlab/core';
 export default class MLClusteringOption extends BaseOption {
     getOptionName(): string;
     getDescription(): string;
+    static hasOptionSet(args: ParsedArgs): boolean;
     parse(config: MemLabConfig, args: ParsedArgs): Promise<void>;
 }
 //# sourceMappingURL=MLClusteringOption.d.ts.map

package/dist/options/MLClusteringOption.js

@@ -30,6 +30,10 @@ class MLClusteringOption extends core_1.BaseOption {
     getDescription() {
         return 'use machine learning algorithms for clustering leak traces (by default, traces are clustered by heuristics)';
     }
+    static hasOptionSet(args) {
+        const name = OptionConstant_1.default.optionNames.ML_CLUSTERING;
+        return args[name] != null;
+    }
     parse(config, args) {
         return __awaiter(this, void 0, void 0, function* () {
             const name = this.getOptionName();

package/dist/options/NumberOfRunsOption.d.ts

@@ -8,13 +8,15 @@
  * @oncall web_perf_infra
  */
 import type { ParsedArgs } from 'minimist';
-import type { AnyRecord, MemLabConfig } from '@memlab/core';
+import type { AnyRecord, MemLabConfig, Optional } from '@memlab/core';
 import { BaseOption } from '@memlab/core';
 export default class NumberOfRunsOption extends BaseOption {
-    static DEFAULT_NUM_RUNS: number;
+    private defaultRunNumber;
+    constructor(runNumber?: number);
     getOptionName(): string;
     getDescription(): string;
     getExampleValues(): string[];
+    static getParsedOption(configFromOptions: Optional<AnyRecord>): number;
     parse(config: MemLabConfig, args: ParsedArgs): Promise<AnyRecord>;
 }
 //# sourceMappingURL=NumberOfRunsOption.d.ts.map

package/dist/options/NumberOfRunsOption.js

@@ -23,7 +23,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@memlab/core");
 const OptionConstant_1 = __importDefault(require("./lib/OptionConstant"));
+const DEFAULT_NUM_RUNS = 10;
 class NumberOfRunsOption extends core_1.BaseOption {
+    constructor(runNumber = DEFAULT_NUM_RUNS) {
+        super();
+        this.defaultRunNumber = DEFAULT_NUM_RUNS;
+        this.defaultRunNumber = runNumber;
+    }
     getOptionName() {
         return OptionConstant_1.default.optionNames.RUN_NUM;
     }
@@ -33,16 +39,18 @@ class NumberOfRunsOption extends core_1.BaseOption {
     getExampleValues() {
         return ['5'];
     }
+    static getParsedOption(configFromOptions) {
+        const { numOfRuns } = configFromOptions !== null && configFromOptions !== void 0 ? configFromOptions : {};
+        const n = parseInt(`${numOfRuns}`, 10);
+        return isNaN(n) ? DEFAULT_NUM_RUNS : n;
+    }
     parse(config, args) {
         return __awaiter(this, void 0, void 0, function* () {
             const ret = Object.create(null);
             const name = this.getOptionName();
-            ret.numOfRuns = args[name]
-                ? args[name] | 0
-                : NumberOfRunsOption.DEFAULT_NUM_RUNS;
+            ret.numOfRuns = args[name] != null ? args[name] | 0 : this.defaultRunNumber;
             return ret;
         });
     }
 }
 exports.default = NumberOfRunsOption;
-NumberOfRunsOption.DEFAULT_NUM_RUNS = 10;

package/dist/options/SetMaxClusterSampleSizeOption.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @oncall web_perf_infra
+ */
+import type { ParsedArgs } from 'minimist';
+import type { MemLabConfig } from '@memlab/core';
+import { BaseOption } from '@memlab/core';
+export default class SetMaxClusterSampleSizeOption extends BaseOption {
+    getOptionName(): string;
+    getDescription(): string;
+    getExampleValues(): string[];
+    parse(config: MemLabConfig, args: ParsedArgs): Promise<void>;
+}
+//# sourceMappingURL=SetMaxClusterSampleSizeOption.d.ts.map

package/dist/options/SetMaxClusterSampleSizeOption.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @oncall web_perf_infra
+ */
+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 core_1 = require("@memlab/core");
+const OptionConstant_1 = __importDefault(require("./lib/OptionConstant"));
+class SetMaxClusterSampleSizeOption extends core_1.BaseOption {
+    getOptionName() {
+        return OptionConstant_1.default.optionNames.MAX_CLUSTER_SAMPLE_SIZE;
+    }
+    getDescription() {
+        return ('specify the max number of leak traces as input to leak trace ' +
+            'clustering algorithm. Big sample size will preserve more complete ' +
+            'inforrmation, but may risk out-of-memory crash.');
+    }
+    getExampleValues() {
+        return ['5000', '10000'];
+    }
+    parse(config, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (args[this.getOptionName()]) {
+                const sampleSize = parseInt(args[this.getOptionName()], 10);
+                if (!isNaN(sampleSize)) {
+                    config.maxSamplesForClustering = sampleSize;
+                }
+            }
+        });
+    }
+}
+exports.default = SetMaxClusterSampleSizeOption;

package/dist/options/e2e/SetChromiumBinaryOption.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @oncall web_perf_infra
+ */
+import type { ParsedArgs } from 'minimist';
+import { MemLabConfig } from '@memlab/core';
+import { BaseOption } from '@memlab/core';
+export default class SetChromiumBinaryOption extends BaseOption {
+    getOptionName(): string;
+    getDescription(): string;
+    parse(config: MemLabConfig, args: ParsedArgs): Promise<void>;
+}
+//# sourceMappingURL=SetChromiumBinaryOption.d.ts.map

package/dist/options/e2e/SetChromiumBinaryOption.js

@@ -0,0 +1,43 @@
+"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 path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const core_1 = require("@memlab/core");
+const OptionConstant_1 = __importDefault(require("../lib/OptionConstant"));
+class SetChromiumBinaryOption extends core_1.BaseOption {
+    getOptionName() {
+        return OptionConstant_1.default.optionNames.CHROMIUM_BINARY;
+    }
+    getDescription() {
+        return 'set the chromium binary for E2E run';
+    }
+    parse(config, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const name = this.getOptionName();
+            const arg = args[name];
+            if (arg) {
+                const binaryPath = path_1.default.resolve(process.cwd(), arg);
+                if (!fs_1.default.existsSync(binaryPath)) {
+                    throw core_1.utils.haltOrThrow(`Chromium binary does not exist: ${binaryPath}`);
+                }
+                if (config.verbose) {
+                    core_1.info.lowLevel(`Using ${binaryPath} as Chromium binary for E2E run`);
+                }
+                config.puppeteerConfig.executablePath = binaryPath;
+            }
+        });
+    }
+}
+exports.default = SetChromiumBinaryOption;

package/dist/options/experiment/SetControlWorkDirOption.d.ts

@@ -8,13 +8,14 @@
  * @oncall web_perf_infra
  */
 import type { ParsedArgs } from 'minimist';
-import type { MemLabConfig } from '@memlab/core';
+import type { MemLabConfig, Nullable } from '@memlab/core';
 import { BaseOption } from '@memlab/core';
 export default class SetControlWorkDirOption extends BaseOption {
     getOptionName(): string;
     getDescription(): string;
+    protected extractAndCheckWorkDirs(args: ParsedArgs): Nullable<string[]>;
     parse(config: MemLabConfig, args: ParsedArgs): Promise<{
-        controlWorkDir?: string;
+        controlWorkDirs?: Nullable<string[]>;
     }>;
 }
 //# sourceMappingURL=SetControlWorkDirOption.d.ts.map

package/dist/options/experiment/SetControlWorkDirOption.js

@@ -21,6 +21,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
 const core_1 = require("@memlab/core");
 const OptionConstant_1 = __importDefault(require("../lib/OptionConstant"));
 class SetControlWorkDirOption extends core_1.BaseOption {
@@ -30,14 +31,32 @@ class SetControlWorkDirOption extends core_1.BaseOption {
     getDescription() {
         return 'set the working directory of the control run';
     }
+    extractAndCheckWorkDirs(args) {
+        let dirs = [];
+        const name = this.getOptionName();
+        const flagValue = args[name];
+        if (!flagValue) {
+            return null;
+        }
+        if (Array.isArray(flagValue)) {
+            dirs = flagValue;
+        }
+        else {
+            dirs = [flagValue];
+        }
+        for (const dir of dirs) {
+            if (fs_1.default.existsSync(dir)) {
+                core_1.fileManager.createDefaultVisitOrderMetaFile({
+                    workDir: dir,
+                });
+            }
+        }
+        return dirs;
+    }
     parse(config, args) {
         return __awaiter(this, void 0, void 0, function* () {
-            const name = this.getOptionName();
-            const ret = {};
-            if (args[name]) {
-                ret.controlWorkDir = args[name];
-            }
-            return ret;
+            const dirs = this.extractAndCheckWorkDirs(args);
+            return { controlWorkDirs: dirs };
         });
     }
 }

package/dist/options/experiment/SetTreatmentWorkDirOption.js

@@ -21,6 +21,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
 const core_1 = require("@memlab/core");
 const OptionConstant_1 = __importDefault(require("../lib/OptionConstant"));
 class SetTreatmentWorkDirOption extends core_1.BaseOption {
@@ -36,6 +37,11 @@ class SetTreatmentWorkDirOption extends core_1.BaseOption {
             const ret = {};
             if (args[name]) {
                 ret.treatmentWorkDir = args[name];
+                if (fs_1.default.existsSync(ret.treatmentWorkDir)) {
+                    core_1.fileManager.createDefaultVisitOrderMetaFile({
+                        workDir: ret.treatmentWorkDir,
+                    });
+                }
             }
             return ret;
         });

package/dist/options/heap/SetTraceContainsFilterOption.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @oncall web_perf_infra
+ */
+import type { ParsedArgs } from 'minimist';
+import type { MemLabConfig } from '@memlab/core';
+import { BaseOption } from '@memlab/core';
+export default class SetTraceContainsFilterOption extends BaseOption {
+    getOptionName(): string;
+    getDescription(): string;
+    parse(config: MemLabConfig, args: ParsedArgs): Promise<void>;
+}
+//# sourceMappingURL=SetTraceContainsFilterOption.d.ts.map

package/dist/options/heap/SetTraceContainsFilterOption.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @oncall web_perf_infra
+ */
+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 core_1 = require("@memlab/core");
+const OptionConstant_1 = __importDefault(require("../lib/OptionConstant"));
+class SetTraceContainsFilterOption extends core_1.BaseOption {
+    getOptionName() {
+        return OptionConstant_1.default.optionNames.TRACE_CONTAINS;
+    }
+    getDescription() {
+        return 'set the node name or edge name to filter leak traces that contain the name';
+    }
+    parse(config, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const filterName = args[this.getOptionName()];
+            if (filterName != null) {
+                config.filterTraceByName = filterName;
+            }
+        });
+    }
+}
+exports.default = SetTraceContainsFilterOption;

package/dist/options/heap/TraceAllObjectsOption.d.ts

@@ -8,11 +8,13 @@
  * @oncall web_perf_infra
  */
 import type { ParsedArgs } from 'minimist';
-import type { MemLabConfig } from '@memlab/core';
-import { BaseOption } from '@memlab/core';
+import { MemLabConfig } from '@memlab/core';
+import { BaseOption, TraceObjectMode } from '@memlab/core';
 export default class TraceAllObjectsOption extends BaseOption {
     getOptionName(): string;
     getDescription(): string;
+    getAvailableOptions(): Array<string>;
+    getMode(optionValue: string): TraceObjectMode;
     parse(config: MemLabConfig, args: ParsedArgs): Promise<void>;
 }
 //# sourceMappingURL=TraceAllObjectsOption.d.ts.map

package/dist/options/heap/TraceAllObjectsOption.js

@@ -22,20 +22,48 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@memlab/core");
+const core_2 = require("@memlab/core");
 const OptionConstant_1 = __importDefault(require("../lib/OptionConstant"));
-class TraceAllObjectsOption extends core_1.BaseOption {
+const OversizeThresholdOption_1 = __importDefault(require("./OversizeThresholdOption"));
+const optionMapping = new Map([
+    ['selected-js-objects', core_2.TraceObjectMode.SelectedJSObjects],
+    ['default', core_2.TraceObjectMode.Default],
+]);
+class TraceAllObjectsOption extends core_2.BaseOption {
     getOptionName() {
         return OptionConstant_1.default.optionNames.TRACE_ALL_OBJECTS;
     }
     getDescription() {
-        return 'dump retainer trace for all allocated objects (ignore the leak filter)';
+        return ('dump retainer trace for all allocated objects (ignore the leak filter), ' +
+            `available option modes: ${this.getAvailableOptions().join(', ')}`);
+    }
+    getAvailableOptions() {
+        return Array.from(optionMapping.keys()).map(mode => `--${this.getOptionName()}=${mode}`);
+    }
+    getMode(optionValue) {
+        // if the user specified an option value (--flag=value instead of --flag)
+        if (typeof optionValue === 'boolean') {
+            return optionMapping.get('default');
+        }
+        if (!optionMapping.has(optionValue)) {
+            throw core_1.utils.haltOrThrow(`Unknown option value ${optionValue}. ` +
+                `Available options: ${this.getAvailableOptions().join(', ')}`);
+        }
+        return optionMapping.get(optionValue);
     }
     parse(config, args) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (args[this.getOptionName()]) {
-                config.oversizeObjectAsLeak = true;
+            const optionValue = args[this.getOptionName()];
+            if (optionValue == null) {
+                return;
+            }
+            config.oversizeObjectAsLeak = true;
+            const overSizeOptionName = new OversizeThresholdOption_1.default().getOptionName();
+            // oversize option will set the oversize threshold
+            if (!args[overSizeOptionName]) {
                 config.oversizeThreshold = 0;
             }
+            config.traceAllObjectsMode = this.getMode(optionValue);
         });
     }
 }

package/dist/options/lib/OptionConstant.d.ts

@@ -14,6 +14,7 @@ declare const optionConstants: {
         CLEAN_UP_SNAPSHOT: string;
         CONTINUS_TEST: string;
         CONTROL_WORK_DIR: string;
+        CHROMIUM_BINARY: string;
         DEVICE: string;
         DISABLE_WEB_SECURITY: string;
         DISABLE_XVFB: string;
@@ -27,6 +28,7 @@ declare const optionConstants: {
         LEAK_FILTER: string;
         LOCAL_PUPPETEER: string;
         LOG_SCRIPT: string;
+        MAX_CLUSTER_SAMPLE_SIZE: string;
         ML_CLUSTERING: string;
         ML_CLUSTERING_MAX_DF: string;
         ML_LINKAGE_MAX_DIST: string;
@@ -49,6 +51,7 @@ declare const optionConstants: {
         SNAPSHOT_DIR: string;
         TARGET: string;
         TRACE_ALL_OBJECTS: string;
+        TRACE_CONTAINS: string;
         TRACE_OBJECT_SIZE_ABOVE: string;
         TREATMENT_WORK_DIR: string;
         USER_AGENT: string;
@@ -71,6 +74,7 @@ declare const _default: {
         CLEAN_UP_SNAPSHOT: string;
         CONTINUS_TEST: string;
         CONTROL_WORK_DIR: string;
+        CHROMIUM_BINARY: string;
         DEVICE: string;
         DISABLE_WEB_SECURITY: string;
         DISABLE_XVFB: string;
@@ -84,6 +88,7 @@ declare const _default: {
         LEAK_FILTER: string;
         LOCAL_PUPPETEER: string;
         LOG_SCRIPT: string;
+        MAX_CLUSTER_SAMPLE_SIZE: string;
         ML_CLUSTERING: string;
         ML_CLUSTERING_MAX_DF: string;
         ML_LINKAGE_MAX_DIST: string;
@@ -106,6 +111,7 @@ declare const _default: {
         SNAPSHOT_DIR: string;
         TARGET: string;
         TRACE_ALL_OBJECTS: string;
+        TRACE_CONTAINS: string;
         TRACE_OBJECT_SIZE_ABOVE: string;
         TREATMENT_WORK_DIR: string;
         USER_AGENT: string;

package/dist/options/lib/OptionConstant.js

@@ -16,6 +16,7 @@ const optionNames = {
     CLEAN_UP_SNAPSHOT: 'clean-up-snapshot',
     CONTINUS_TEST: 'ContinuousTest',
     CONTROL_WORK_DIR: 'control-work-dir',
+    CHROMIUM_BINARY: 'chromium-binary',
     DEVICE: 'device',
     DISABLE_WEB_SECURITY: 'disable-web-security',
     DISABLE_XVFB: 'disable-xvfb',
@@ -29,6 +30,7 @@ const optionNames = {
     LEAK_FILTER: 'leak-filter',
     LOCAL_PUPPETEER: 'local-puppeteer',
     LOG_SCRIPT: 'log-script',
+    MAX_CLUSTER_SAMPLE_SIZE: 'max-cluster-sample-size',
     ML_CLUSTERING: 'ml-clustering',
     ML_CLUSTERING_MAX_DF: 'ml-clustering-max-df',
     ML_LINKAGE_MAX_DIST: 'ml-linkage-max-dist',
@@ -51,6 +53,7 @@ const optionNames = {
     SNAPSHOT_DIR: 'snapshot-dir',
     TARGET: 'target',
     TRACE_ALL_OBJECTS: 'trace-all-objects',
+    TRACE_CONTAINS: 'trace-contains',
     TRACE_OBJECT_SIZE_ABOVE: 'trace-object-size-above',
     TREATMENT_WORK_DIR: 'treatment-work-dir',
     USER_AGENT: 'user-agent',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memlab/cli",
-  "version": "1.0.23",
+  "version": "1.0.25",
   "license": "MIT",
   "description": "command line interface for memlab",
   "author": "Liang Gong <lgong@fb.com>",