@memlab/cli 2.0.4 → 2.0.5

package/dist/commands/heap/AnonymizeSnapshotCommand.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 memory_lab
+ */
+import type { CLIOptions } from '@memlab/core';
+import { BaseOption } from '@memlab/core';
+import BaseCommand, { CommandCategory } from '../../BaseCommand';
+export default class AnonymizeSnapshotCommand extends BaseCommand {
+    getCommandName(): string;
+    getDescription(): string;
+    getCategory(): CommandCategory;
+    getExamples(): string[];
+    getOptions(): BaseOption[];
+    run(options: CLIOptions): Promise<void>;
+}
+//# sourceMappingURL=AnonymizeSnapshotCommand.d.ts.map

package/dist/commands/heap/AnonymizeSnapshotCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnonymizeSnapshotCommand.d.ts","sourceRoot":"","sources":["../../../src/commands/heap/AnonymizeSnapshotCommand.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAkB,UAAU,EAAC,MAAM,cAAc,CAAC;AAE9D,OAAO,EAGL,UAAU,EAIX,MAAM,cAAc,CAAC;AACtB,OAAO,WAAW,EAAE,EAAC,eAAe,EAAC,MAAM,mBAAmB,CAAC;AA0C/D,MAAM,CAAC,OAAO,OAAO,wBAAyB,SAAQ,WAAW;IAC/D,cAAc,IAAI,MAAM;IAIxB,cAAc,IAAI,MAAM;IAIxB,WAAW,IAAI,eAAe;IAI9B,WAAW,IAAI,MAAM,EAAE;IAQvB,UAAU,IAAI,UAAU,EAAE;IAWpB,GAAG,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CA4D9C"}

package/dist/commands/heap/AnonymizeSnapshotCommand.js

@@ -0,0 +1,170 @@
+"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 memory_lab
+ */
+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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __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 BaseCommand_1 = __importStar(require("../../BaseCommand"));
+const AnonymizeAuditOnlyOption_1 = __importDefault(require("../../options/heap/AnonymizeAuditOnlyOption"));
+const AnonymizeModeOption_1 = __importDefault(require("../../options/heap/AnonymizeModeOption"));
+const AnonymizeOutputOption_1 = __importDefault(require("../../options/heap/AnonymizeOutputOption"));
+const AnonymizeSaltOption_1 = __importDefault(require("../../options/heap/AnonymizeSaltOption"));
+const OptionConstant_1 = __importDefault(require("../../options/lib/OptionConstant"));
+const SnapshotDirectoryOption_1 = __importDefault(require("../../options/heap/SnapshotDirectoryOption"));
+const SnapshotFileOption_1 = __importDefault(require("../../options/heap/SnapshotFileOption"));
+function printReport(report, wrote) {
+    core_1.info.topLevel(wrote != null ? `Anonymized snapshot written to ${wrote}` : 'Audit only');
+    core_1.info.lowLevel(`  mode: ${report.mode}${report.salted ? ' (salted)' : ''}`);
+    core_1.info.lowLevel(`  string table entries: ${report.stringTableSize}`);
+    core_1.info.lowLevel(`  heap string values redacted: ${report.valuesRedacted}`);
+    core_1.info.lowLevel(`  entries split to keep a label: ${report.entriesSplit}`);
+    core_1.info.lowLevel(`  entries redacted by content: ${report.contentRedacted}`);
+    for (const rule of report.contentRedactedByRule) {
+        core_1.info.lowLevel(`    ${rule.rule}: ${rule.count}`);
+    }
+    // Printed even when it is empty, and printed last, because it is the part a
+    // reader has to act on. A tool that only lists what it removed invites the
+    // reader to assume the rest was safe.
+    core_1.info.topLevel('Still in the clear — review before sharing:');
+    if (report.unclassifiedLabelFamilies.length === 0) {
+        core_1.info.lowLevel('  (no machine-generated-looking labels remain)');
+        return;
+    }
+    for (const family of report.unclassifiedLabelFamilies) {
+        const examples = family.examples
+            .map(e => (e.length > 40 ? `${e.slice(0, 37)}...` : e))
+            .join(', ');
+        core_1.info.lowLevel(`  ${family.count} x ${family.shape}   e.g. ${examples}`);
+    }
+    core_1.info.lowLevel('  Any of these that is an identifier in YOUR application is a residual; ' +
+        'anonymize again from the API with a `shouldRedact` callback to remove it.');
+}
+class AnonymizeSnapshotCommand extends BaseCommand_1.default {
+    getCommandName() {
+        return 'anonymize';
+    }
+    getDescription() {
+        return 'remove user data from a heap snapshot so it can be shared';
+    }
+    getCategory() {
+        return BaseCommand_1.CommandCategory.COMMON;
+    }
+    getExamples() {
+        return [
+            '--snapshot <HEAP_SNAPSHOT_FILE> --output <OUTPUT_FILE>',
+            '--snapshot <HEAP_SNAPSHOT_FILE> --output <OUTPUT_FILE> --anonymize-salt <SALT>',
+            '--snapshot <HEAP_SNAPSHOT_FILE> --audit-only',
+        ];
+    }
+    getOptions() {
+        return [
+            new SnapshotFileOption_1.default(),
+            new SnapshotDirectoryOption_1.default(),
+            new AnonymizeOutputOption_1.default(),
+            new AnonymizeModeOption_1.default(),
+            new AnonymizeSaltOption_1.default(),
+            new AnonymizeAuditOnlyOption_1.default(),
+        ];
+    }
+    run(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const args = options.cliArgs;
+            const names = OptionConstant_1.default.optionNames;
+            const input = core_1.utils.getSingleSnapshotFileForAnalysis();
+            const output = args[names.ANONYMIZE_OUTPUT];
+            const auditOnly = Boolean(args[names.ANONYMIZE_AUDIT_ONLY]);
+            const anonymizeOptions = {
+                mode: args[names.ANONYMIZE_MODE],
+                salt: args[names.ANONYMIZE_SALT],
+            };
+            if (auditOnly) {
+                if (output) {
+                    // Said out loud rather than ignored. The whole point of this command is
+                    // that the caller knows exactly what did and did not happen to their
+                    // capture; silently dropping the output path leaves them looking for a
+                    // file that was never written.
+                    core_1.info.warning(`--${names.ANONYMIZE_AUDIT_ONLY} writes nothing, so ` +
+                        `--${names.ANONYMIZE_OUTPUT}=${output} is ignored. Re-run without ` +
+                        `--${names.ANONYMIZE_AUDIT_ONLY} to produce that file.`);
+                }
+                printReport(yield (0, core_1.auditHeapSnapshotFile)(input, anonymizeOptions), null);
+                return;
+            }
+            if (!output) {
+                // Refusing rather than defaulting to a path next to the input: writing an
+                // anonymized copy somewhere the caller did not name is how a file ends up
+                // shared by accident, and overwriting the original would destroy the only
+                // unredacted copy.
+                core_1.utils.haltOrThrow(`Specify --${names.ANONYMIZE_OUTPUT} <FILE> to write the anonymized ` +
+                    `snapshot to, or --${names.ANONYMIZE_AUDIT_ONLY} to only report ` +
+                    `what would be redacted.`);
+                return;
+            }
+            // Compared canonically, not as strings. `input` arrives already resolved
+            // from `getSingleSnapshotFileForAnalysis`, while `output` is whatever the
+            // user typed, so `./capture.heapsnapshot`, a relative path, or a symlink to
+            // the input are all spellings this guard has to catch — missing one
+            // overwrites the only unredacted copy, which is the thing it exists to
+            // prevent. The API refuses too; this is here to fail with a CLI-shaped
+            // message before any work starts.
+            if ((0, core_1.resolveForComparison)(output) === (0, core_1.resolveForComparison)(input)) {
+                core_1.utils.haltOrThrow(`--${names.ANONYMIZE_OUTPUT} resolves to the same file as the input ` +
+                    `snapshot; anonymizing in place would destroy the original capture.`);
+                return;
+            }
+            printReport(yield (0, core_1.anonymizeHeapSnapshotFile)(input, output, anonymizeOptions), output);
+        });
+    }
+}
+exports.default = AnonymizeSnapshotCommand;

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

package/dist/options/heap/AnonymizeAuditOnlyOption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnonymizeAuditOnlyOption.d.ts","sourceRoot":"","sources":["../../../src/options/heap/AnonymizeAuditOnlyOption.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,UAAU,CAAC;AACzC,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAC,UAAU,EAAQ,MAAM,cAAc,CAAC;AAG/C,MAAM,CAAC,OAAO,OAAO,wBAAyB,SAAQ,UAAU;IAC9D,aAAa,IAAI,MAAM;IAIvB,cAAc,IAAI,MAAM;IAQlB,KAAK,CAAC,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAQnE"}

package/dist/options/heap/AnonymizeAuditOnlyOption.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 memory_lab
+ */
+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 AnonymizeAuditOnlyOption extends core_1.BaseOption {
+    getOptionName() {
+        return OptionConstant_1.default.optionNames.ANONYMIZE_AUDIT_ONLY;
+    }
+    getDescription() {
+        return ('report what would be redacted and what would be left in the clear, ' +
+            'without writing a file. Use it on a capture someone already ' +
+            'anonymized to check whether anything was missed');
+    }
+    parse(config, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const value = args[this.getOptionName()];
+            if (value != null && typeof value !== 'boolean') {
+                core_1.utils.haltOrThrow(`--${this.getOptionName()} is a flag and takes no value, got: ${value}`);
+            }
+        });
+    }
+}
+exports.default = AnonymizeAuditOnlyOption;

package/dist/options/heap/AnonymizeModeOption.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 memory_lab
+ */
+import type { ParsedArgs } from 'minimist';
+import type { MemLabConfig } from '@memlab/core';
+import { BaseOption } from '@memlab/core';
+export default class AnonymizeModeOption extends BaseOption {
+    getOptionName(): string;
+    getDescription(): string;
+    getExampleValues(): string[];
+    parse(config: MemLabConfig, args: ParsedArgs): Promise<void>;
+}
+//# sourceMappingURL=AnonymizeModeOption.d.ts.map

package/dist/options/heap/AnonymizeModeOption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnonymizeModeOption.d.ts","sourceRoot":"","sources":["../../../src/options/heap/AnonymizeModeOption.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,UAAU,CAAC;AACzC,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAC,UAAU,EAAQ,MAAM,cAAc,CAAC;AAK/C,MAAM,CAAC,OAAO,OAAO,mBAAoB,SAAQ,UAAU;IACzD,aAAa,IAAI,MAAM;IAIvB,cAAc,IAAI,MAAM;IAQxB,gBAAgB,IAAI,MAAM,EAAE;IAOtB,KAAK,CAAC,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAQnE"}

package/dist/options/heap/AnonymizeModeOption.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 memory_lab
+ */
+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"));
+const MODES = ['stable', 'uniform'];
+class AnonymizeModeOption extends core_1.BaseOption {
+    getOptionName() {
+        return OptionConstant_1.default.optionNames.ANONYMIZE_MODE;
+    }
+    getDescription() {
+        return ('set how redacted text is generated: ' +
+            '`stable` (default) keeps distinct values distinct so duplication ' +
+            'analysis stays accurate, `uniform` replaces every character with ?');
+    }
+    getExampleValues() {
+        // A copy: the same array backs the validation in `parse`, so handing the
+        // live reference to a caller lets a mutation there decide what this option
+        // accepts.
+        return [...MODES];
+    }
+    parse(config, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const value = args[this.getOptionName()];
+            if (value != null && !MODES.includes(String(value))) {
+                core_1.utils.haltOrThrow(`Invalid --${this.getOptionName()}: ${value}. Expected one of: ${MODES.join(', ')}`);
+            }
+        });
+    }
+}
+exports.default = AnonymizeModeOption;

package/dist/options/heap/AnonymizeOutputOption.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 memory_lab
+ */
+import type { ParsedArgs } from 'minimist';
+import type { MemLabConfig } from '@memlab/core';
+import { BaseOption } from '@memlab/core';
+export default class AnonymizeOutputOption extends BaseOption {
+    getOptionName(): string;
+    getDescription(): string;
+    getExampleValues(): string[];
+    parse(config: MemLabConfig, args: ParsedArgs): Promise<void>;
+}
+//# sourceMappingURL=AnonymizeOutputOption.d.ts.map

package/dist/options/heap/AnonymizeOutputOption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnonymizeOutputOption.d.ts","sourceRoot":"","sources":["../../../src/options/heap/AnonymizeOutputOption.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,UAAU,CAAC;AACzC,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAC,UAAU,EAAQ,MAAM,cAAc,CAAC;AAG/C,MAAM,CAAC,OAAO,OAAO,qBAAsB,SAAQ,UAAU;IAC3D,aAAa,IAAI,MAAM;IAIvB,cAAc,IAAI,MAAM;IAIxB,gBAAgB,IAAI,MAAM,EAAE;IAItB,KAAK,CAAC,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAMnE"}

package/dist/options/heap/AnonymizeOutputOption.js

@@ -0,0 +1,45 @@
+"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 memory_lab
+ */
+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 AnonymizeOutputOption extends core_1.BaseOption {
+    getOptionName() {
+        return OptionConstant_1.default.optionNames.ANONYMIZE_OUTPUT;
+    }
+    getDescription() {
+        return 'set file path to write the anonymized heap snapshot to';
+    }
+    getExampleValues() {
+        return ['/tmp/shareable.heapsnapshot'];
+    }
+    parse(config, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const value = args[this.getOptionName()];
+            if (value != null && typeof value !== 'string') {
+                core_1.utils.haltOrThrow(`Invalid --${this.getOptionName()} value: ${value}`);
+            }
+        });
+    }
+}
+exports.default = AnonymizeOutputOption;

package/dist/options/heap/AnonymizeSaltOption.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 memory_lab
+ */
+import type { ParsedArgs } from 'minimist';
+import type { MemLabConfig } from '@memlab/core';
+import { BaseOption } from '@memlab/core';
+export default class AnonymizeSaltOption extends BaseOption {
+    getOptionName(): string;
+    getDescription(): string;
+    getExampleValues(): string[];
+    parse(config: MemLabConfig, args: ParsedArgs): Promise<void>;
+}
+//# sourceMappingURL=AnonymizeSaltOption.d.ts.map

package/dist/options/heap/AnonymizeSaltOption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnonymizeSaltOption.d.ts","sourceRoot":"","sources":["../../../src/options/heap/AnonymizeSaltOption.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,UAAU,CAAC;AACzC,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAC,UAAU,EAAQ,MAAM,cAAc,CAAC;AAG/C,MAAM,CAAC,OAAO,OAAO,mBAAoB,SAAQ,UAAU;IACzD,aAAa,IAAI,MAAM;IAIvB,cAAc,IAAI,MAAM;IASxB,gBAAgB,IAAI,MAAM,EAAE;IAItB,KAAK,CAAC,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAMnE"}

package/dist/options/heap/AnonymizeSaltOption.js

@@ -0,0 +1,48 @@
+"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 memory_lab
+ */
+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 AnonymizeSaltOption extends core_1.BaseOption {
+    getOptionName() {
+        return OptionConstant_1.default.optionNames.ANONYMIZE_SALT;
+    }
+    getDescription() {
+        return ('set a salt for the replacement text. Without one the mapping is the ' +
+            'same in every capture, which keeps a set of snapshots comparable but ' +
+            'lets anyone holding a candidate value confirm it. Use the SAME salt ' +
+            'for every file in a set');
+    }
+    getExampleValues() {
+        return ['my-team-salt'];
+    }
+    parse(config, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const value = args[this.getOptionName()];
+            if (value != null && typeof value !== 'string') {
+                core_1.utils.haltOrThrow(`Invalid --${this.getOptionName()} value: ${value}`);
+            }
+        });
+    }
+}
+exports.default = AnonymizeSaltOption;

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

@@ -9,6 +9,10 @@
  */
 declare const optionConstants: {
     optionNames: {
+        ANONYMIZE_AUDIT_ONLY: string;
+        ANONYMIZE_MODE: string;
+        ANONYMIZE_OUTPUT: string;
+        ANONYMIZE_SALT: string;
         APP: string;
         BASELINE: string;
         CLEAN_UP_SNAPSHOT: string;
@@ -75,6 +79,10 @@ declare const optionConstants: {
 export type OptionConstants = typeof optionConstants;
 declare const _default: {
     optionNames: {
+        ANONYMIZE_AUDIT_ONLY: string;
+        ANONYMIZE_MODE: string;
+        ANONYMIZE_OUTPUT: string;
+        ANONYMIZE_SALT: string;
         APP: string;
         BASELINE: string;
         CLEAN_UP_SNAPSHOT: string;

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

@@ -1 +1 @@
-{"version":3,"file":"OptionConstant.d.ts","sourceRoot":"","sources":["../../../src/options/lib/OptionConstant.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAqEH,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGpB,CAAC;AACF,MAAM,MAAM,eAAe,GAAG,OAAO,eAAe,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACrD,wBAIE"}
+{"version":3,"file":"OptionConstant.d.ts","sourceRoot":"","sources":["../../../src/options/lib/OptionConstant.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAyEH,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGpB,CAAC;AACF,MAAM,MAAM,eAAe,GAAG,OAAO,eAAe,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACrD,wBAIE"}

package/dist/options/lib/OptionConstant.js

@@ -11,6 +11,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@memlab/core");
 const optionNames = {
+    ANONYMIZE_AUDIT_ONLY: 'audit-only',
+    ANONYMIZE_MODE: 'anonymize-mode',
+    ANONYMIZE_OUTPUT: 'output',
+    ANONYMIZE_SALT: 'anonymize-salt',
     APP: 'app',
     BASELINE: 'baseline',
     CLEAN_UP_SNAPSHOT: 'clean-up-snapshot',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memlab/cli",
-  "version": "2.0.4",
+  "version": "2.0.5",
   "license": "MIT",
   "description": "command line interface for memlab",
   "author": "Liang Gong <lgong@meta.com>",
@@ -26,10 +26,10 @@
     "access": "public"
   },
   "dependencies": {
-    "@memlab/api": "^2.0.4",
-    "@memlab/core": "^2.0.4",
-    "@memlab/e2e": "^2.0.4",
-    "@memlab/heap-analysis": "^2.0.4",
+    "@memlab/api": "^2.0.5",
+    "@memlab/core": "^2.0.5",
+    "@memlab/e2e": "^2.0.5",
+    "@memlab/heap-analysis": "^2.0.5",
     "ansi": "^0.3.1",
     "babar": "^0.2.0",
     "blessed": "^0.1.81",