@memlab/cli 1.0.21 → 1.0.23

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

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

package/dist/commands/heap/CheckLeakCommand.js

@@ -61,6 +61,8 @@ const LeakClusterSizeThresholdOption_1 = __importDefault(require("../../options/
 const MLClusteringOption_1 = __importDefault(require("../../options/MLClusteringOption"));
 const MLClusteringLinkageMaxDistanceOption_1 = __importDefault(require("../../options/MLClusteringLinkageMaxDistanceOption"));
 const MLClusteringMaxDFOption_1 = __importDefault(require("../../options/MLClusteringMaxDFOption"));
+const CleanupSnapshotOption_1 = __importDefault(require("../../options/heap/CleanupSnapshotOption"));
+const SetWorkingDirectoryOption_1 = __importDefault(require("../../options/SetWorkingDirectoryOption"));
 class CheckLeakCommand extends BaseCommand_1.default {
     getCommandName() {
         return 'find-leaks';
@@ -89,13 +91,21 @@ class CheckLeakCommand extends BaseCommand_1.default {
             new MLClusteringOption_1.default(),
             new MLClusteringLinkageMaxDistanceOption_1.default(),
             new MLClusteringMaxDFOption_1.default(),
+            new CleanupSnapshotOption_1.default(),
+            new SetWorkingDirectoryOption_1.default(),
         ];
     }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    run(_options) {
+    run(options) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
+            const workDir = (_a = options.configFromOptions) === null || _a === void 0 ? void 0 : _a.workDir;
+            core_1.fileManager.initDirs(core_1.config, { workDir });
             core_1.config.chaseWeakMapEdge = false;
             yield core_1.analysis.checkLeak();
+            const configFromOptions = (_b = options.configFromOptions) !== null && _b !== void 0 ? _b : {};
+            if (configFromOptions['cleanUpSnapshot']) {
+                core_1.fileManager.removeSnapshotFiles();
+            }
         });
     }
 }

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

@@ -0,0 +1,21 @@
+/**
+ * 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 { CLIOptions } from '@memlab/core';
+import BaseCommand, { CommandCategory } from '../../BaseCommand';
+import { BaseOption } from '@memlab/core';
+export default class CheckLeakCommand extends BaseCommand {
+    getCommandName(): string;
+    getDescription(): string;
+    getCategory(): CommandCategory;
+    getPrerequisites(): BaseCommand[];
+    getOptions(): BaseOption[];
+    run(options: CLIOptions): Promise<void>;
+}
+//# sourceMappingURL=DiffLeakCommand.d.ts.map

package/dist/commands/heap/DiffLeakCommand.js

@@ -0,0 +1,110 @@
+"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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 core_2 = require("@memlab/core");
+const BaseCommand_1 = __importStar(require("../../BaseCommand"));
+const core_3 = require("@memlab/core");
+const JSEngineOption_1 = __importDefault(require("../../options/heap/JSEngineOption"));
+const InitDirectoryCommand_1 = __importDefault(require("../InitDirectoryCommand"));
+const OversizeThresholdOption_1 = __importDefault(require("../../options/heap/OversizeThresholdOption"));
+const TraceAllObjectsOption_1 = __importDefault(require("../../options/heap/TraceAllObjectsOption"));
+const LogTraceAsClusterOption_1 = __importDefault(require("../../options/heap/LogTraceAsClusterOption"));
+const CleanLoggerDataCommand_1 = __importDefault(require("../CleanLoggerDataCommand"));
+const LeakFilterFileOption_1 = __importDefault(require("../../options/heap/leak-filter/LeakFilterFileOption"));
+const LeakClusterSizeThresholdOption_1 = __importDefault(require("../../options/heap/LeakClusterSizeThresholdOption"));
+const MLClusteringOption_1 = __importDefault(require("../../options/MLClusteringOption"));
+const MLClusteringLinkageMaxDistanceOption_1 = __importDefault(require("../../options/MLClusteringLinkageMaxDistanceOption"));
+const MLClusteringMaxDFOption_1 = __importDefault(require("../../options/MLClusteringMaxDFOption"));
+const SetControlWorkDirOption_1 = __importDefault(require("../../options/experiment/SetControlWorkDirOption"));
+const SetTreatmentWorkDirOption_1 = __importDefault(require("../../options/experiment/SetTreatmentWorkDirOption"));
+class CheckLeakCommand extends BaseCommand_1.default {
+    getCommandName() {
+        return 'diff-leaks';
+    }
+    getDescription() {
+        return 'find new memory leaks by diffing control and test heap snapshots';
+    }
+    getCategory() {
+        return BaseCommand_1.CommandCategory.COMMON;
+    }
+    getPrerequisites() {
+        return [new InitDirectoryCommand_1.default(), new CleanLoggerDataCommand_1.default()];
+    }
+    getOptions() {
+        return [
+            new SetControlWorkDirOption_1.default().required(),
+            new SetTreatmentWorkDirOption_1.default().required(),
+            new JSEngineOption_1.default(),
+            new LeakFilterFileOption_1.default(),
+            new OversizeThresholdOption_1.default(),
+            new LeakClusterSizeThresholdOption_1.default(),
+            new TraceAllObjectsOption_1.default(),
+            new LogTraceAsClusterOption_1.default(),
+            new MLClusteringOption_1.default(),
+            new MLClusteringLinkageMaxDistanceOption_1.default(),
+            new MLClusteringMaxDFOption_1.default(),
+        ];
+    }
+    run(options) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            core_3.config.chaseWeakMapEdge = false;
+            // double check parameters
+            if (!((_a = options.configFromOptions) === null || _a === void 0 ? void 0 : _a.controlWorkDir) ||
+                !((_b = options.configFromOptions) === null || _b === void 0 ? void 0 : _b.treatmentWorkDir)) {
+                core_2.info.error('Please specify control and test working directory');
+                throw core_1.utils.haltOrThrow('No control or test working directory specified');
+            }
+            // get parameters
+            const controlWorkDir = options.configFromOptions['controlWorkDir'];
+            const treatmentWorkDir = options.configFromOptions['treatmentWorkDir'];
+            // diff memory leaks
+            yield core_3.analysis.diffLeakByWorkDir({ controlWorkDir, treatmentWorkDir });
+        });
+    }
+}
+exports.default = CheckLeakCommand;

package/dist/commands/heap/interactive/InteractiveHeapExploreCommand.js

@@ -53,6 +53,7 @@ const JSEngineOption_1 = __importDefault(require("../../../options/heap/JSEngine
 const CliScreen_1 = __importDefault(require("./ui-components/CliScreen"));
 const HeapNodeIdOption_1 = __importDefault(require("../../../options/heap/HeapNodeIdOption"));
 const MLClusteringOption_1 = __importDefault(require("../../../options/MLClusteringOption"));
+const SetWorkingDirectoryOption_1 = __importDefault(require("../../../options/SetWorkingDirectoryOption"));
 class InteractiveHeapViewCommand extends BaseCommand_1.default {
     getCommandName() {
         return 'view-heap';
@@ -72,6 +73,7 @@ class InteractiveHeapViewCommand extends BaseCommand_1.default {
             new JSEngineOption_1.default(),
             new HeapNodeIdOption_1.default(),
             new MLClusteringOption_1.default(),
+            new SetWorkingDirectoryOption_1.default(),
         ];
     }
     // get the heap snapshot to view
@@ -160,6 +162,7 @@ class InteractiveHeapViewCommand extends BaseCommand_1.default {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const workDir = (_a = options.configFromOptions) === null || _a === void 0 ? void 0 : _a.workDir;
+            core_1.fileManager.initDirs(core_1.config, { workDir, errorWhenAbsent: true });
             const reportOutDir = core_1.fileManager.getReportOutDir({ workDir });
             fs_extra_1.default.emptyDirSync(reportOutDir);
             const heap = yield this.getHeap(options);

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

@@ -34,7 +34,6 @@ class ListComponent {
                 },
                 selected: {
                     bg: 'grey',
-                    bold: true,
                 },
             } }));
         this.setContent(content);

package/dist/commands/snapshot/TakeSnapshotCommand.js

@@ -44,6 +44,7 @@ const SetUserAgentOption_1 = __importDefault(require("../../options/e2e/SetUserA
 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 TargetWorkerOption_1 = __importDefault(require("../../options/e2e/TargetWorkerOption"));
 class TakeSnapshotCommand extends BaseCommand_1.default {
     getCommandName() {
         return 'snapshot';
@@ -85,6 +86,7 @@ class TakeSnapshotCommand extends BaseCommand_1.default {
             new DisableWebSecurityOption_1.default(),
             new EnableJSRewriteOption_1.default(),
             new EnableJSInterceptOption_1.default(),
+            new TargetWorkerOption_1.default(),
         ];
     }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars

package/dist/options/SetWorkingDirectoryOption.d.ts

@@ -8,7 +8,7 @@
  * @oncall web_perf_infra
  */
 import type { ParsedArgs } from 'minimist';
-import type { MemLabConfig } from '@memlab/core';
+import { MemLabConfig } from '@memlab/core';
 import { BaseOption } from '@memlab/core';
 export default class SetWorkingDirectoryOption extends BaseOption {
     getOptionName(): string;

package/dist/options/SetWorkingDirectoryOption.js

@@ -34,8 +34,9 @@ class SetWorkingDirectoryOption extends core_1.BaseOption {
         return __awaiter(this, void 0, void 0, function* () {
             const name = this.getOptionName();
             const ret = {};
-            if (args[name]) {
-                ret.workDir = args[name];
+            const workDir = args[name];
+            if (workDir) {
+                ret.workDir = workDir;
             }
             return ret;
         });

package/dist/options/e2e/TargetWorkerOption.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 TargetWorkerOption extends BaseOption {
+    getOptionName(): string;
+    getDescription(): string;
+    getExampleValues(): string[];
+    parse(config: MemLabConfig, args: ParsedArgs): Promise<void>;
+}
+//# sourceMappingURL=TargetWorkerOption.d.ts.map

package/dist/options/e2e/TargetWorkerOption.js

@@ -0,0 +1,51 @@
+"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 TargetWorkerOption extends core_1.BaseOption {
+    getOptionName() {
+        return OptionConstant_1.default.optionNames.WORKER_TITLE;
+    }
+    getDescription() {
+        return ('set title of the target (worker) that ' +
+            'needs to be selected and analyzed');
+    }
+    getExampleValues() {
+        return ['WorkerTitle'];
+    }
+    parse(config, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const name = this.getOptionName();
+            const arg = args[name];
+            if (arg) {
+                config.isAnalyzingMainThread = false;
+                const value = Array.isArray(arg) ? arg[arg.length - 1] : arg;
+                if (typeof value === 'string') {
+                    config.targetWorkerTitle = value;
+                }
+            }
+        });
+    }
+}
+exports.default = TargetWorkerOption;

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

@@ -0,0 +1,20 @@
+/**
+ * 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 SetControlWorkDirOption extends BaseOption {
+    getOptionName(): string;
+    getDescription(): string;
+    parse(config: MemLabConfig, args: ParsedArgs): Promise<{
+        controlWorkDir?: string;
+    }>;
+}
+//# sourceMappingURL=SetControlWorkDirOption.d.ts.map

package/dist/options/experiment/SetControlWorkDirOption.js

@@ -0,0 +1,44 @@
+"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 SetControlWorkDirOption extends core_1.BaseOption {
+    getOptionName() {
+        return OptionConstant_1.default.optionNames.CONTROL_WORK_DIR;
+    }
+    getDescription() {
+        return 'set the working directory of the control run';
+    }
+    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;
+        });
+    }
+}
+exports.default = SetControlWorkDirOption;

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

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

package/dist/options/experiment/SetTreatmentWorkDirOption.js

@@ -0,0 +1,44 @@
+"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 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';
+    }
+    parse(config, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const name = this.getOptionName();
+            const ret = {};
+            if (args[name]) {
+                ret.treatmentWorkDir = args[name];
+            }
+            return ret;
+        });
+    }
+}
+exports.default = SetTreatmentWorkDirOption;

package/dist/options/heap/CleanupSnapshotOption.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 { BaseOption, MemLabConfig } from '@memlab/core';
+export default class CleanupSnapshotOption extends BaseOption {
+    getOptionName(): string;
+    getDescription(): string;
+    parse(config: MemLabConfig, args: ParsedArgs): Promise<{
+        cleanUpSnapshot: boolean;
+    }>;
+}
+//# sourceMappingURL=CleanupSnapshotOption.d.ts.map

package/dist/options/heap/CleanupSnapshotOption.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 CleanupSnapshotOption extends core_1.BaseOption {
+    getOptionName() {
+        return OptionConstant_1.default.optionNames.CLEAN_UP_SNAPSHOT;
+    }
+    getDescription() {
+        return 'clean up heap snapshots after running';
+    }
+    parse(config, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const name = this.getOptionName();
+            return {
+                cleanUpSnapshot: !!args[name],
+            };
+        });
+    }
+}
+exports.default = CleanupSnapshotOption;

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

@@ -11,7 +11,9 @@ declare const optionConstants: {
     optionNames: {
         APP: string;
         BASELINE: string;
+        CLEAN_UP_SNAPSHOT: string;
         CONTINUS_TEST: string;
+        CONTROL_WORK_DIR: string;
         DEVICE: string;
         DISABLE_WEB_SECURITY: string;
         DISABLE_XVFB: string;
@@ -48,9 +50,11 @@ declare const optionConstants: {
         TARGET: string;
         TRACE_ALL_OBJECTS: string;
         TRACE_OBJECT_SIZE_ABOVE: string;
+        TREATMENT_WORK_DIR: string;
         USER_AGENT: string;
         VERBOSE: string;
         WORK_DIR: string;
+        WORKER_TITLE: string;
         DEBUG: string;
     };
     optionShortcuts: {
@@ -64,7 +68,9 @@ declare const _default: {
     optionNames: {
         APP: string;
         BASELINE: string;
+        CLEAN_UP_SNAPSHOT: string;
         CONTINUS_TEST: string;
+        CONTROL_WORK_DIR: string;
         DEVICE: string;
         DISABLE_WEB_SECURITY: string;
         DISABLE_XVFB: string;
@@ -101,9 +107,11 @@ declare const _default: {
         TARGET: string;
         TRACE_ALL_OBJECTS: string;
         TRACE_OBJECT_SIZE_ABOVE: string;
+        TREATMENT_WORK_DIR: string;
         USER_AGENT: string;
         VERBOSE: string;
         WORK_DIR: string;
+        WORKER_TITLE: string;
         DEBUG: string;
     };
     optionShortcuts: {

package/dist/options/lib/OptionConstant.js

@@ -13,7 +13,9 @@ const core_1 = require("@memlab/core");
 const optionNames = {
     APP: 'app',
     BASELINE: 'baseline',
+    CLEAN_UP_SNAPSHOT: 'clean-up-snapshot',
     CONTINUS_TEST: 'ContinuousTest',
+    CONTROL_WORK_DIR: 'control-work-dir',
     DEVICE: 'device',
     DISABLE_WEB_SECURITY: 'disable-web-security',
     DISABLE_XVFB: 'disable-xvfb',
@@ -50,9 +52,11 @@ const optionNames = {
     TARGET: 'target',
     TRACE_ALL_OBJECTS: 'trace-all-objects',
     TRACE_OBJECT_SIZE_ABOVE: 'trace-object-size-above',
+    TREATMENT_WORK_DIR: 'treatment-work-dir',
     USER_AGENT: 'user-agent',
     VERBOSE: 'verbose',
     WORK_DIR: 'work-dir',
+    WORKER_TITLE: 'worker',
     DEBUG: 'debug',
 };
 const optionShortcuts = {

package/package.json

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