@memlab/cli 1.0.24 → 1.0.25

package/dist/BaseCommand.d.ts

@@ -7,7 +7,7 @@
  * @format
  * @oncall web_perf_infra
  */
-import type { CLIOptions, Nullable } from '@memlab/core';
+import type { CLIOptions, CommandOptionExample, Nullable, Optional } from '@memlab/core';
 import { BaseOption } from '@memlab/core';
 export declare enum CommandCategory {
     COMMON = "COMMON",
@@ -24,7 +24,7 @@ declare abstract class Command {
 }
 export default class BaseCommand extends Command {
     getCommandName(): string;
-    getExamples(): string[];
+    getExamples(): CommandOptionExample[];
     getCategory(): CommandCategory;
     getDescription(): string;
     getDocumenation(): string;
@@ -32,7 +32,7 @@ export default class BaseCommand extends Command {
     isInternalCommand(): boolean;
     getOptions(): BaseOption[];
     getExcludedOptions(): BaseOption[];
-    getSubCommands(): BaseCommand[];
+    getSubCommands(): Optional<BaseCommand[]>;
     run(_options: CLIOptions): Promise<void>;
 }
 export {};

package/dist/BaseCommand.js

@@ -85,7 +85,7 @@ class BaseCommand extends Command {
         const className = this.constructor.name;
         throw new Error(`${className}.getCommandName is not implemented`);
     }
-    // get a list of examples
+    // get a list of CLI option examples
     // examples will be displayed in helper text
     getExamples() {
         return [];
@@ -131,6 +131,10 @@ class BaseCommand extends Command {
     // for example command 'A' has two sub-commands 'B' and 'C'
     // CLI supports running in terminal: `memlab A B` or `memlab A C`
     // The parent command will be executed before its subcommands
+    //
+    // If this callback returns null or undefined, it means
+    // the command will handle the dispatcher won't try to match and process
+    // the subcommands (the command will handle sub-commands by itself).
     getSubCommands() {
         return [];
     }

package/dist/Dispatcher.js

@@ -107,6 +107,8 @@ class CommandDispatcher {
             const { configFromOptions } = runCmdOpt;
             // execute command
             yield command.run({ cliArgs: args, configFromOptions });
+            // recommand CLI command and flags
+            core_1.config.setRunInfo('command', process.argv.slice(2).join(' '));
             if (runCmdOpt.isPrerequisite !== true) {
                 // execute subcommands
                 const commandIndex = ((_a = runCmdOpt.commandIndex) !== null && _a !== void 0 ? _a : 0) + 1;
@@ -125,6 +127,10 @@ class CommandDispatcher {
                 return;
             }
             const subCommands = command.getSubCommands();
+            // if the command will handle the sub-commands by itself
+            if (subCommands == null) {
+                return;
+            }
             for (const subCommand of subCommands) {
                 if (subCommand.getCommandName() === args._[subCommandIndex]) {
                     yield this.runCommand(subCommand, args, runCmdOpt);

package/dist/commands/MemLabRunCommand.d.ts

@@ -7,12 +7,12 @@
  * @format
  * @oncall web_perf_infra
  */
-import type { BaseOption, CLIOptions } from '@memlab/core';
+import type { BaseOption, CLIOptions, CommandOptionExample } from '@memlab/core';
 import BaseCommand, { CommandCategory } from '../BaseCommand';
 export default class MemLabRunCommand extends BaseCommand {
     getCommandName(): string;
     getDescription(): string;
-    getExamples(): string[];
+    getExamples(): CommandOptionExample[];
     getPrerequisites(): BaseCommand[];
     getOptions(): BaseOption[];
     getExcludedOptions(): BaseOption[];

package/dist/commands/RunMeasureCommand.d.ts

@@ -7,14 +7,14 @@
  * @format
  * @oncall web_perf_infra
  */
-import type { CLIOptions } from '@memlab/core';
+import type { CLIOptions, CommandOptionExample } from '@memlab/core';
 import BaseCommand from '../BaseCommand';
 import { BaseOption } from '@memlab/core';
 export default class RunMeasureCommand extends BaseCommand {
     getCommandName(): string;
     getDescription(): string;
     getPrerequisites(): BaseCommand[];
-    getExamples(): string[];
+    getExamples(): CommandOptionExample[];
     getOptions(): BaseOption[];
     run(options: CLIOptions): Promise<void>;
 }

package/dist/commands/RunMeasureCommand.js

@@ -45,6 +45,7 @@ const HeadfulBrowserOption_1 = __importDefault(require("../options/e2e/HeadfulBr
 const DisableWebSecurityOption_1 = __importDefault(require("../options/e2e/DisableWebSecurityOption"));
 const EnableJSRewriteOption_1 = __importDefault(require("../options/e2e/EnableJSRewriteOption"));
 const EnableJSInterceptOption_1 = __importDefault(require("../options/e2e/EnableJSInterceptOption"));
+const SetChromiumBinaryOption_1 = __importDefault(require("../options/e2e/SetChromiumBinaryOption"));
 class RunMeasureCommand extends BaseCommand_1.default {
     getCommandName() {
         return 'measure';
@@ -77,6 +78,7 @@ class RunMeasureCommand extends BaseCommand_1.default {
             new RunningModeOption_1.default(),
             new RemoteBrowserDebugOption_1.default(),
             new ScenarioFileOption_1.default(),
+            new SetChromiumBinaryOption_1.default(),
             new SetDeviceOption_1.default(),
             new SetUserAgentOption_1.default(),
             new DisableXvfbOption_1.default(),

package/dist/commands/WarmupAppCommand.d.ts

@@ -7,14 +7,14 @@
  * @format
  * @oncall web_perf_infra
  */
-import type { CLIOptions } from '@memlab/core';
+import type { CLIOptions, CommandOptionExample } from '@memlab/core';
 import { BaseOption } from '@memlab/core';
 import BaseCommand from '../BaseCommand';
 export default class FBWarmupAppCommand extends BaseCommand {
     getCommandName(): string;
     getDescription(): string;
     getPrerequisites(): BaseCommand[];
-    getExamples(): string[];
+    getExamples(): CommandOptionExample[];
     getOptions(): BaseOption[];
     run(_options: CLIOptions): Promise<void>;
 }

package/dist/commands/WarmupAppCommand.js

@@ -38,6 +38,7 @@ const HeadfulBrowserOption_1 = __importDefault(require("../options/e2e/HeadfulBr
 const DisableWebSecurityOption_1 = __importDefault(require("../options/e2e/DisableWebSecurityOption"));
 const EnableJSRewriteOption_1 = __importDefault(require("../options/e2e/EnableJSRewriteOption"));
 const EnableJSInterceptOption_1 = __importDefault(require("../options/e2e/EnableJSInterceptOption"));
+const SetChromiumBinaryOption_1 = __importDefault(require("../options/e2e/SetChromiumBinaryOption"));
 class FBWarmupAppCommand extends BaseCommand_1.default {
     getCommandName() {
         return 'warmup';
@@ -62,6 +63,7 @@ class FBWarmupAppCommand extends BaseCommand_1.default {
             new RunningModeOption_1.default(),
             new RemoteBrowserDebugOption_1.default(),
             new ScenarioFileOption_1.default(),
+            new SetChromiumBinaryOption_1.default(),
             new SetDeviceOption_1.default(),
             new SetUserAgentOption_1.default(),
             new DisableXvfbOption_1.default(),

package/dist/commands/heap/CheckLeakCommand.d.ts

@@ -8,7 +8,7 @@
  * @oncall web_perf_infra
  */
 import type { ParsedArgs } from 'minimist';
-import type { BaseOption, CLIOptions } from '@memlab/core';
+import type { BaseOption, CLIOptions, CommandOptionExample } from '@memlab/core';
 import BaseCommand, { CommandCategory } from '../../BaseCommand';
 export declare type CheckLeakCommandOptions = {
     isMLClustering?: boolean;
@@ -20,6 +20,7 @@ export default class CheckLeakCommand extends BaseCommand {
     protected restoreDefaultMLClusteringSetting(cliArgs: ParsedArgs): void;
     constructor(options?: CheckLeakCommandOptions);
     getCommandName(): string;
+    getExamples(): CommandOptionExample[];
     getDescription(): string;
     getDocumenation(): string;
     getCategory(): CommandCategory;

package/dist/commands/heap/CheckLeakCommand.js

@@ -54,6 +54,7 @@ const MLClusteringLinkageMaxDistanceOption_1 = __importDefault(require("../../op
 const MLClusteringMaxDFOption_1 = __importDefault(require("../../options/MLClusteringMaxDFOption"));
 const CleanupSnapshotOption_1 = __importDefault(require("../../options/heap/CleanupSnapshotOption"));
 const SetWorkingDirectoryOption_1 = __importDefault(require("../../options/SetWorkingDirectoryOption"));
+const OptionConstant_1 = __importDefault(require("../../options/lib/OptionConstant"));
 class CheckLeakCommand extends BaseCommand_1.default {
     constructor(options = {}) {
         super();
@@ -75,16 +76,54 @@ class CheckLeakCommand extends BaseCommand_1.default {
     getCommandName() {
         return 'find-leaks';
     }
+    getExamples() {
+        const optionNames = OptionConstant_1.default.optionNames;
+        const workDirOption = `--${optionNames.WORK_DIR}`;
+        const snapshotDirOption = `--${optionNames.SNAPSHOT_DIR}`;
+        const baselineOption = `--${optionNames.BASELINE}`;
+        const targetOption = `--${optionNames.TARGET}`;
+        const finalOption = `--${optionNames.FINAL}`;
+        return [
+            {
+                description: 'check memory leaks in the default working directory generated by\n' +
+                    `memlab run (without setting the ${workDirOption} option)`,
+                cliOptionExample: '', // default empty command options
+            },
+            {
+                description: 'specify the baseline, target, and final heap snapshot file path separately',
+                cliOptionExample: `${baselineOption} /tmp/baseline.heapsnapshot ${targetOption} /tmp/target.heapsnapshot ${finalOption} /tmp/final.heapsnapshot`,
+            },
+            {
+                description: 'specifies the directory that holds all three heap snapshot files',
+                cliOptionExample: `${snapshotDirOption} /dir/containing/heapsnapshot/files/`,
+            },
+            {
+                description: 'specifies the output working directory of the `memlab run` or the `memlab snapshot` command',
+                cliOptionExample: `${workDirOption} /memlab/working/dir/generated/by/memlab/`,
+            },
+        ];
+    }
     getDescription() {
         return 'find memory leaks in heap snapshots';
     }
     getDocumenation() {
-        return `There are three ways to specify inputs for the \`memlab find-leaks\` command:
- 1. \`--baseline\`, \`--target\`, \`--final\` specifies each snapshot input individually;
- 2. \`--snapshot-dir\` specifies the directory that holds all three heap snapshot files (MemLab will assign baseline, target, and final based on alphabetic order of the file);
- 3. \`--work-dir\` specifies the output working directory of the \`memlab run\` or the \`memlab snapshot\` command;
+        const optionNames = OptionConstant_1.default.optionNames;
+        const workDirOption = `--${optionNames.WORK_DIR}`;
+        const snapshotDirOption = `--${optionNames.SNAPSHOT_DIR}`;
+        const baselineOption = `--${optionNames.BASELINE}`;
+        const targetOption = `--${optionNames.TARGET}`;
+        const finalOption = `--${optionNames.FINAL}`;
+        return `There are three ways to specify inputs for the \`memlab ${this.getCommandName()}\` command:
+ 1. \`${baselineOption}\`, \`${targetOption}\`, \`${finalOption}\` specifies each heap snapshot input individually;
+ 2. \`${snapshotDirOption}\` specifies the directory that holds all three heap snapshot files (MemLab will assign baseline, target, and final based on alphabetic order of the file);
+ 3. \`${workDirOption}\` specifies the output working directory of the \`memlab run\` or the \`memlab snapshot\` command;
+
+Please only use one of the three ways to specify the input.
 
-Please only use one of the three ways to specify the input.`;
+You can also manually take heap snapshots in Chrome Devtools, save them to disk.
+Then process them using this command with the CLI flags (either option 1
+or option 2 mentioned above).
+`;
     }
     getCategory() {
         return BaseCommand_1.CommandCategory.COMMON;

package/dist/commands/heap/DiffLeakCommand.d.ts

@@ -7,14 +7,26 @@
  * @format
  * @oncall web_perf_infra
  */
-import type { BaseOption, CLIOptions } from '@memlab/core';
+import type { ParsedArgs } from 'minimist';
+import { BaseOption, CLIOptions } from '@memlab/core';
+import type { CheckLeakCommandOptions } from './CheckLeakCommand';
 import BaseCommand, { CommandCategory } from '../../BaseCommand';
+export declare type WorkDirSettings = {
+    controlWorkDirs: Array<string>;
+    treatmentWorkDir: string;
+};
 export default class CheckLeakCommand extends BaseCommand {
+    private isMLClustering;
+    private isMLClusteringSettingCache;
+    protected useDefaultMLClusteringSetting(cliArgs: ParsedArgs): void;
+    protected restoreDefaultMLClusteringSetting(cliArgs: ParsedArgs): void;
+    constructor(options?: CheckLeakCommandOptions);
     getCommandName(): string;
     getDescription(): string;
     getCategory(): CommandCategory;
     getPrerequisites(): BaseCommand[];
     getOptions(): BaseOption[];
+    protected getWorkDirs(options: CLIOptions): WorkDirSettings;
     run(options: CLIOptions): Promise<void>;
 }
 //# sourceMappingURL=DiffLeakCommand.d.ts.map

package/dist/commands/heap/DiffLeakCommand.js

@@ -50,7 +50,26 @@ const MLClusteringLinkageMaxDistanceOption_1 = __importDefault(require("../../op
 const MLClusteringMaxDFOption_1 = __importDefault(require("../../options/MLClusteringMaxDFOption"));
 const SetControlWorkDirOption_1 = __importDefault(require("../../options/experiment/SetControlWorkDirOption"));
 const SetTreatmentWorkDirOption_1 = __importDefault(require("../../options/experiment/SetTreatmentWorkDirOption"));
+const SetMaxClusterSampleSizeOption_1 = __importDefault(require("../../options/SetMaxClusterSampleSizeOption"));
+const SetTraceContainsFilterOption_1 = __importDefault(require("../../options/heap/SetTraceContainsFilterOption"));
 class CheckLeakCommand extends BaseCommand_1.default {
+    constructor(options = {}) {
+        super();
+        this.isMLClustering = false;
+        this.isMLClusteringSettingCache = false;
+        this.isMLClustering = !!(options === null || options === void 0 ? void 0 : options.isMLClustering);
+    }
+    useDefaultMLClusteringSetting(cliArgs) {
+        if (!MLClusteringOption_1.default.hasOptionSet(cliArgs)) {
+            core_1.config.isMLClustering = this.isMLClustering;
+            this.isMLClusteringSettingCache = core_1.config.isMLClustering;
+        }
+    }
+    restoreDefaultMLClusteringSetting(cliArgs) {
+        if (!MLClusteringOption_1.default.hasOptionSet(cliArgs)) {
+            core_1.config.isMLClustering = this.isMLClusteringSettingCache;
+        }
+    }
     getCommandName() {
         return 'diff-leaks';
     }
@@ -65,8 +84,8 @@ class CheckLeakCommand extends BaseCommand_1.default {
     }
     getOptions() {
         return [
-            new SetControlWorkDirOption_1.default().required(),
-            new SetTreatmentWorkDirOption_1.default().required(),
+            new SetControlWorkDirOption_1.default(),
+            new SetTreatmentWorkDirOption_1.default(),
             new JSEngineOption_1.default(),
             new LeakFilterFileOption_1.default(),
             new OversizeThresholdOption_1.default(),
@@ -76,28 +95,39 @@ class CheckLeakCommand extends BaseCommand_1.default {
             new MLClusteringOption_1.default(),
             new MLClusteringLinkageMaxDistanceOption_1.default(),
             new MLClusteringMaxDFOption_1.default(),
+            new SetMaxClusterSampleSizeOption_1.default(),
+            new SetTraceContainsFilterOption_1.default(),
         ];
     }
-    run(options) {
+    getWorkDirs(options) {
         var _a, _b;
+        // double check parameters
+        if (!((_a = options.configFromOptions) === null || _a === void 0 ? void 0 : _a.controlWorkDirs) ||
+            !((_b = options.configFromOptions) === null || _b === void 0 ? void 0 : _b.treatmentWorkDir)) {
+            core_1.info.error('Please specify control and test working directory');
+            throw core_1.utils.haltOrThrow('No control or test working directory specified');
+        }
+        // get parameters
+        const controlWorkDirs = options.configFromOptions['controlWorkDirs'];
+        const treatmentWorkDir = options.configFromOptions['treatmentWorkDir'];
+        return {
+            controlWorkDirs,
+            treatmentWorkDir,
+        };
+    }
+    run(options) {
         return __awaiter(this, void 0, void 0, function* () {
             core_1.config.chaseWeakMapEdge = false;
-            // double check parameters
-            if (!((_a = options.configFromOptions) === null || _a === void 0 ? void 0 : _a.controlWorkDirs) ||
-                !((_b = options.configFromOptions) === null || _b === void 0 ? void 0 : _b.treatmentWorkDir)) {
-                core_1.info.error('Please specify control and test working directory');
-                throw core_1.utils.haltOrThrow('No control or test working directory specified');
-            }
-            // get parameters
-            const controlWorkDirs = options.configFromOptions['controlWorkDirs'];
-            const treatmentWorkDir = options.configFromOptions['treatmentWorkDir'];
+            const { controlWorkDirs, treatmentWorkDir } = this.getWorkDirs(options);
             const { runMetaInfoManager } = core_1.runInfoUtils;
             runMetaInfoManager.setConfigFromRunMeta({
                 workDir: treatmentWorkDir,
                 silentFail: true,
             });
             // diff memory leaks
+            this.useDefaultMLClusteringSetting(options.cliArgs);
             yield core_1.analysis.diffLeakByWorkDir({ controlWorkDirs, treatmentWorkDir });
+            this.restoreDefaultMLClusteringSetting(options.cliArgs);
         });
     }
 }

package/dist/commands/heap/GetRetainerTraceCommand.d.ts

@@ -7,14 +7,14 @@
  * @format
  * @oncall web_perf_infra
  */
-import type { CLIOptions } from '@memlab/core';
+import type { CLIOptions, CommandOptionExample } from '@memlab/core';
 import BaseCommand, { CommandCategory } from '../../BaseCommand';
 import { BaseOption } from '@memlab/core';
 export default class GetRetainerTraceCommand extends BaseCommand {
     getCommandName(): string;
     getDescription(): string;
     getCategory(): CommandCategory;
-    getExamples(): string[];
+    getExamples(): CommandOptionExample[];
     getOptions(): BaseOption[];
     run(options: CLIOptions): Promise<void>;
 }

package/dist/commands/heap/HeapAnalysisCommand.d.ts

@@ -7,7 +7,7 @@
  * @format
  * @oncall web_perf_infra
  */
-import type { CLIOptions } from '@memlab/core';
+import type { CLIOptions, CommandOptionExample } from '@memlab/core';
 import BaseCommand, { CommandCategory } from '../../BaseCommand';
 export default class RunHeapAnalysisCommand extends BaseCommand {
     getCommandName(): string;
@@ -15,7 +15,7 @@ export default class RunHeapAnalysisCommand extends BaseCommand {
     getCategory(): CommandCategory;
     getPrerequisites(): BaseCommand[];
     getSubCommands(): BaseCommand[];
-    getExamples(): string[];
+    getExamples(): CommandOptionExample[];
     run(options: CLIOptions): Promise<void>;
 }
 //# sourceMappingURL=HeapAnalysisCommand.d.ts.map

package/dist/commands/heap/interactive/InteractiveHeapCommand.d.ts

@@ -7,14 +7,14 @@
  * @format
  * @oncall web_perf_infra
  */
-import { CLIOptions } from '@memlab/core';
+import { CLIOptions, CommandOptionExample } from '@memlab/core';
 import BaseCommand, { CommandCategory } from '../../../BaseCommand';
 import { BaseOption } from '@memlab/core';
 export default class InteractiveHeapCommand extends BaseCommand {
     getCommandName(): string;
     getDescription(): string;
     getCategory(): CommandCategory;
-    getExamples(): string[];
+    getExamples(): CommandOptionExample[];
     getOptions(): BaseOption[];
     private exitAttempt;
     private printPromptInfo;

package/dist/commands/heap/interactive/InteractiveHeapExploreCommand.d.ts

@@ -7,13 +7,13 @@
  * @format
  * @oncall web_perf_infra
  */
-import type { BaseOption, CLIOptions } from '@memlab/core';
+import type { BaseOption, CLIOptions, CommandOptionExample } from '@memlab/core';
 import BaseCommand, { CommandCategory } from '../../../BaseCommand';
 export default class InteractiveHeapViewCommand extends BaseCommand {
     getCommandName(): string;
     getDescription(): string;
     getCategory(): CommandCategory;
-    getExamples(): string[];
+    getExamples(): CommandOptionExample[];
     getOptions(): BaseOption[];
     private getHeap;
     private getNodesToFocus;

package/dist/commands/heap/interactive/ui-components/HeapViewUtils.d.ts

@@ -17,6 +17,8 @@ export declare class ComponentDataItem {
     type?: string;
     details?: Map<string, string>;
     static getTextForDisplay(data: ComponentDataItem): string;
+    private static getHeapObjectTextContent;
+    private static getHeapEdgeTextContent;
     private static getTextContent;
 }
 export declare class ComponentData {

package/dist/commands/heap/interactive/ui-components/HeapViewUtils.js

@@ -66,6 +66,28 @@ class ComponentDataItem {
         }
         return chalk_1.default.grey(content);
     }
+    static getHeapObjectTextContent(node) {
+        const objectType = chalk_1.default.grey(`(${node.type})`);
+        const objectId = chalk_1.default.grey(` @${node.id}`);
+        const size = core_1.utils.getReadableBytes(node.retainedSize);
+        const sizeInfo = chalk_1.default.grey(' [') + chalk_1.default.bold(chalk_1.default.blue(size)) + chalk_1.default.grey(']');
+        const objectTitle = node.isString ? '<string>' : node.name;
+        return (chalk_1.default.green('[') +
+            (isUsefulObjectForDebugging(node)
+                ? chalk_1.default.green(objectTitle)
+                : chalk_1.default.bold(chalk_1.default.grey(objectTitle))) +
+            chalk_1.default.green(']') +
+            objectType +
+            objectId +
+            sizeInfo);
+    }
+    static getHeapEdgeTextContent(edge) {
+        const arrowPrefix = chalk_1.default.grey('--');
+        const arrowSuffix = chalk_1.default.grey('---') + '>';
+        const edgeType = chalk_1.default.grey(`(${edge.type})`);
+        const edgeName = edge.name_or_index;
+        return `${arrowPrefix}${edgeName}${edgeType}${arrowSuffix} `;
+    }
     static getTextContent(data) {
         let ret = '';
         if (data.tag) {
@@ -74,32 +96,14 @@ class ComponentDataItem {
         if (data.stringContent) {
             ret += data.stringContent;
         }
-        const arrowPrefix = chalk_1.default.grey('--');
-        const arrowSuffix = chalk_1.default.grey('---') + '>';
         if (data.referrerEdge) {
-            const edgeType = chalk_1.default.grey(`(${data.referrerEdge.type})`);
-            const edgeName = data.referrerEdge.name_or_index;
-            ret += `${arrowPrefix}${edgeName}${edgeType}${arrowSuffix} `;
+            ret += this.getHeapEdgeTextContent(data.referrerEdge);
         }
         if (data.heapObject) {
-            const objectType = chalk_1.default.grey(`(${data.heapObject.type})`);
-            const objectId = chalk_1.default.grey(` @${data.heapObject.id}`);
-            const size = core_1.utils.getReadableBytes(data.heapObject.retainedSize);
-            const sizeInfo = chalk_1.default.grey(' [') + chalk_1.default.bold(chalk_1.default.blue(size)) + chalk_1.default.grey(']');
-            ret +=
-                chalk_1.default.green('[') +
-                    (isUsefulObjectForDebugging(data.heapObject)
-                        ? chalk_1.default.green(data.heapObject.name)
-                        : chalk_1.default.bold(chalk_1.default.grey(data.heapObject.name))) +
-                    chalk_1.default.green(']') +
-                    objectType +
-                    objectId +
-                    sizeInfo;
+            ret += this.getHeapObjectTextContent(data.heapObject);
         }
         if (data.referenceEdge) {
-            const edgeType = chalk_1.default.grey(`(${data.referenceEdge.type})`);
-            const edgeName = data.referenceEdge.name_or_index;
-            ret += ` ${arrowPrefix}${edgeName}${edgeType}${arrowSuffix} `;
+            ret += this.getHeapEdgeTextContent(data.referenceEdge);
         }
         return ret === '' ? chalk_1.default.grey('<undefinied>') : ret;
     }

package/dist/commands/heap/interactive/ui-components/ListComponent.js

@@ -203,7 +203,7 @@ class ListComponent {
             this.element.pushItem(content[i]);
             ++this.displayedItems;
         }
-        this.content = content;
+        this.content = content.map(v => v.replace(/\n/g, '\\n'));
         this.horizonScrollPositionMap.clear();
         this.insertDisplayMoreEntry();
         this.updateContent(oldContent, this.content);

package/dist/commands/helper/GenerateCLIDocCommand.js

@@ -46,6 +46,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = __importDefault(require("path"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
+const DocUtils_1 = __importDefault(require("./lib/DocUtils"));
 const BaseCommand_1 = __importStar(require("../../BaseCommand"));
 const core_1 = require("@memlab/core");
 const UniversalOptions_1 = __importDefault(require("../../options/lib/UniversalOptions"));
@@ -86,6 +87,10 @@ class GenerateCLIDocCommand extends BaseCommand_1.default {
     }
     writeCommandCategories(docFile) {
         this.writeTextWithNewLine(docFile, '# Command Line Interface');
+        this.writeTextWithNewLine(docFile, `Install the memlab command line tool with npm:
+\`\`\`bash
+npm install -g memlab
+\`\`\``);
         for (const category in BaseCommand_1.CommandCategory) {
             const commandsToPrintFirst = [];
             this.writeCategory(docFile, category, commandsToPrintFirst);
@@ -131,6 +136,7 @@ class GenerateCLIDocCommand extends BaseCommand_1.default {
         this.writeTextWithNewLine(docFile, `\n## ${categoryName} Commands\n`);
     }
     writeCommand(docFile, command, indent = '') {
+        var _a, _b;
         const name = command.getFullCommand();
         const desc = core_1.utils.upperCaseFirstCharacter(command.getDescription().trim());
         const cmdDoc = command.getDocumenation().trim();
@@ -144,17 +150,14 @@ class GenerateCLIDocCommand extends BaseCommand_1.default {
         }
         // get example
         const examples = command.getExamples();
-        let example = '';
-        if (examples.length > 0) {
-            example = examples[0].trim();
-        }
+        const example = (_a = examples[0]) !== null && _a !== void 0 ? _a : '';
         // write command synopsis
-        const cmd = `memlab ${name} ${example}`;
+        const cmd = DocUtils_1.default.generateExampleCommand(name, example);
         this.writeCodeBlock(docFile, cmd, 'bash');
         // write command examples if there is any
         const exampleBlock = examples
             .slice(1)
-            .map(example => `memlab ${name} ${example.trim()}`)
+            .map(example => DocUtils_1.default.generateExampleCommand(name, example))
             .join('\n');
         if (exampleBlock.length > 0) {
             this.writeTextWithNewLine(docFile, '\n#### examples\n');
@@ -162,7 +165,7 @@ class GenerateCLIDocCommand extends BaseCommand_1.default {
         }
         // write options
         this.writeCommandOptions(docFile, command);
-        const subCommands = command.getSubCommands();
+        const subCommands = (_b = command.getSubCommands()) !== null && _b !== void 0 ? _b : [];
         for (const subCommand of subCommands) {
             this.writeCommand(docFile, subCommand, indent + '#');
         }

package/dist/commands/helper/HelperCommand.d.ts

@@ -7,20 +7,23 @@
  * @format
  * @oncall web_perf_infra
  */
-import type { BaseOption, CLIOptions } from '@memlab/core';
+import type { BaseOption, CLIOptions, CommandOptionExample } from '@memlab/core';
 import BaseCommand from '../../BaseCommand';
-declare type HelperOption = CLIOptions & {
+declare type PrintCommandOptions = {
+    printOptions?: boolean;
+    printDoc?: boolean;
+};
+declare type HelperOption = CLIOptions & PrintCommandOptions & {
     modules: Map<string, BaseCommand>;
     command: BaseCommand | null;
     indent?: string;
-    printOptions?: boolean;
 };
 export default class HelperCommand extends BaseCommand {
     private printedCommand;
     private universalOptions;
     getCommandName(): string;
     getDescription(): string;
-    getExamples(): string[];
+    getExamples(): CommandOptionExample[];
     setUniversalOptions(options: BaseOption[]): void;
     private printHeader;
     private printCommandCategories;

package/dist/commands/helper/HelperCommand.js

@@ -49,6 +49,7 @@ const chalk_1 = __importDefault(require("chalk"));
 const string_width_1 = __importDefault(require("string-width"));
 const core_1 = require("@memlab/core");
 const heap_analysis_1 = require("@memlab/heap-analysis");
+const DocUtils_1 = __importDefault(require("./lib/DocUtils"));
 const CommandOrder_1 = __importDefault(require("./lib/CommandOrder"));
 const BaseCommand_1 = __importStar(require("../../BaseCommand"));
 const UniversalOptions_1 = __importDefault(require("../../options/lib/UniversalOptions"));
@@ -188,21 +189,22 @@ class HelperCommand extends BaseCommand_1.default {
         });
         return `${headerString}${descString.substring(headerStringWidth)}`;
     }
-    printCommand(command, extraIndent = '', printOptions = false) {
+    printCommand(command, extraIndent = '', options = {}) {
+        var _a;
         const indent = '  ' + extraIndent;
         const name = command.getFullCommand();
         const desc = core_1.utils.upperCaseFirstCharacter(command.getDescription().trim());
         const cmdDoc = command.getDocumenation().trim();
         // get example
         const examples = command.getExamples();
-        let example = '';
-        if (examples.length > 0) {
-            example = ' ' + examples[0].trim();
-        }
-        const cmd = chalk_1.default.green(`memlab ${name}${example}`);
+        const example = (_a = examples[0]) !== null && _a !== void 0 ? _a : '';
+        // write command synopsis
+        const cmd = DocUtils_1.default.generateExampleCommand(name, example, {
+            descriptionAsBashComment: false,
+        });
         let msg = `${indent}${cmd}`;
         msg += `\n${indent}${desc}`;
-        if (cmdDoc.length > 0) {
+        if (options.printOptions && cmdDoc.length > 0) {
             const cmdDocBlock = (0, CLIUtils_1.alignTextInBlock)(cmdDoc, {
                 leftIndent: indent.length + 2,
             });
@@ -210,7 +212,7 @@ class HelperCommand extends BaseCommand_1.default {
         }
         core_1.info.topLevel(msg);
         // print options info
-        if (printOptions) {
+        if (options.printOptions) {
             // print full options description
             this.printOptions(command, indent);
         }
@@ -224,11 +226,12 @@ class HelperCommand extends BaseCommand_1.default {
         core_1.info.topLevel('');
     }
     printHelperTextForCommand(command, options) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             // print helper text for a specific command
-            this.printCommand(command, options.indent, options.printOptions);
+            this.printCommand(command, options.indent, options);
             // print helper text for its subcommands
-            const subcommands = command.getSubCommands();
+            const subcommands = (_a = command.getSubCommands()) !== null && _a !== void 0 ? _a : [];
             const subOptions = Object.assign({}, options);
             subOptions.indent = (subOptions.indent || '') + ' ';
             for (const subcommand of subcommands) {
@@ -238,6 +241,7 @@ class HelperCommand extends BaseCommand_1.default {
         });
     }
     printFullHelperTextForCommand(args, modules) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             // get the command to print
             let map = modules;
@@ -252,7 +256,7 @@ class HelperCommand extends BaseCommand_1.default {
                 if (!command) {
                     break;
                 }
-                const subCommands = command.getSubCommands();
+                const subCommands = (_a = command.getSubCommands()) !== null && _a !== void 0 ? _a : [];
                 map = new Map(subCommands.map((cmd) => [cmd.getCommandName(), cmd]));
             }
             if (!command) {
@@ -260,9 +264,9 @@ class HelperCommand extends BaseCommand_1.default {
             }
             // print the helper text of the command
             core_1.info.topLevel('');
-            this.printCommand(command, '', true);
+            this.printCommand(command, '', { printOptions: true, printDoc: true });
             // print the helper text of the subcommands
-            const subCommands = command.getSubCommands();
+            const subCommands = (_b = command.getSubCommands()) !== null && _b !== void 0 ? _b : [];
             if (subCommands.length > 0) {
                 core_1.info.topLevel(chalk_1.default.bold('  SUB-COMMANDS\n'));
                 for (const subCommand of subCommands) {

package/dist/commands/helper/lib/DocUtils.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 { CommandOptionExample } from '@memlab/core';
+declare type GenerateExampleCommandOption = {
+    descriptionAsBashComment?: boolean;
+};
+declare function generateExampleCommand(command: string, cliExample: CommandOptionExample, options?: GenerateExampleCommandOption): string;
+declare const _default: {
+    generateExampleCommand: typeof generateExampleCommand;
+};
+export default _default;
+//# sourceMappingURL=DocUtils.d.ts.map

package/dist/commands/helper/lib/DocUtils.js

@@ -0,0 +1,39 @@
+"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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+function generateExampleCommand(command, cliExample, options = {}) {
+    if (typeof cliExample === 'string') {
+        return exampleFromCliOptionString(command, cliExample);
+    }
+    let commandExample = '';
+    if (cliExample.description != null &&
+        // if it's not null, undefined, or true
+        options.descriptionAsBashComment !== false) {
+        const desc = cliExample.description.trim();
+        if (desc.length > 0) {
+            // inject the description as a bash command in the bash example
+            const bashText = cliExample.description
+                .trim()
+                .split('\n')
+                .map(line => `# ${line.trim()}`)
+                .join('\n');
+            commandExample += bashText + '\n';
+        }
+    }
+    commandExample += exampleFromCliOptionString(command, cliExample.cliOptionExample);
+    return commandExample;
+}
+function exampleFromCliOptionString(command, cliExample) {
+    return `memlab ${command} ${cliExample.trim()}`;
+}
+exports.default = {
+    generateExampleCommand,
+};

package/dist/commands/snapshot/TakeSnapshotCommand.d.ts

@@ -7,14 +7,14 @@
  * @format
  * @oncall web_perf_infra
  */
-import type { CLIOptions } from '@memlab/core';
+import type { CLIOptions, CommandOptionExample } from '@memlab/core';
 import BaseCommand from '../../BaseCommand';
 import { BaseOption } from '@memlab/core';
 export default class TakeSnapshotCommand extends BaseCommand {
     getCommandName(): string;
     getDescription(): string;
     getPrerequisites(): BaseCommand[];
-    getExamples(): string[];
+    getExamples(): CommandOptionExample[];
     getOptions(): BaseOption[];
     run(_options: CLIOptions): Promise<void>;
 }

package/dist/commands/snapshot/TakeSnapshotCommand.js

@@ -45,6 +45,7 @@ const DisableWebSecurityOption_1 = __importDefault(require("../../options/e2e/Di
 const EnableJSRewriteOption_1 = __importDefault(require("../../options/e2e/EnableJSRewriteOption"));
 const EnableJSInterceptOption_1 = __importDefault(require("../../options/e2e/EnableJSInterceptOption"));
 const TargetWorkerOption_1 = __importDefault(require("../../options/e2e/TargetWorkerOption"));
+const SetChromiumBinaryOption_1 = __importDefault(require("../../options/e2e/SetChromiumBinaryOption"));
 class TakeSnapshotCommand extends BaseCommand_1.default {
     getCommandName() {
         return 'snapshot';
@@ -80,6 +81,7 @@ class TakeSnapshotCommand extends BaseCommand_1.default {
             new RunningModeOption_1.default(),
             new RemoteBrowserDebugOption_1.default(),
             new ScenarioFileOption_1.default(),
+            new SetChromiumBinaryOption_1.default(),
             new SetDeviceOption_1.default(),
             new SetUserAgentOption_1.default(),
             new DisableXvfbOption_1.default(),

package/dist/commands/snapshot/WarmupAndSnapshotCommand.d.ts

@@ -7,11 +7,13 @@
  * @format
  * @oncall web_perf_infra
  */
-import type { CLIOptions } from '@memlab/core';
+import type { CLIOptions, CommandOptionExample } from '@memlab/core';
 import BaseCommand from '../../BaseCommand';
 export default class WarmupAndSnapshotCommand extends BaseCommand {
     getCommandName(): string;
     getDescription(): string;
+    getDocumenation(): string;
+    getExamples(): CommandOptionExample[];
     getPrerequisites(): BaseCommand[];
     run(_options: CLIOptions): Promise<void>;
 }

package/dist/commands/snapshot/WarmupAndSnapshotCommand.js

@@ -22,6 +22,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const BaseCommand_1 = __importDefault(require("../../BaseCommand"));
+const SetWorkingDirectoryOption_1 = __importDefault(require("../../options/SetWorkingDirectoryOption"));
 const InitDirectoryCommand_1 = __importDefault(require("../InitDirectoryCommand"));
 const WarmupAppCommand_1 = __importDefault(require("../WarmupAppCommand"));
 const TakeSnapshotCommand_1 = __importDefault(require("./TakeSnapshotCommand"));
@@ -32,6 +33,28 @@ class WarmupAndSnapshotCommand extends BaseCommand_1.default {
     getDescription() {
         return 'Warm up server and take heap snapshots';
     }
+    getDocumenation() {
+        const warmupCommand = new WarmupAppCommand_1.default();
+        const warmupCLI = `memlab ${warmupCommand.getCommandName()}`;
+        const takeSnapshotCommand = new TakeSnapshotCommand_1.default();
+        const snapshotCLI = `memlab ${takeSnapshotCommand.getCommandName()}`;
+        return ('This is equivalent to running ' +
+            `\`${warmupCLI}\` and \`${snapshotCLI}\`.`);
+    }
+    getExamples() {
+        return [
+            {
+                description: 'specify a test scenario file, memlab will ' +
+                    'warm up the server and take heap snapshots',
+                cliOptionExample: '--scenario <TEST_SCENARIO_FILE>',
+            },
+            '--scenario /tmp/test-scenario.js',
+            {
+                description: new SetWorkingDirectoryOption_1.default().getDescription(),
+                cliOptionExample: '--scenario /tmp/test-scenario.js --work-dir /tmp/test-1/',
+            },
+        ];
+    }
     getPrerequisites() {
         return [
             new InitDirectoryCommand_1.default(),

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,14 +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): string[];
+    protected extractAndCheckWorkDirs(args: ParsedArgs): Nullable<string[]>;
     parse(config: MemLabConfig, args: ParsedArgs): Promise<{
-        controlWorkDirs?: string[];
+        controlWorkDirs?: Nullable<string[]>;
     }>;
 }
 //# sourceMappingURL=SetControlWorkDirOption.d.ts.map

package/dist/options/experiment/SetControlWorkDirOption.js

@@ -36,7 +36,7 @@ class SetControlWorkDirOption extends core_1.BaseOption {
         const name = this.getOptionName();
         const flagValue = args[name];
         if (!flagValue) {
-            return dirs;
+            return null;
         }
         if (Array.isArray(flagValue)) {
             dirs = flagValue;

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,26 +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"));
 const OversizeThresholdOption_1 = __importDefault(require("./OversizeThresholdOption"));
-class TraceAllObjectsOption extends core_1.BaseOption {
+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()]) {
+            const optionValue = args[this.getOptionName()];
+            if (optionValue == null) {
                 return;
             }
             config.oversizeObjectAsLeak = true;
             const overSizeOptionName = new OversizeThresholdOption_1.default().getOptionName();
-            // over size option will set the oversize threshold
+            // 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.24",
+  "version": "1.0.25",
   "license": "MIT",
   "description": "command line interface for memlab",
   "author": "Liang Gong <lgong@fb.com>",