@memlab/cli 1.0.21 → 1.0.22

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

@@ -7,7 +7,7 @@
  * @format
  * @oncall web_perf_infra
  */
-import type { CLIOptions } from '@memlab/core';
+import { CLIOptions } from '@memlab/core';
 import BaseCommand, { CommandCategory } from '../../BaseCommand';
 import { BaseOption } from '@memlab/core';
 export default class CheckLeakCommand extends BaseCommand {
@@ -16,6 +16,6 @@ export default class CheckLeakCommand extends BaseCommand {
     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

@@ -44,8 +44,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const BaseCommand_1 = __importStar(require("../../BaseCommand"));
 const core_1 = require("@memlab/core");
+const BaseCommand_1 = __importStar(require("../../BaseCommand"));
+const core_2 = require("@memlab/core");
 const BaselineFileOption_1 = __importDefault(require("../../options/heap/BaselineFileOption"));
 const FinalFileOption_1 = __importDefault(require("../../options/heap/FinalFileOption"));
 const JSEngineOption_1 = __importDefault(require("../../options/heap/JSEngineOption"));
@@ -61,6 +62,7 @@ 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"));
 class CheckLeakCommand extends BaseCommand_1.default {
     getCommandName() {
         return 'find-leaks';
@@ -89,13 +91,18 @@ class CheckLeakCommand extends BaseCommand_1.default {
             new MLClusteringOption_1.default(),
             new MLClusteringLinkageMaxDistanceOption_1.default(),
             new MLClusteringMaxDFOption_1.default(),
+            new CleanupSnapshotOption_1.default(),
         ];
     }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    run(_options) {
+    run(options) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            core_1.config.chaseWeakMapEdge = false;
-            yield core_1.analysis.checkLeak();
+            core_2.config.chaseWeakMapEdge = false;
+            yield core_2.analysis.checkLeak();
+            const configFromOptions = (_a = options.configFromOptions) !== null && _a !== void 0 ? _a : {};
+            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/ui-components/ListComponent.js

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

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/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,6 +50,7 @@ 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;
@@ -64,7 +67,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,6 +106,7 @@ 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;

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,6 +52,7 @@ 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',

package/package.json

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