moonwall 1.0.0-dev.0

package/dist/cli/cmds/main.js

@@ -0,0 +1,336 @@
+import chalk from "chalk";
+import clear from "clear";
+import colors from "colors";
+import fs from "node:fs";
+import cfonts from "cfonts";
+import path from "node:path";
+import { SemVer, lt } from "semver";
+import pkg from "../../../package.json" with { type: "json" };
+import { createFolders, deriveTestIds, executeScript, fetchArtifact, generateConfig, getVersions, } from "../internal/index.js";
+import { configExists, importAsyncConfig } from "../lib/configReader.js";
+import { allReposAsync, standardRepos } from "../lib/repoDefinitions/index.js";
+import { runNetworkCmd } from "./runNetwork.js";
+import { testCmd } from "./runTests.js";
+import { Octokit } from "@octokit/rest";
+import { checkbox, confirm, input, select, Separator } from "@inquirer/prompts";
+const octokit = new Octokit({
+    baseUrl: "https://api.github.com",
+    log: {
+        debug: () => { },
+        info: () => { },
+        warn: console.warn,
+        error: console.error,
+    },
+});
+export async function main() {
+    for (;;) {
+        const globalConfig = (await configExists()) ? await importAsyncConfig() : undefined;
+        clear();
+        await printIntro();
+        if (await mainMenu(globalConfig)) {
+            break;
+        }
+    }
+    process.stdout.write("Goodbye! 👋\n");
+}
+async function mainMenu(config) {
+    const configPresent = config !== undefined;
+    const menuChoice = await select({
+        message: "Main Menu - Please select one of the following:",
+        default: "init",
+        pageSize: 12,
+        choices: !configPresent
+            ? [
+                {
+                    name: !configPresent
+                        ? "1) Initialise:                         Generate a new Moonwall Config File"
+                        : chalk.dim("1) Initialise:                       ✅  CONFIG ALREADY GENERATED"),
+                    value: "init",
+                },
+                {
+                    name: "2) Artifact Downloader:                Fetch artifacts (x86) from GitHub repos",
+                    value: "download",
+                },
+                {
+                    name: "3) Quit Application",
+                    value: "quit",
+                },
+            ]
+            : [
+                {
+                    name: "1) Execute Script:                     Run scripts placed in your config defined script directory",
+                    value: "exec",
+                },
+                {
+                    name: "2) Network Launcher & Toolbox:         Launch network, access tools: tail logs, interactive tests etc",
+                    value: "run",
+                },
+                {
+                    name: "3) Test Suite Execution:               Run automated tests, start network if needed",
+                    value: "test",
+                },
+                {
+                    name: "4) Artifact Downloader:                Fetch artifacts (x86) from GitHub repos",
+                    value: "download",
+                },
+                {
+                    name: "5) Rename TestIDs:                     Rename test id prefixes based on position in the directory tree",
+                    value: "derive",
+                },
+                {
+                    name: "6) Quit Application",
+                    value: "quit",
+                },
+            ],
+    });
+    switch (menuChoice) {
+        case "init":
+            await generateConfig({});
+            await createFolders();
+            return false;
+        case "run": {
+            if (!config) {
+                throw new Error("Config not defined, this is a defect please raise it.");
+            }
+            const chosenRunEnv = await chooseRunEnv(config);
+            process.env.MOON_RUN_SCRIPTS = "true";
+            if (chosenRunEnv.envName !== "back") {
+                await runNetworkCmd(chosenRunEnv);
+            }
+            return true;
+        }
+        case "test": {
+            if (!config) {
+                throw new Error("Config not defined, this is a defect please raise it.");
+            }
+            const chosenTestEnv = await chooseTestEnv(config);
+            if (chosenTestEnv.envName !== "back") {
+                process.env.MOON_RUN_SCRIPTS = "true";
+                await testCmd(chosenTestEnv.envName);
+                await input({
+                    message: `ℹ️  Test run for ${chalk.bgWhiteBright.black(chosenTestEnv.envName)} has been completed. Press any key to continue...\n`,
+                });
+            }
+            return true;
+        }
+        case "download":
+            await resolveDownloadChoice();
+            return false;
+        case "quit":
+            return await resolveQuitChoice();
+        case "exec": {
+            if (!config) {
+                throw new Error("Config not defined, this is a defect please raise it.");
+            }
+            return await resolveExecChoice(config);
+        }
+        case "derive": {
+            clear();
+            const rootDir = await input({
+                message: "Enter the root testSuites directory to process:",
+                default: "suites",
+            });
+            await deriveTestIds({ rootDir });
+            await input({
+                message: `ℹ️  Renaming task for ${chalk.bold(`/${rootDir}`)} has been completed. Press any key to continue...\n`,
+            });
+            return false;
+        }
+        default:
+            throw new Error("Invalid choice");
+    }
+}
+async function resolveExecChoice(config) {
+    const scriptDir = config.scriptsDir;
+    if (!scriptDir) {
+        await input({
+            message: `ℹ️  No scriptDir property defined at ${chalk.bgWhiteBright.black("moonwall.config.json")}\n Press any key to continue...\n`,
+        });
+        return false;
+    }
+    if (!fs.existsSync(scriptDir)) {
+        await input({
+            message: `ℹ️  No scriptDir found at at ${chalk.bgWhiteBright.black(path.join(process.cwd(), scriptDir))}\n Press any key to continue...\n`,
+        });
+        return false;
+    }
+    const files = await fs.promises.readdir(scriptDir);
+    if (!files) {
+        await input({
+            message: `ℹ️  No scripts found at ${chalk.bgWhiteBright.black(path.join(process.cwd(), config.scriptsDir || ""))}\n Press any key to continue...\n`,
+        });
+    }
+    const choices = files.map((file) => {
+        const ext = getExtString(file);
+        return { name: `${ext}:    ${path.basename(file, "")}`, value: file };
+    });
+    for (;;) {
+        const selections = await checkbox({
+            message: "Select which scripts you'd like to run (press ↩️ with none selected to go 🔙)\n",
+            choices,
+        });
+        if (selections.length === 0) {
+            const noneSelected = await confirm({
+                message: "No scripts have been selected to run, do you wish to exit?",
+                default: true,
+            });
+            if (noneSelected) {
+                return false;
+            }
+            continue;
+        }
+        for (const script of selections) {
+            const args = await input({
+                message: `Enter any arguments for ${chalk.bgWhiteBright.black(script)} (press enter for none)`,
+            });
+            await executeScript(script, args);
+        }
+        await input({
+            message: "Press any key to continue...\n",
+        });
+        return false;
+    }
+}
+async function resolveDownloadChoice() {
+    const repos = (await configExists()) ? await allReposAsync() : standardRepos();
+    const binList = repos.reduce((acc, curr) => {
+        acc.push(...curr.binaries.flatMap((bin) => bin.name));
+        acc.push(new Separator());
+        acc.push("Back");
+        acc.push(new Separator());
+        return acc;
+    }, []);
+    for (;;) {
+        const firstChoice = await select({
+            message: "Download - which artifact?",
+            choices: binList,
+        });
+        if (firstChoice === "Back") {
+            return;
+        }
+        const versions = await getVersions(firstChoice, firstChoice.includes("runtime"));
+        const chooseversion = await select({
+            default: "latest",
+            message: "Download - which version?",
+            choices: [...versions, new Separator(), "Back", new Separator()],
+        });
+        if (chooseversion === "Back") {
+            continue;
+        }
+        const chooseLocation = await input({
+            message: "Download - where would you like it placed?",
+            default: "./tmp",
+        });
+        const result = await confirm({
+            message: `You are about to download ${chalk.bgWhite.blackBright(firstChoice)} v-${chalk.bgWhite.blackBright(chooseversion)} to: ${chalk.bgWhite.blackBright(chooseLocation)}.\n Would you like to continue? `,
+            default: true,
+        });
+        if (result === false) {
+            continue;
+        }
+        await fetchArtifact({
+            bin: firstChoice,
+            ver: chooseversion,
+            path: chooseLocation,
+        });
+        return;
+    }
+}
+const chooseTestEnv = async (config) => {
+    const envs = config.environments
+        .map((a) => ({
+        name: `[${a.foundation.type}] ${a.name}${a.description ? `: \t\t${a.description}` : ""}`,
+        value: a.name,
+        disabled: false,
+    }))
+        .sort((a, b) => (a.name > b.name ? -1 : +1));
+    envs.push(...[new Separator(), { name: "Back", value: "back" }, new Separator()]);
+    const envName = (await select({
+        message: "Select a environment to run",
+        pageSize: 12,
+        choices: envs,
+    }));
+    return { envName };
+};
+const chooseRunEnv = async (config) => {
+    const envs = config.environments.map((a) => {
+        const result = { name: "", value: a.name, disabled: false };
+        if (a.foundation.type === "dev" ||
+            a.foundation.type === "chopsticks" ||
+            a.foundation.type === "zombie") {
+            result.name = `[${a.foundation.type}] ${a.name}${a.description ? `: \t\t${a.description}` : ""}`;
+        }
+        else {
+            result.name = chalk.dim(`[${a.foundation.type}] ${a.name}     NO NETWORK TO RUN`);
+            result.disabled = true;
+        }
+        return result;
+    });
+    const choices = [
+        ...envs.filter(({ disabled }) => disabled === false).sort((a, b) => (a.name > b.name ? 1 : -1)),
+        new Separator(),
+        ...envs.filter(({ disabled }) => disabled === true).sort((a, b) => (a.name > b.name ? 1 : -1)),
+        new Separator(),
+        { name: "Back", value: "back" },
+        new Separator(),
+    ];
+    const envName = (await select({
+        message: "Select a environment to run",
+        pageSize: 12,
+        choices,
+    }));
+    return { envName };
+};
+const resolveQuitChoice = async () => {
+    const result = await confirm({
+        message: "Are you sure you want to Quit?",
+        default: false,
+    });
+    return result;
+};
+const printIntro = async () => {
+    const currentVersion = new SemVer(pkg.version);
+    let remoteVersion = "";
+    try {
+        const releases = await octokit.rest.repos.listReleases({
+            owner: "moonsong-labs",
+            repo: "moonwall",
+        });
+        if (releases.status !== 200 || releases.data.length === 0) {
+            throw new Error("No releases found for moonsong-labs.moonwall, try again later.");
+        }
+        const json = releases.data;
+        remoteVersion =
+            json.find((a) => a.tag_name.includes("moonwall@"))?.tag_name.split("@")[2] || "unknown";
+    }
+    catch (error) {
+        remoteVersion = "unknown";
+        console.error(`Fetch Error: ${error}`);
+    }
+    cfonts.say("Moonwall", {
+        gradient: ["#FF66FF", "#9966FF", "#99CCFF", "#99FFFF", "#33FFFF", "#3366FF"],
+        transitionGradient: true,
+        lineHeight: 4,
+    });
+    const versionText = remoteVersion !== "unknown" && lt(currentVersion, new SemVer(remoteVersion))
+        ? `V${currentVersion.version} (New version ${remoteVersion} available!) ${currentVersion.version}`
+        : `V${currentVersion.version}`;
+    const dividerLength = 90;
+    const leftPadding = Math.floor((dividerLength - versionText.length) / 2);
+    const rightPadding = dividerLength - versionText.length - leftPadding;
+    const formattedDivider = `${colors.rainbow("=".repeat(leftPadding))}${chalk.bgCyan.grey(versionText)}${colors.rainbow("=".repeat(rightPadding))}\n`;
+    console.log(formattedDivider);
+};
+const getExtString = (file) => {
+    const ext = path.extname(file);
+    switch (ext) {
+        case ".js":
+            return chalk.bgYellow.black(ext);
+        case ".ts":
+            return chalk.bgBlue.black(ext);
+        case ".sh":
+            return chalk.bgGreen.black(ext);
+        default:
+            return chalk.bgRed.black(ext);
+    }
+};

package/dist/cli/cmds/runNetwork.d.ts

@@ -0,0 +1,3 @@
+import type { RunCommandArgs } from "./entrypoint.js";
+export declare function runNetworkCmd(args: RunCommandArgs): Promise<void>;
+//# sourceMappingURL=runNetwork.d.ts.map

package/dist/cli/cmds/runNetwork.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runNetwork.d.ts","sourceRoot":"","sources":["../../../src/cli/cmds/runNetwork.tsx"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAAE,cAAc,EAAE,wBAAwB;AAKtD,wBAAsB,aAAa,CAAC,IAAI,EAAE,cAAc,iBAsKvD"}

package/dist/cli/cmds/runNetwork.js

@@ -0,0 +1,292 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import chalk from "chalk";
+import clear from "clear";
+import { promises as fsPromises } from "node:fs";
+import { render } from "ink";
+import { LogViewer as LogStreamer } from "./components/LogViewer.js";
+import { parse } from "yaml";
+import { clearNodeLogs, reportLogLocation } from "../internal/cmdFunctions/tempLogs.js";
+import { commonChecks } from "../internal/launcherCommon.js";
+import { cacheConfig, getEnvironmentFromConfig, importAsyncConfig, loadEnvVars, } from "../lib/configReader.js";
+import { MoonwallContext, runNetworkOnly } from "../lib/globalContext.js";
+import { shardManager } from "../lib/shardManager.js";
+import { resolveChopsticksInteractiveCmdChoice, resolveDevInteractiveCmdChoice, resolveZombieInteractiveCmdChoice, } from "./interactiveCmds/index.js";
+import { executeTests } from "./runTests.js";
+import { confirm, input, select, Separator } from "@inquirer/prompts";
+let lastSelected = 0;
+export async function runNetworkCmd(args) {
+    await cacheConfig();
+    process.env.MOON_TEST_ENV = args.envName;
+    if (args.subDirectory) {
+        process.env.MOON_SUBDIR = args.subDirectory;
+    }
+    // Initialize shard configuration (defaults to no sharding for run command)
+    shardManager.initializeSharding();
+    const globalConfig = await importAsyncConfig();
+    const env = globalConfig.environments.find(({ name }) => name === args.envName);
+    if (!env) {
+        const envList = globalConfig.environments
+            .map((env) => env.name)
+            .sort()
+            .join(", ");
+        throw new Error(`No environment found in config for: ${chalk.bgWhiteBright.blackBright(args.envName)}\n Environments defined in config are: ${envList}\n`);
+    }
+    loadEnvVars();
+    await commonChecks(env);
+    const testFileDirs = env.testFileDir;
+    const foundation = env.foundation.type;
+    if ((env.foundation.type === "dev" && !env.foundation.launchSpec[0].retainAllLogs) ||
+        (env.foundation.type === "chopsticks" && !env.foundation.launchSpec[0].retainAllLogs)) {
+        clearNodeLogs();
+    }
+    await runNetworkOnly();
+    clear();
+    const portsList = await reportServicePorts();
+    reportLogLocation();
+    for (const { port } of portsList) {
+        console.log(`  🖥️   https://polkadot.js.org/apps/?rpc=ws%3A%2F%2F127.0.0.1%3A${port}`);
+    }
+    if (process.env.MOON_SUBDIR) {
+        console.log(chalk.bgWhite.blackBright(`📍 Subdirectory Filter: ${process.env.MOON_SUBDIR}`));
+    }
+    if (!args.GrepTest) {
+        await input({ message: "✅  Press any key to continue...\n" });
+    }
+    else {
+        process.env.MOON_RECYCLE = "true";
+        process.env.MOON_GREP = args.GrepTest;
+        await executeTests(env, { testNamePattern: args.GrepTest, subDirectory: args.subDirectory });
+    }
+    mainloop: for (;;) {
+        const menuChoice = await select({
+            message: `Environment : ${chalk.bgGray.cyanBright(args.envName)}\nPlease select a choice: `,
+            default: lastSelected,
+            pageSize: 10,
+            choices: [
+                {
+                    name: "Tail:      Print the logs of the current running node to this console",
+                    value: 1,
+                    short: "tail",
+                },
+                {
+                    name: `Info:      Display Information about this environment ${args.envName}`,
+                    value: 2,
+                    short: "info",
+                },
+                {
+                    name: foundation === "dev" || foundation === "chopsticks" || foundation === "zombie"
+                        ? `Command:   Run command on network (${chalk.bgGrey.cyanBright(foundation)})`
+                        : chalk.dim(`Not applicable for foundation type (${chalk.bgGrey.cyanBright(foundation)})`),
+                    value: 3,
+                    short: "cmd",
+                    disabled: foundation !== "dev" && foundation !== "chopsticks" && foundation !== "zombie",
+                },
+                {
+                    name: testFileDirs.length > 0
+                        ? `Test:      Execute tests registered for this environment   (${chalk.bgGrey.cyanBright(testFileDirs)})`
+                        : chalk.dim("Test:    NO TESTS SPECIFIED"),
+                    value: 4,
+                    disabled: !(testFileDirs.length > 0),
+                    short: "test",
+                },
+                {
+                    name: testFileDirs.length > 0
+                        ? `GrepTest:  Execute individual test(s) based on grepping the name / ID (${chalk.bgGrey.cyanBright(testFileDirs)})`
+                        : chalk.dim("Test:    NO TESTS SPECIFIED"),
+                    value: 5,
+                    disabled: !(testFileDirs.length > 0),
+                    short: "grep",
+                },
+                new Separator(),
+                {
+                    name: "Quit:      Close network and quit the application",
+                    value: 6,
+                    short: "quit",
+                },
+            ],
+        });
+        const env = globalConfig.environments.find(({ name }) => name === args.envName);
+        if (!env) {
+            throw new Error("Environment not found in config. This is an error, please raise.");
+        }
+        switch (menuChoice) {
+            case 1:
+                clear();
+                await resolveTailChoice(env);
+                lastSelected = 0;
+                clear();
+                break;
+            case 2:
+                await resolveInfoChoice(env);
+                lastSelected = 1;
+                break;
+            case 3:
+                await resolveCommandChoice();
+                lastSelected = 2;
+                break;
+            case 4:
+                await resolveTestChoice(env);
+                lastSelected = 3;
+                break;
+            case 5:
+                await resolveGrepChoice(env);
+                lastSelected = 4;
+                break;
+            case 6: {
+                const quit = await confirm({
+                    message: "ℹ️  Are you sure you'd like to close network and quit? \n",
+                    default: false,
+                });
+                if (quit === true) {
+                    break mainloop;
+                }
+                break;
+            }
+            default:
+                throw new Error("invalid value");
+        }
+    }
+    await MoonwallContext.destroy();
+}
+const reportServicePorts = async () => {
+    const ctx = await MoonwallContext.getContext();
+    const portsList = [];
+    const config = getEnvironmentFromConfig();
+    switch (config.foundation.type) {
+        case "dev": {
+            const args = ctx.environment.nodes[0].args;
+            const explicitPortArg = args.find((a) => a.includes("ws-port") || a.includes("rpc-port"));
+            const port = explicitPortArg ? explicitPortArg.split("=")[1] : "9944";
+            portsList.push({ port, name: "dev" });
+            break;
+        }
+        case "chopsticks": {
+            portsList.push(...(await Promise.all(config.foundation.launchSpec.map(async ({ configPath, name }) => {
+                const yaml = parse((await fsPromises.readFile(configPath)).toString());
+                return { name, port: yaml.port || "8000" };
+            }))));
+            break;
+        }
+        case "zombie": {
+            const zombieNetwork = ctx.zombieNetwork;
+            if (!zombieNetwork) {
+                throw new Error("Zombie network not found. This is a bug, please raise an issue.");
+            }
+            for (const { wsUri, name } of zombieNetwork.relay) {
+                portsList.push({ name, port: wsUri.split("ws://127.0.0.1:")[1] });
+            }
+            for (const paraId of Object.keys(zombieNetwork.paras)) {
+                for (const { wsUri, name } of zombieNetwork.paras[paraId].nodes) {
+                    portsList.push({ name, port: wsUri.split("ws://127.0.0.1:")[1] });
+                }
+            }
+        }
+    }
+    for (const { port, name } of portsList) {
+        console.log(`  🌐  Node ${name} has started, listening on ports - Websocket: ${port}`);
+    }
+    return portsList;
+};
+const resolveCommandChoice = async () => {
+    const ctx = await (await MoonwallContext.getContext()).connectEnvironment();
+    switch (ctx.foundation) {
+        case "dev":
+            await resolveDevInteractiveCmdChoice();
+            break;
+        case "chopsticks":
+            await resolveChopsticksInteractiveCmdChoice();
+            break;
+        case "zombie":
+            await resolveZombieInteractiveCmdChoice();
+            break;
+    }
+};
+const resolveInfoChoice = async (env) => {
+    console.log(chalk.bgWhite.blackBright("Node Launch args:"));
+    console.dir((await MoonwallContext.getContext()).environment, {
+        depth: null,
+    });
+    console.log(chalk.bgWhite.blackBright("Launch Spec in Config File:"));
+    console.dir(env, { depth: null });
+    const portsList = await reportServicePorts();
+    reportLogLocation();
+    for (const { port } of portsList) {
+        console.log(`  🖥️   https://polkadot.js.org/apps/?rpc=ws%3A%2F%2F127.0.0.1%3A${port}`);
+    }
+    if (process.env.MOON_SUBDIR) {
+        console.log(chalk.bgWhite.blackBright(`📍 Subdirectory Filter: ${process.env.MOON_SUBDIR}`));
+    }
+};
+const resolveGrepChoice = async (env, silent = false) => {
+    const grep = await input({
+        message: "What pattern would you like to filter for (ID/Title): ",
+        default: process.env.MOON_GREP || "D01T01",
+    });
+    process.env.MOON_RECYCLE = "true";
+    process.env.MOON_GREP = grep;
+    const opts = {
+        testNamePattern: grep,
+        silent,
+        subDirectory: process.env.MOON_SUBDIR,
+    };
+    if (silent) {
+        opts.reporters = ["dot"];
+    }
+    return await executeTests(env, opts);
+};
+const resolveTestChoice = async (env, silent = false) => {
+    process.env.MOON_RECYCLE = "true";
+    const opts = { silent, subDirectory: process.env.MOON_SUBDIR };
+    if (silent) {
+        opts.reporters = ["dot"];
+    }
+    return await executeTests(env, opts);
+};
+const resolveTailChoice = async (env) => {
+    let zombieNodePointer = 0;
+    let switchNode;
+    let zombieNodes;
+    if (process.env.MOON_ZOMBIE_NODES) {
+        zombieNodes = process.env.MOON_ZOMBIE_NODES.split("|");
+    }
+    for (;;) {
+        switchNode = false;
+        await new Promise(async (resolve) => {
+            const logFilePath = process.env.MOON_ZOMBIE_NODES
+                ? `${process.env.MOON_ZOMBIE_DIR}/${zombieNodes?.[zombieNodePointer]}.log`
+                : process.env.MOON_LOG_LOCATION;
+            if (!logFilePath) {
+                throw new Error("No log file path resolved, this should not happen. Please raise defect");
+            }
+            // Resume stdin before rendering with ink - @inquirer/prompts pauses stdin
+            // after completing, which prevents ink's useInput from receiving keyboard events
+            if (process.stdin.isPaused()) {
+                process.stdin.resume();
+            }
+            const { waitUntilExit } = render(_jsx(LogStreamer, { env: env, logFilePath: logFilePath, onExit: () => resolve(), onNextLog: zombieNodes
+                    ? () => {
+                        switchNode = true;
+                        zombieNodePointer = (zombieNodePointer + 1) % zombieNodes.length;
+                        resolve();
+                    }
+                    : undefined, onPrevLog: zombieNodes
+                    ? () => {
+                        switchNode = true;
+                        zombieNodePointer =
+                            (zombieNodePointer - 1 + zombieNodes.length) % zombieNodes.length;
+                        resolve();
+                    }
+                    : undefined, zombieInfo: zombieNodes
+                    ? {
+                        currentNode: zombieNodes[zombieNodePointer],
+                        position: zombieNodePointer + 1,
+                        total: zombieNodes.length,
+                    }
+                    : undefined }));
+            await waitUntilExit();
+        });
+        if (!switchNode) {
+            break;
+        }
+    }
+};

package/dist/cli/cmds/runTests.d.ts

@@ -0,0 +1,12 @@
+import type { Environment } from "../../api/types/index.js";
+import type { TestUserConfig, Vitest } from "vitest/node";
+export declare function testCmd(envName: string, additionalArgs?: testRunArgs): Promise<boolean>;
+export type testRunArgs = {
+    testNamePattern?: string;
+    subDirectory?: string;
+    shard?: string;
+    update?: boolean;
+    vitestPassthroughArgs?: string[];
+};
+export declare function executeTests(env: Environment, testRunArgs?: testRunArgs & TestUserConfig): Promise<Vitest>;
+//# sourceMappingURL=runTests.d.ts.map

package/dist/cli/cmds/runTests.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runTests.d.ts","sourceRoot":"","sources":["../../../src/cli/cmds/runTests.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,iCAAiC;AAG5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAmC1D,wBAAsB,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,CAgD7F;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,qBAAqB,CAAC,EAAE,MAAM,EAAE,CAAC;CAClC,CAAC;AAEF,wBAAsB,YAAY,CAAC,GAAG,EAAE,WAAW,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,cAAc,mBA2G9F"}