@memlab/cli 1.0.24 → 1.0.26

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/lib/CLIUtils.js

@@ -39,6 +39,19 @@ function filterAndGetUndefinedArgs(cliArgs) {
     return ret;
 }
 exports.filterAndGetUndefinedArgs = filterAndGetUndefinedArgs;
+function quoteIfNecessary(v) {
+    if (typeof v !== 'string') {
+        return v;
+    }
+    // if the string contains any whitespace character
+    if (/\s/.test(v)) {
+        // escape any existing " character
+        v = v.replace(/"/g, '\\"');
+        // wrap the string with "
+        v = `"${v}"`;
+    }
+    return v;
+}
 function argsToString(args) {
     let ret = '';
     for (const optionName of Object.keys(args)) {
@@ -51,11 +64,11 @@ function argsToString(args) {
         }
         else if (Array.isArray(value)) {
             value.forEach(v => {
-                ret += `--${optionName}=${v} `;
+                ret += `--${optionName}=${quoteIfNecessary(v)} `;
             });
         }
         else {
-            ret += `--${optionName}=${value} `;
+            ret += `--${optionName}=${quoteIfNecessary(value)} `;
         }
     }
     return ret.trim();

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/ExperimentOptionUtils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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 { Nullable } from '@memlab/core';
+export declare function extractAndCheckWorkDirs(optionName: string, args: ParsedArgs): Nullable<string[]>;
+//# sourceMappingURL=ExperimentOptionUtils.d.ts.map

package/dist/options/experiment/ExperimentOptionUtils.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
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractAndCheckWorkDirs = void 0;
+const fs_1 = __importDefault(require("fs"));
+const core_1 = require("@memlab/core");
+function extractAndCheckWorkDirs(optionName, args) {
+    let dirs = [];
+    const flagValue = args[optionName];
+    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;
+}
+exports.extractAndCheckWorkDirs = extractAndCheckWorkDirs;

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

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

package/dist/options/experiment/SetControlWorkDirOption.js

@@ -21,9 +21,9 @@ 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"));
+const ExperimentOptionUtils_1 = require("./ExperimentOptionUtils");
 class SetControlWorkDirOption extends core_1.BaseOption {
     getOptionName() {
         return OptionConstant_1.default.optionNames.CONTROL_WORK_DIR;
@@ -31,31 +31,9 @@ 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 dirs;
-        }
-        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) {
+    parse(_config, args) {
         return __awaiter(this, void 0, void 0, function* () {
-            const dirs = this.extractAndCheckWorkDirs(args);
+            const dirs = (0, ExperimentOptionUtils_1.extractAndCheckWorkDirs)(this.getOptionName(), args);
             return { controlWorkDirs: dirs };
         });
     }

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

@@ -8,13 +8,13 @@
  * @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 SetTreatmentWorkDirOption extends BaseOption {
     getOptionName(): string;
     getDescription(): string;
     parse(config: MemLabConfig, args: ParsedArgs): Promise<{
-        treatmentWorkDir?: string;
+        treatmentWorkDirs?: Nullable<string[]>;
     }>;
 }
 //# sourceMappingURL=SetTreatmentWorkDirOption.d.ts.map

package/dist/options/experiment/SetTreatmentWorkDirOption.js

@@ -21,29 +21,20 @@ 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"));
+const ExperimentOptionUtils_1 = require("./ExperimentOptionUtils");
 class SetTreatmentWorkDirOption extends core_1.BaseOption {
     getOptionName() {
         return OptionConstant_1.default.optionNames.TREATMENT_WORK_DIR;
     }
     getDescription() {
-        return 'set the working directory of the test (treatment) run';
+        return 'set the working directory of the treatment run';
     }
     parse(config, args) {
         return __awaiter(this, void 0, void 0, function* () {
-            const name = this.getOptionName();
-            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;
+            const dirs = (0, ExperimentOptionUtils_1.extractAndCheckWorkDirs)(this.getOptionName(), args);
+            return { treatmentWorkDirs: dirs };
         });
     }
 }

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