@memlab/cli 1.0.0

package/README.md

@@ -0,0 +1,11 @@
+# `@memlab/cli`
+
+> TODO: description
+
+## Usage
+
+```
+const cli = require('@memlab/cli');
+
+// TODO: DEMONSTRATE API
+```

package/bin/memlab

@@ -0,0 +1,14 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+
+/**
+ * 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.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+
+var cli = require("@memlab/cli");
+cli.run();

package/dist/BaseCommand.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 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.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+import type { CLIOptions, Nullable } from '@memlab/core';
+import { BaseOption } from '@memlab/core';
+export declare enum CommandCategory {
+    COMMON = "COMMON",
+    DEV = "DEV",
+    MISC = "MISC"
+}
+declare abstract class Command {
+    getCommandName(): string;
+    private parentCommand;
+    setParentCommand(parent: BaseCommand): void;
+    getParentCommand(): Nullable<BaseCommand>;
+    getFullCommand(): string;
+    getFullOptionsFromPrerequisiteChain(): BaseOption[];
+}
+export default class BaseCommand extends Command {
+    getCommandName(): string;
+    getExamples(): string[];
+    getCategory(): CommandCategory;
+    getDescription(): string;
+    getPrerequisites(): BaseCommand[];
+    isInternalCommand(): boolean;
+    getOptions(): BaseOption[];
+    getSubCommands(): BaseCommand[];
+    run(_options: CLIOptions): Promise<void>;
+}
+export {};
+//# sourceMappingURL=BaseCommand.d.ts.map

package/dist/BaseCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseCommand.d.ts","sourceRoot":"","sources":["../src/BaseCommand.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAC,UAAU,EAAE,QAAQ,EAAC,MAAM,cAAc,CAAC;AACvD,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAC;AAExC,oBAAY,eAAe;IACzB,MAAM,WAAW;IACjB,GAAG,QAAQ;IACX,IAAI,SAAS;CACd;AAED,uBAAe,OAAO;IACpB,cAAc,IAAI,MAAM;IAUxB,OAAO,CAAC,aAAa,CAA+B;IAEpD,gBAAgB,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI;IAI3C,gBAAgB,IAAI,QAAQ,CAAC,WAAW,CAAC;IAIzC,cAAc,IAAI,MAAM;IAOxB,mCAAmC,IAAI,UAAU,EAAE;CAyBpD;AAED,MAAM,CAAC,OAAO,OAAO,WAAY,SAAQ,OAAO;IAG9C,cAAc,IAAI,MAAM;IAOxB,WAAW,IAAI,MAAM,EAAE;IAMvB,WAAW,IAAI,eAAe;IAM9B,cAAc,IAAI,MAAM;IAOxB,gBAAgB,IAAI,WAAW,EAAE;IAKjC,iBAAiB,IAAI,OAAO;IAK5B,UAAU,IAAI,UAAU,EAAE;IAQ1B,cAAc,IAAI,WAAW,EAAE;IAOzB,GAAG,CAAC,QAAQ,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAI/C"}

package/dist/BaseCommand.js

@@ -0,0 +1,132 @@
+"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.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandCategory = void 0;
+var CommandCategory;
+(function (CommandCategory) {
+    CommandCategory["COMMON"] = "COMMON";
+    CommandCategory["DEV"] = "DEV";
+    CommandCategory["MISC"] = "MISC";
+})(CommandCategory = exports.CommandCategory || (exports.CommandCategory = {}));
+class Command {
+    constructor() {
+        // If you are trying to add a new CLI command in MemLab,
+        // DO NOT OVERRIDE any property or method in below in this class.
+        // These methods are intended for internal orchestration
+        // purposes. All commands should extend BaseCommand,
+        // which contains the overridable hooks.
+        this.parentCommand = null;
+    }
+    getCommandName() {
+        const className = this.constructor.name;
+        throw new Error(`${className}.getCommandName is not implemented`);
+    }
+    setParentCommand(parent) {
+        this.parentCommand = parent;
+    }
+    getParentCommand() {
+        return this.parentCommand;
+    }
+    getFullCommand() {
+        const prefix = this.parentCommand
+            ? this.parentCommand.getFullCommand() + ' '
+            : '';
+        return prefix + this.getCommandName();
+    }
+    getFullOptionsFromPrerequisiteChain() {
+        const self = this;
+        const uniqueOptions = new Map();
+        const visitedCommands = new Set();
+        const queue = [self];
+        while (queue.length > 0) {
+            const cur = queue.shift();
+            if (cur) {
+                const options = cur.getOptions();
+                for (const option of options) {
+                    const optionName = option.getOptionName();
+                    if (!uniqueOptions.has(optionName)) {
+                        uniqueOptions.set(optionName, option);
+                    }
+                }
+                visitedCommands.add(cur.getCommandName());
+                for (const prereq of cur.getPrerequisites()) {
+                    if (!visitedCommands.has(prereq.getCommandName())) {
+                        queue.push(prereq);
+                    }
+                }
+            }
+        }
+        return [...uniqueOptions.values()];
+    }
+}
+class BaseCommand extends Command {
+    // The following terminal command will initiate with this command
+    // `memlab <command-name>`
+    getCommandName() {
+        const className = this.constructor.name;
+        throw new Error(`${className}.getCommandName is not implemented`);
+    }
+    // get a list of examples
+    // examples will be displayed in helper text
+    getExamples() {
+        return [];
+    }
+    // get command's category, commands under the same category
+    // are grouped together in helper text
+    getCategory() {
+        return CommandCategory.MISC;
+    }
+    // The description of this analysis will be printed by
+    // `memlab` or `memlab help`
+    getDescription() {
+        const className = this.constructor.name;
+        throw new Error(`${className}.getDescription is not implemented`);
+    }
+    // get a sequence of commands that must be executed before
+    // running this command
+    getPrerequisites() {
+        return [];
+    }
+    // internal command will not be listed in helper
+    isInternalCommand() {
+        return false;
+    }
+    // get options supported by this command
+    getOptions() {
+        return [];
+    }
+    // get subcommands of this command
+    // for example command 'A' has two sub-commands 'B' and 'C'
+    // CLI supports running in terminal: `memlab A B` or `memlab A C`
+    // The parent command will be executed before its subcommands
+    getSubCommands() {
+        return [];
+    }
+    // Callback for `memlab <command-name>`
+    // Do the memory analysis and print results in this callback
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    run(_options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const className = this.constructor.name;
+            throw new Error(`${className}.run is not implemented`);
+        });
+    }
+}
+exports.default = BaseCommand;

package/dist/Dispatcher.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+import type { ParsedArgs } from 'minimist';
+import { MemLabConfig, AnyRecord } from '@memlab/core';
+import BaseCommand from './BaseCommand';
+declare type RunCommandOptions = {
+    isPrerequisite?: boolean;
+    commandIndex?: number;
+    configFromOptions: AnyRecord;
+};
+declare class CommandDispatcher {
+    private modules;
+    private modulePaths;
+    private executedCommands;
+    private executingCommandStack;
+    constructor();
+    dispatch(args: ParsedArgs): Promise<void>;
+    parseOptions(command: BaseCommand, config: MemLabConfig, args: ParsedArgs): Promise<AnyRecord>;
+    private runCommand;
+    runSubCommandIfAny(command: BaseCommand, args: ParsedArgs, runCmdOpt: RunCommandOptions): Promise<void>;
+    private helper;
+    private registerBuiltInCommands;
+    private registerCommands;
+    private registerCommandsFromDir;
+}
+declare const _default: CommandDispatcher;
+export default _default;
+//# sourceMappingURL=Dispatcher.d.ts.map

package/dist/Dispatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Dispatcher.d.ts","sourceRoot":"","sources":["../src/Dispatcher.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,UAAU,CAAC;AACzC,OAAO,EAAC,YAAY,EAAE,SAAS,EAAQ,MAAM,cAAc,CAAC;AAM5D,OAAO,WAAW,MAAM,eAAe,CAAC;AAQxC,aAAK,iBAAiB,GAAG;IACvB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,SAAS,CAAC;CAC9B,CAAC;AAYF,cAAM,iBAAiB;IACrB,OAAO,CAAC,OAAO,CAA2B;IAC1C,OAAO,CAAC,WAAW,CAAsB;IACzC,OAAO,CAAC,gBAAgB,CAA0B;IAClD,OAAO,CAAC,qBAAqB,CAAqB;;IAU5C,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IA8BzC,YAAY,CAChB,OAAO,EAAE,WAAW,EACpB,MAAM,EAAE,YAAY,EACpB,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,SAAS,CAAC;YAYP,UAAU;IA+ClB,kBAAkB,CACtB,OAAO,EAAE,WAAW,EACpB,IAAI,EAAE,UAAU,EAChB,SAAS,EAAE,iBAAiB,GAC3B,OAAO,CAAC,IAAI,CAAC;YAuBF,MAAM;IAYpB,OAAO,CAAC,uBAAuB;IAI/B,OAAO,CAAC,gBAAgB;IAKxB,OAAO,CAAC,uBAAuB;CA6ChC;;AAED,wBAAuC"}

package/dist/Dispatcher.js

@@ -0,0 +1,205 @@
+"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.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+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 fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const core_2 = require("@memlab/core");
+const BaseCommand_1 = __importDefault(require("./BaseCommand"));
+const HelperCommand_1 = __importDefault(require("./commands/helper/HelperCommand"));
+const VerboseOption_1 = __importDefault(require("./options/VerboseOption"));
+const SetContinuousTestOption_1 = __importDefault(require("./options/SetContinuousTestOption"));
+const DebugOption_1 = __importDefault(require("./options/DebugOption"));
+const SilentOption_1 = __importDefault(require("./options/SilentOption"));
+const HelperOption_1 = __importDefault(require("./options/HelperOption"));
+const universalOptions = [
+    new HelperOption_1.default(),
+    new VerboseOption_1.default(),
+    new SetContinuousTestOption_1.default(),
+    new DebugOption_1.default(),
+    new SilentOption_1.default(),
+];
+const helperCommand = new HelperCommand_1.default();
+helperCommand.setUniversalOptions(universalOptions);
+class CommandDispatcher {
+    constructor() {
+        this.executedCommands = new Set();
+        this.executingCommandStack = [];
+        // auto load all command modules
+        this.modules = new Map();
+        this.modulePaths = new Map();
+        this.registerBuiltInCommands();
+        this.registerCommands();
+    }
+    dispatch(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // triggered by `memlab` (without specific command)
+            if (!args._ || !(args._.length >= 1)) {
+                core_2.info.error('\n  command argument missing');
+                yield this.helper(args);
+                return;
+            }
+            const command = args._[0];
+            // invalid command, e.g., `memlab xyz`
+            if (!this.modules.has(command)) {
+                yield this.helper(args);
+                return;
+            }
+            // `memlab <COMMAND> <SUB-COMMAND> -h`
+            if (args.h || args.help) {
+                yield this.helper(args);
+                return;
+            }
+            // `memlab help <COMMAND> <SUB-COMMAND>`
+            if (command === helperCommand.getCommandName()) {
+                yield this.helper(Object.assign(Object.assign({}, args), { _: args._.slice(1) }));
+                return;
+            }
+            const module = this.modules.get(command);
+            this.executedCommands = new Set();
+            this.executingCommandStack = [];
+            yield this.runCommand(module, args);
+        });
+    }
+    parseOptions(command, config, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = [...universalOptions, ...command.getOptions()];
+            const configFromOptions = Object.create(null);
+            for (const option of options) {
+                const ret = yield option.run(config, args);
+                if (ret) {
+                    Object.assign(configFromOptions, ret);
+                }
+            }
+            return configFromOptions;
+        });
+    }
+    runCommand(command, args, runCmdOpt = { configFromOptions: {} }) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const commandName = command.getCommandName();
+            // make sure commands on the prerequisite are only executed once
+            if (this.executedCommands.has(commandName)) {
+                return;
+            }
+            this.executingCommandStack.push(commandName);
+            // execute prerequisites
+            const prerequisites = command.getPrerequisites();
+            for (const prereq of prerequisites) {
+                const prereqName = prereq.getCommandName();
+                if (this.executingCommandStack.indexOf(prereqName) > 0) {
+                    throw new Error(`circular prerequisite reference: ${commandName} <--> ${prereqName}`);
+                }
+                yield this.runCommand(prereq, args, Object.assign({ isPrerequisite: true }, runCmdOpt));
+            }
+            // parse command line options
+            const c = yield this.parseOptions(command, core_2.config, args);
+            Object.assign(runCmdOpt.configFromOptions, c);
+            const { configFromOptions } = runCmdOpt;
+            // execute command
+            yield command.run({ cliArgs: args, configFromOptions });
+            if (runCmdOpt.isPrerequisite !== true) {
+                // execute subcommands
+                const commandIndex = ((_a = runCmdOpt.commandIndex) !== null && _a !== void 0 ? _a : 0) + 1;
+                const runSubCmdOpt = Object.assign(Object.assign({}, runCmdOpt), { commandIndex });
+                yield this.runSubCommandIfAny(command, args, runSubCmdOpt);
+            }
+            this.executingCommandStack.pop();
+            this.executedCommands.add(commandName);
+        });
+    }
+    runSubCommandIfAny(command, args, runCmdOpt) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const subCommandIndex = (_a = runCmdOpt.commandIndex) !== null && _a !== void 0 ? _a : 0;
+            if (args._.length <= subCommandIndex) {
+                return;
+            }
+            const subCommands = command.getSubCommands();
+            for (const subCommand of subCommands) {
+                if (subCommand.getCommandName() === args._[subCommandIndex]) {
+                    this.runCommand(subCommand, args, runCmdOpt);
+                    return;
+                }
+            }
+            core_2.info.error(`Invalid sub-command \`${args._[subCommandIndex]}\` of \`${command.getCommandName()}\`\n`);
+            yield this.helper(args, command);
+        });
+    }
+    helper(cliArgs, command = null) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield helperCommand.run({
+                modules: this.modules,
+                command,
+                cliArgs,
+                indent: '  ',
+            });
+        });
+    }
+    registerBuiltInCommands() {
+        // TBA
+    }
+    registerCommands() {
+        const modulesDir = path_1.default.resolve(__dirname, 'commands');
+        this.registerCommandsFromDir(modulesDir);
+    }
+    registerCommandsFromDir(modulesDir) {
+        const moduleFiles = fs_1.default.readdirSync(modulesDir);
+        for (const moduleFile of moduleFiles) {
+            const modulePath = path_1.default.join(modulesDir, moduleFile);
+            // recursively import modules from subdirectories
+            if (fs_1.default.lstatSync(modulePath).isDirectory()) {
+                this.registerCommandsFromDir(modulePath);
+                continue;
+            }
+            // only import modules files ends with with Command.js
+            if (!moduleFile.endsWith('Command.js')) {
+                continue;
+            }
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const module = require(modulePath);
+            const moduleConstructor = typeof module.default === 'function' ? module.default : module;
+            const moduleInstance = new moduleConstructor();
+            if (!(moduleInstance instanceof BaseCommand_1.default)) {
+                core_1.utils.haltOrThrow('loading a command that does not extend BaseCommand');
+            }
+            const commandName = moduleInstance.getCommandName();
+            if (this.modules.has(commandName)) {
+                // resolve conflict
+                const ossCommandLoaded = !core_2.fileManager.isWithinInternalDirectory(this.modulePaths.get(commandName));
+                const loadingOssCommand = !core_2.fileManager.isWithinInternalDirectory(modulePath);
+                if (ossCommandLoaded === loadingOssCommand) {
+                    // when both commands are open source or neither are open source
+                    core_2.info.midLevel(`MemLab command ${commandName} is already registered`);
+                }
+                else if (!ossCommandLoaded && loadingOssCommand) {
+                    // when open source command tries to overwrite non-open source command
+                    continue;
+                }
+            }
+            this.modules.set(commandName, moduleInstance);
+            this.modulePaths.set(commandName, modulePath);
+        }
+    }
+}
+exports.default = new CommandDispatcher();

package/dist/TypesThirdParty.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+/// <reference types="node" />
+declare module 'html-inline' {
+    interface InlinerParams {
+        basedir: string;
+    }
+    export default function Inliner(params: InlinerParams): NodeJS.ReadWriteStream;
+}
+//# sourceMappingURL=TypesThirdParty.d.ts.map

package/dist/TypesThirdParty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypesThirdParty.d.ts","sourceRoot":"","sources":["../src/TypesThirdParty.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;;AAEH,OAAO,QAAQ,aAAa,CAAC;IAC3B,UAAU,aAAa;QACrB,OAAO,EAAE,MAAM,CAAC;KACjB;IACD,MAAM,CAAC,OAAO,UAAU,OAAO,CAC7B,MAAM,EAAE,aAAa,GACpB,MAAM,CAAC,eAAe,CAAC;CAC3B"}

package/dist/TypesThirdParty.js

@@ -0,0 +1,10 @@
+"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.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */

package/dist/commands/CleanLoggerDataCommand.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.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+import type { CLIOptions } from '@memlab/core';
+import BaseCommand from '../BaseCommand';
+import { BaseOption } from '@memlab/core';
+export default class CleanTraceDataCommand extends BaseCommand {
+    getCommandName(): string;
+    getDescription(): string;
+    isInternalCommand(): boolean;
+    getOptions(): BaseOption[];
+    run(options: CLIOptions): Promise<void>;
+}
+//# sourceMappingURL=CleanLoggerDataCommand.d.ts.map

package/dist/commands/CleanLoggerDataCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CleanLoggerDataCommand.d.ts","sourceRoot":"","sources":["../../src/commands/CleanLoggerDataCommand.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAC,UAAU,EAAW,MAAM,cAAc,CAAC;AAEvD,OAAO,WAAW,MAAM,gBAAgB,CAAC;AACzC,OAAO,EAAc,UAAU,EAAC,MAAM,cAAc,CAAC;AAIrD,MAAM,CAAC,OAAO,OAAO,qBAAsB,SAAQ,WAAW;IAC5D,cAAc,IAAI,MAAM;IAIxB,cAAc,IAAI,MAAM;IAIxB,iBAAiB,IAAI,OAAO;IAI5B,UAAU,IAAI,UAAU,EAAE;IAIpB,GAAG,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAK9C"}

package/dist/commands/CleanLoggerDataCommand.js

@@ -0,0 +1,50 @@
+"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.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+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 BaseCommand_1 = __importDefault(require("../BaseCommand"));
+const core_1 = require("@memlab/core");
+const SetWorkingDirectoryOption_1 = __importDefault(require("../options/SetWorkingDirectoryOption"));
+const InitDirectoryCommand_1 = __importDefault(require("./InitDirectoryCommand"));
+class CleanTraceDataCommand extends BaseCommand_1.default {
+    getCommandName() {
+        return 'clear-trace-data';
+    }
+    getDescription() {
+        return 'remove all retainer trace data generated from memlab runs';
+    }
+    isInternalCommand() {
+        return true;
+    }
+    getOptions() {
+        return [new SetWorkingDirectoryOption_1.default()];
+    }
+    run(options) {
+        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.emptyTraceLogDataDir({ workDir });
+            yield new InitDirectoryCommand_1.default().run(options);
+        });
+    }
+}
+exports.default = CleanTraceDataCommand;

package/dist/commands/CleanRunDataCommand.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.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+import type { CLIOptions } from '@memlab/core';
+import BaseCommand from '../BaseCommand';
+import { BaseOption } from '@memlab/core';
+export default class CleanRunDataCommand extends BaseCommand {
+    getCommandName(): string;
+    getDescription(): string;
+    isInternalCommand(): boolean;
+    getOptions(): BaseOption[];
+    run(options: CLIOptions): Promise<void>;
+}
+//# sourceMappingURL=CleanRunDataCommand.d.ts.map

package/dist/commands/CleanRunDataCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CleanRunDataCommand.d.ts","sourceRoot":"","sources":["../../src/commands/CleanRunDataCommand.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAC,UAAU,EAAW,MAAM,cAAc,CAAC;AAEvD,OAAO,WAAW,MAAM,gBAAgB,CAAC;AACzC,OAAO,EAAc,UAAU,EAAC,MAAM,cAAc,CAAC;AAGrD,MAAM,CAAC,OAAO,OAAO,mBAAoB,SAAQ,WAAW;IAC1D,cAAc,IAAI,MAAM;IAIxB,cAAc,IAAI,MAAM;IAIxB,iBAAiB,IAAI,OAAO;IAI5B,UAAU,IAAI,UAAU,EAAE;IAIpB,GAAG,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAI9C"}

package/dist/commands/CleanRunDataCommand.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.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+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 BaseCommand_1 = __importDefault(require("../BaseCommand"));
+const core_1 = require("@memlab/core");
+const SetWorkingDirectoryOption_1 = __importDefault(require("../options/SetWorkingDirectoryOption"));
+class CleanRunDataCommand extends BaseCommand_1.default {
+    getCommandName() {
+        return 'clear-run-data';
+    }
+    getDescription() {
+        return 'remove all web page E2E data generated from memlab runs';
+    }
+    isInternalCommand() {
+        return true;
+    }
+    getOptions() {
+        return [new SetWorkingDirectoryOption_1.default()];
+    }
+    run(options) {
+        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.clearDataDirs({ workDir });
+        });
+    }
+}
+exports.default = CleanRunDataCommand;

package/dist/commands/InitDirectoryCommand.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.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+import type { CLIOptions } from '@memlab/core';
+import BaseCommand from '../BaseCommand';
+import { BaseOption } from '@memlab/core';
+export default class InitDirectoryCommand extends BaseCommand {
+    getCommandName(): string;
+    getDescription(): string;
+    isInternalCommand(): boolean;
+    getOptions(): BaseOption[];
+    run(options: CLIOptions): Promise<void>;
+}
+//# sourceMappingURL=InitDirectoryCommand.d.ts.map

package/dist/commands/InitDirectoryCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InitDirectoryCommand.d.ts","sourceRoot":"","sources":["../../src/commands/InitDirectoryCommand.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAC,UAAU,EAAW,MAAM,cAAc,CAAC;AAEvD,OAAO,WAAW,MAAM,gBAAgB,CAAC;AACzC,OAAO,EAAsB,UAAU,EAAC,MAAM,cAAc,CAAC;AAG7D,MAAM,CAAC,OAAO,OAAO,oBAAqB,SAAQ,WAAW;IAC3D,cAAc,IAAI,MAAM;IAIxB,cAAc,IAAI,MAAM;IAIxB,iBAAiB,IAAI,OAAO;IAI5B,UAAU,IAAI,UAAU,EAAE;IAIpB,GAAG,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAI9C"}