moonwall 1.0.0-dev.0

package/dist/cli/cmds/runTests.js

@@ -0,0 +1,257 @@
+import chalk from "chalk";
+import path from "node:path";
+import { startVitest } from "vitest/node";
+import { createLogger } from "../../util/index.js";
+import { clearNodeLogs } from "../internal/cmdFunctions/tempLogs.js";
+import { commonChecks } from "../internal/launcherCommon.js";
+import { cacheConfig, importAsyncConfig, loadEnvVars } from "../lib/configReader.js";
+import { MoonwallContext, contextCreator, runNetworkOnly } from "../lib/globalContext.js";
+import { shardManager } from "../lib/shardManager.js";
+import { findTestFilesMatchingPattern } from "../internal/testIdParser.js";
+const logger = createLogger({ name: "runner" });
+/**
+ * Pre-filters test files by scanning for suite/test IDs matching the pattern.
+ * Uses ast-grep's parallel file search for efficient parsing.
+ * Returns matching file paths, or undefined if no pattern (let vitest handle all).
+ */
+async function filterTestFilesByPattern(testDirs, includePatterns, pattern) {
+    if (!pattern)
+        return undefined;
+    const patternRegex = new RegExp(pattern, "i");
+    const matches = await findTestFilesMatchingPattern(testDirs, includePatterns, patternRegex);
+    if (matches.length === 0) {
+        throw new Error(`No test files found matching pattern "${pattern}". ` +
+            `Check that the suite/test ID exists (e.g., D01, D01E01).`);
+    }
+    return matches;
+}
+export async function testCmd(envName, additionalArgs) {
+    await cacheConfig();
+    const globalConfig = await importAsyncConfig();
+    const env = globalConfig.environments.find(({ name }) => name === envName);
+    process.env.MOON_TEST_ENV = envName;
+    // Initialize sharding configuration
+    shardManager.initializeSharding(additionalArgs?.shard);
+    if (!env) {
+        const envList = globalConfig.environments
+            .map((env) => env.name)
+            .sort()
+            .join(", ");
+        throw new Error(`No environment found in config for: ${chalk.bgWhiteBright.blackBright(envName)}\n Environments defined in config are: ${envList}\n`);
+    }
+    loadEnvVars();
+    await commonChecks(env);
+    if ((env.foundation.type === "dev" && !env.foundation.launchSpec[0].retainAllLogs) ||
+        (env.foundation.type === "chopsticks" && !env.foundation.launchSpec[0].retainAllLogs)) {
+        clearNodeLogs();
+    }
+    if (env.foundation.type === "zombie") {
+        process.env.MOON_EXIT = "true";
+    }
+    const vitest = await executeTests(env, additionalArgs);
+    const failed = vitest.state
+        .getFiles()
+        .filter((file) => file.result && file.result.state === "fail");
+    if (failed.length === 0) {
+        logger.info("✅ All tests passed");
+        global.MOONWALL_TERMINATION_REASON = "tests finished";
+        return true;
+    }
+    logger.warn("❌ Some tests failed");
+    global.MOONWALL_TERMINATION_REASON = "tests failed";
+    return false;
+}
+export async function executeTests(env, testRunArgs) {
+    return new Promise(async (resolve, reject) => {
+        const globalConfig = await importAsyncConfig();
+        if (env.foundation.type === "read_only") {
+            try {
+                if (!process.env.MOON_TEST_ENV) {
+                    throw new Error("MOON_TEST_ENV not set");
+                }
+                const ctx = await contextCreator();
+                const chainData = ctx.providers
+                    .filter((provider) => provider.type === "polkadotJs" && provider.name.includes("para"))
+                    .map((provider) => {
+                    return {
+                        [provider.name]: {
+                            rtName: provider.greet().rtName,
+                            rtVersion: provider.greet().rtVersion,
+                        },
+                    };
+                });
+                // TODO: Extend/develop this feature to respect para/relay chain specifications
+                if (chainData.length < 1) {
+                    throw "Could not read runtime name or version \nTo fix: ensure moonwall config has a polkadotJs provider with a name containing 'para'";
+                }
+                const { rtVersion, rtName } = Object.values(chainData[0])[0];
+                process.env.MOON_RTVERSION = rtVersion;
+                process.env.MOON_RTNAME = rtName;
+            }
+            catch (e) {
+                logger.error(e);
+            }
+            finally {
+                await MoonwallContext.destroy();
+            }
+        }
+        const additionalArgs = { ...testRunArgs };
+        const vitestOptions = testRunArgs?.vitestPassthroughArgs?.reduce((acc, arg) => {
+            const [key, value] = arg.split("=");
+            return {
+                ...acc,
+                [key]: Number(value) || value,
+            };
+        }, {});
+        // transform  in regexp pattern
+        if (env.skipTests && env.skipTests.length > 0) {
+            // the final pattern will look like this: "^((?!SO00T02|SM00T01|SM00T03).)*$"
+            additionalArgs.testNamePattern = `^((?!${env.skipTests?.map((test) => `${test.name}`).join("|")}).)*$`;
+        }
+        const options = new VitestOptionsBuilder()
+            .setReporters(env.reporters || ["default"])
+            .setOutputFile(env.reportFile)
+            .setName(env.name)
+            .setTimeout(env.timeout || globalConfig.defaultTestTimeout)
+            .setInclude(env.include || ["**/*{test,spec,test_,test-}*{ts,mts,cts}"])
+            .addThreadConfig(env.multiThreads)
+            .setCacheImports(env.cacheImports)
+            .addVitestPassthroughArgs(env.vitestArgs)
+            .build();
+        if (globalConfig.environments.find((env) => env.name === process.env.MOON_TEST_ENV)?.foundation
+            .type === "zombie") {
+            await runNetworkOnly();
+            process.env.MOON_RECYCLE = "true";
+        }
+        try {
+            const testFileDir = additionalArgs?.subDirectory !== undefined
+                ? env.testFileDir.map((folder) => path.join(folder, additionalArgs.subDirectory || "error"))
+                : env.testFileDir;
+            const folders = testFileDir.map((folder) => path.join(".", folder, "/"));
+            const includePatterns = env.include || ["**/*{test,spec,test_,test-}*{ts,mts,cts}"];
+            // Pre-filter test files by scanning for suite IDs matching the pattern
+            // This avoids loading all files in vitest just to discover which ones match
+            const filteredFiles = await filterTestFilesByPattern(folders, includePatterns, additionalArgs?.testNamePattern);
+            const optionsToUse = {
+                ...options,
+                ...additionalArgs,
+                ...vitestOptions,
+                ...(filteredFiles ? { include: filteredFiles.map((f) => path.resolve(f)) } : {}),
+            };
+            if (env.printVitestOptions) {
+                logger.info(`Options to use: ${JSON.stringify(optionsToUse, null, 2)}`);
+            }
+            const foldersToUse = filteredFiles ? ["."] : folders;
+            resolve((await startVitest("test", foldersToUse, optionsToUse)));
+        }
+        catch (e) {
+            logger.error(e);
+            reject(e);
+        }
+    });
+}
+const filterList = ["<empty line>", "", "stdout | unknown test"];
+class VitestOptionsBuilder {
+    options = {
+        watch: false,
+        globals: true,
+        reporters: ["default"],
+        passWithNoTests: false,
+        deps: {
+            optimizer: { ssr: { enabled: false }, web: { enabled: false } },
+        },
+        env: {
+            NODE_OPTIONS: "--no-warnings --no-deprecation",
+        },
+        include: ["**/*{test,spec,test_,test-}*{ts,mts,cts}"],
+        onConsoleLog(log) {
+            if (filterList.includes(log.trim()))
+                return false;
+            if (log.includes("has multiple versions, ensure that there is only one installed.")) {
+                return false;
+            }
+        },
+    };
+    setName(name) {
+        this.options.name = name;
+        return this;
+    }
+    setReporters(reporters) {
+        const modified = reporters.includes("basic")
+            ? reporters.map((r) => r === "basic" ? ["default", { summary: false }] : r)
+            : reporters;
+        this.options.reporters = modified;
+        return this;
+    }
+    setOutputFile(file) {
+        if (!file) {
+            logger.info("No output file specified, skipping");
+            return this;
+        }
+        this.options.outputFile = file;
+        return this;
+    }
+    setTimeout(timeout) {
+        this.options.testTimeout = timeout;
+        this.options.hookTimeout = timeout;
+        return this;
+    }
+    setInclude(include) {
+        this.options.include = include;
+        return this;
+    }
+    addVitestPassthroughArgs(args) {
+        this.options = { ...this.options, ...args };
+        return this;
+    }
+    addThreadConfig(threads = false) {
+        this.options.fileParallelism = false;
+        this.options.pool = "forks";
+        // Vitest 4: pool options are now top-level (isolate, maxWorkers)
+        this.options.isolate = true;
+        this.options.maxWorkers = 3;
+        if (threads === true && process.env.MOON_RECYCLE !== "true") {
+            this.options.fileParallelism = true;
+        }
+        if (typeof threads === "number" && process.env.MOON_RECYCLE !== "true") {
+            this.options.fileParallelism = true;
+            this.options.maxWorkers = threads;
+        }
+        if (typeof threads === "object" && process.env.MOON_RECYCLE !== "true") {
+            // Vitest 4 format: { pool: "forks", maxWorkers: 1, isolate: false, ... }
+            const config = threads;
+            if (!["threads", "forks", "vmThreads", "typescript"].includes(config.pool)) {
+                throw new Error(`Invalid pool type: ${config.pool}`);
+            }
+            this.options.fileParallelism = true;
+            this.options.pool = config.pool;
+            if (config.maxWorkers !== undefined) {
+                this.options.maxWorkers = config.maxWorkers;
+            }
+            if (config.isolate !== undefined) {
+                this.options.isolate = config.isolate;
+            }
+            if (config.memoryLimit !== undefined) {
+                this.options.vmMemoryLimit = config.memoryLimit;
+            }
+        }
+        return this;
+    }
+    setCacheImports(enabled) {
+        if (enabled) {
+            this.options.deps = {
+                optimizer: {
+                    ssr: {
+                        enabled: true,
+                        include: ["viem", "ethers"],
+                    },
+                    web: { enabled: false },
+                },
+            };
+        }
+        return this;
+    }
+    build() {
+        return this.options;
+    }
+}

package/dist/cli/internal/cmdFunctions/downloader.d.ts

@@ -0,0 +1,4 @@
+import { SingleBar } from "cli-progress";
+export declare function downloader(url: string, outputPath: string): Promise<void>;
+export declare function initializeProgressBar(): SingleBar;
+//# sourceMappingURL=downloader.d.ts.map

package/dist/cli/internal/cmdFunctions/downloader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"downloader.d.ts","sourceRoot":"","sources":["../../../../src/cli/internal/cmdFunctions/downloader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAW,MAAM,cAAc,CAAC;AAUlD,wBAAsB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA+C/E;AAED,wBAAgB,qBAAqB,IAAI,SAAS,CAQjD"}

package/dist/cli/internal/cmdFunctions/downloader.js

@@ -0,0 +1,49 @@
+import { SingleBar, Presets } from "cli-progress";
+import fs from "node:fs";
+import { Readable } from "node:stream";
+export async function downloader(url, outputPath) {
+    const tempPath = `${outputPath}.tmp`;
+    const writeStream = fs.createWriteStream(tempPath);
+    let transferredBytes = 0;
+    if (url.startsWith("ws")) {
+        console.log("You've passed a WebSocket URL to fetch. Is this intended?");
+    }
+    const headers = {};
+    if (process.env.GITHUB_TOKEN) {
+        headers.Authorization = `Bearer ${process.env.GITHUB_TOKEN}`;
+    }
+    const response = await fetch(url, { headers });
+    if (!response.body) {
+        throw new Error("No response body");
+    }
+    const readStream = Readable.fromWeb(response.body);
+    const contentLength = Number.parseInt(response.headers.get("Content-Length") || "0", 10);
+    const progressBar = initializeProgressBar();
+    progressBar.start(contentLength, 0);
+    readStream.pipe(writeStream);
+    await new Promise((resolve, reject) => {
+        readStream.on("data", (chunk) => {
+            transferredBytes += chunk.length;
+            progressBar.update(transferredBytes);
+        });
+        readStream.on("end", () => {
+            writeStream.end();
+            progressBar.stop();
+            process.stdout.write("  💾 Saving binary artifact...");
+            writeStream.close(() => resolve());
+        });
+        readStream.on("error", (error) => {
+            reject(error);
+        });
+    });
+    fs.writeFileSync(outputPath, fs.readFileSync(tempPath));
+    fs.rmSync(tempPath);
+}
+export function initializeProgressBar() {
+    const options = {
+        etaAsynchronousUpdate: true,
+        etaBuffer: 40,
+        format: "Downloading: [{bar}] {percentage}% | ETA: {eta_formatted} | {value}/{total}",
+    };
+    return new SingleBar(options, Presets.shades_classic);
+}

package/dist/cli/internal/cmdFunctions/fetchArtifact.d.ts

@@ -0,0 +1,10 @@
+export type fetchArtifactArgs = {
+    bin: string;
+    ver?: string;
+    path?: string;
+    overwrite?: boolean;
+    outputName?: string;
+};
+export declare function fetchArtifact(args: fetchArtifactArgs): Promise<void>;
+export declare function getVersions(name: string, runtime?: boolean): Promise<string[]>;
+//# sourceMappingURL=fetchArtifact.d.ts.map

package/dist/cli/internal/cmdFunctions/fetchArtifact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchArtifact.d.ts","sourceRoot":"","sources":["../../../../src/cli/internal/cmdFunctions/fetchArtifact.ts"],"names":[],"mappings":"AAuBA,MAAM,MAAM,iBAAiB,GAAG;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,wBAAsB,aAAa,CAAC,IAAI,EAAE,iBAAiB,iBA0G1D;AAED,wBAAsB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,UAAQ,qBAuC9D"}

package/dist/cli/internal/cmdFunctions/fetchArtifact.js

@@ -0,0 +1,145 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import semver from "semver";
+import chalk from "chalk";
+import { runTask } from "../processHelpers.js";
+import { minimatch } from "minimatch";
+import { downloader } from "./downloader.js";
+import { allReposAsync, standardRepos } from "../../lib/repoDefinitions/index.js";
+import { execSync } from "node:child_process";
+import { configExists } from "../../lib/configReader.js";
+import { Octokit } from "@octokit/rest";
+import { confirm } from "@inquirer/prompts";
+const octokit = new Octokit({
+    baseUrl: "https://api.github.com",
+    log: {
+        debug: () => { },
+        info: () => { },
+        warn: console.warn,
+        error: console.error,
+    },
+});
+export async function fetchArtifact(args) {
+    if (args.path && (await fs.access(args.path).catch(() => true))) {
+        console.log("Folder not exists, creating");
+        fs.mkdir(args.path);
+    }
+    const checkOverwrite = async (path) => {
+        try {
+            await fs.access(path, fs.constants.R_OK);
+            if (args.overwrite) {
+                console.log("File exists, overwriting ...");
+            }
+            else {
+                const cont = await confirm({
+                    message: "File exists, do you want to overwrite?",
+                });
+                if (!cont) {
+                    return false;
+                }
+            }
+        }
+        catch {
+            console.log("File does not exist, creating ...");
+        }
+        return true;
+    };
+    const binary = args.bin;
+    const repos = (await configExists()) ? await allReposAsync() : standardRepos();
+    const repo = repos.find((network) => network.binaries.find((bin) => bin.name === binary));
+    if (!repo) {
+        throw new Error(`Downloading ${binary} unsupported`);
+    }
+    const enteredPath = args.path ? args.path : "tmp/";
+    const releases = await octokit.rest.repos.listReleases({
+        owner: repo.ghAuthor,
+        repo: repo.ghRepo,
+    });
+    if (releases.status !== 200 || releases.data.length === 0) {
+        throw new Error(`No releases found for ${repo.ghAuthor}.${repo.ghRepo}, try again later.`);
+    }
+    const release = binary.includes("-runtime")
+        ? releases.data.find((release) => {
+            if (args.ver === "latest") {
+                return release.assets.find((asset) => asset.name.includes(binary));
+            }
+            return release.assets.find((asset) => asset.name === `${binary}-${args.ver}.wasm`);
+        })
+        : args.ver === "latest"
+            ? releases.data.find((release) => release.assets.find((asset) => asset.name === binary))
+            : releases.data
+                .filter((release) => release.tag_name.includes(args.ver || ""))
+                .find((release) => release.assets.find((asset) => minimatch(asset.name, binary)));
+    if (!release) {
+        throw new Error(`Release not found for ${args.ver}`);
+    }
+    const asset = binary.includes("-runtime")
+        ? release.assets.find((asset) => asset.name.includes(binary) && asset.name.includes("wasm"))
+        : release.assets.find((asset) => minimatch(asset.name, binary));
+    if (!asset) {
+        throw new Error(`Asset not found for ${binary}`);
+    }
+    if (!binary.includes("-runtime")) {
+        const url = asset.browser_download_url;
+        const filename = path.basename(url);
+        const binPath = args.outputName ? args.outputName : path.join("./", enteredPath, filename);
+        if ((await checkOverwrite(binPath)) === false) {
+            console.log("User chose not to overwrite existing file, exiting.");
+            return;
+        }
+        await downloader(url, binPath);
+        await fs.chmod(binPath, "755");
+        if (filename.endsWith(".tar.gz")) {
+            const outputBuffer = execSync(`tar -xzvf ${binPath}`);
+            const cleaned = outputBuffer.toString().split("\n")[0].split("/")[0];
+            const version = (await runTask(`./${cleaned} --version`)).trim();
+            process.stdout.write(` ${chalk.green(version.trim())} ✓\n`);
+            return;
+        }
+        const version = (await runTask(`./${binPath} --version`)).trim();
+        process.stdout.write(`${path.basename(binPath)} ${chalk.green(version.trim())} ✓\n`);
+        return;
+    }
+    const binaryPath = args.outputName
+        ? args.outputName
+        : path.join("./", args.path || "", `${args.bin}-${args.ver}.wasm`);
+    if ((await checkOverwrite(binaryPath)) === false) {
+        console.log("User chose not to overwrite existing file, exiting.");
+        return;
+    }
+    await downloader(asset.browser_download_url, binaryPath);
+    await fs.chmod(binaryPath, "755");
+    process.stdout.write(` ${chalk.green("done")} ✓\n`);
+    return;
+}
+export async function getVersions(name, runtime = false) {
+    const repos = (await configExists()) ? await allReposAsync() : standardRepos();
+    const repo = repos.find((network) => network.binaries.find((bin) => bin.name === name));
+    if (!repo) {
+        throw new Error(`Network not found for ${name}`);
+    }
+    const releases = await octokit.rest.repos.listReleases({
+        owner: repo.ghAuthor,
+        repo: repo.ghRepo,
+    });
+    if (releases.status !== 200 || releases.data.length === 0) {
+        throw new Error(`No releases found for ${repo.ghAuthor}.${repo.ghRepo}, try again later.`);
+    }
+    const versions = releases.data
+        .map((release) => {
+        let tag = release.tag_name;
+        if (release.tag_name.includes("v")) {
+            tag = tag.split("v")[1];
+        }
+        if (tag.includes("-rc")) {
+            tag = tag.split("-rc")[0];
+        }
+        return tag;
+    })
+        .filter((version) => (runtime && version.includes("runtime")) || (!runtime && !version.includes("runtime")))
+        .map((version) => version.replace("runtime-", ""));
+    const set = new Set(versions);
+    return runtime
+        ? [...set]
+        : [...set].sort((a, b) => (semver.valid(a) && semver.valid(b) ? semver.rcompare(a, b) : a));
+}

package/dist/cli/internal/cmdFunctions/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./downloader.js";
+export * from "./fetchArtifact.js";
+export * from "./initialisation.js";
+export * from "./tempLogs.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/internal/cmdFunctions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/cli/internal/cmdFunctions/index.ts"],"names":[],"mappings":"AAAA,gCAAgC;AAChC,mCAAmC;AACnC,oCAAoC;AACpC,8BAA8B"}

package/dist/cli/internal/cmdFunctions/index.js

@@ -0,0 +1,4 @@
+export * from "./downloader.js";
+export * from "./fetchArtifact.js";
+export * from "./initialisation.js";
+export * from "./tempLogs.js";

package/dist/cli/internal/cmdFunctions/initialisation.d.ts

@@ -0,0 +1,20 @@
+import type { FoundationType, MoonwallConfig } from "../../../api/types/index.js";
+export declare function createFolders(): Promise<void>;
+export declare function generateConfig(argv: {
+    acceptAllDefaults?: boolean;
+}): Promise<void>;
+export declare function createConfig(options: {
+    label: string;
+    timeout: number;
+    environmentName: string;
+    foundation: FoundationType;
+    testDir: string;
+}): MoonwallConfig;
+export declare function createSampleConfig(options: {
+    label: string;
+    timeout: number;
+    environmentName: string;
+    foundation: FoundationType;
+    testDir: string;
+}): MoonwallConfig;
+//# sourceMappingURL=initialisation.d.ts.map

package/dist/cli/internal/cmdFunctions/initialisation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initialisation.d.ts","sourceRoot":"","sources":["../../../../src/cli/internal/cmdFunctions/initialisation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,oCAAoC;AAIlF,wBAAsB,aAAa,kBAIlC;AAED,wBAAsB,cAAc,CAAC,IAAI,EAAE;IAAE,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAAE,iBA+EzE;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,cAAc,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;CACjB,GAAG,cAAc,CAcjB;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE;IAC1C,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,cAAc,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;CACjB,GAAG,cAAc,CAwBjB"}

package/dist/cli/internal/cmdFunctions/initialisation.js

@@ -0,0 +1,150 @@
+import fs from "node:fs/promises";
+import { confirm, input, number } from "@inquirer/prompts";
+export async function createFolders() {
+    await fs.mkdir("scripts").catch(() => "scripts folder already exists, skipping");
+    await fs.mkdir("tests").catch(() => "tests folder already exists, skipping");
+    await fs.mkdir("tmp").catch(() => "tmp folder already exists, skipping");
+}
+export async function generateConfig(argv) {
+    let answers;
+    try {
+        await fs.access("moonwall.config.json");
+        console.log("ℹ️  Config file already exists at this location. Quitting.");
+        return;
+    }
+    catch (_) {
+        // File does not exist — proceed with configuration
+    }
+    if (argv.acceptAllDefaults) {
+        answers = {
+            label: "moonwall_config",
+            timeout: 30000,
+            environmentName: "default_env",
+            foundation: "dev",
+            testDir: "tests/default/",
+        };
+    }
+    else {
+        while (true) {
+            answers = {
+                label: await input({
+                    message: "Provide a label for the config file",
+                    default: "moonwall_config",
+                }),
+                timeout: (await number({
+                    message: "Provide a global timeout value",
+                    default: 30000,
+                })) ?? 30000,
+                environmentName: await input({
+                    message: "Provide a name for this environment",
+                    default: "default_env",
+                }),
+                foundation: "dev",
+                testDir: await input({
+                    message: "Provide the path for where tests for this environment are kept",
+                    default: "tests/default/",
+                }),
+            };
+            const proceed = await confirm({
+                message: "Would you like to generate this config? (no to restart from beginning)",
+            });
+            if (proceed) {
+                break;
+            }
+            console.log("Restarting the configuration process...");
+        }
+    }
+    const config = createSampleConfig({
+        label: answers.label,
+        timeout: answers.timeout,
+        environmentName: answers.environmentName,
+        foundation: answers.foundation,
+        testDir: answers.testDir,
+    });
+    const JSONBlob = JSON.stringify(config, null, 3);
+    await fs.writeFile("moonwall.config.json", JSONBlob, "utf-8");
+    process.env.MOON_CONFIG_PATH = "./moonwall.config.json";
+    await createSampleTest(answers.testDir);
+    console.log("Test directory created at: ", answers.testDir);
+    console.log(`You can now add tests to this directory and run them with 'pnpm moonwall test ${answers.environmentName}'`);
+    console.log("Goodbye! 👋");
+}
+export function createConfig(options) {
+    return {
+        label: options.label,
+        defaultTestTimeout: options.timeout,
+        environments: [
+            {
+                name: options.environmentName,
+                testFileDir: [options.testDir],
+                foundation: {
+                    type: options.foundation,
+                },
+            },
+        ],
+    };
+}
+export function createSampleConfig(options) {
+    return {
+        $schema: "https://raw.githubusercontent.com/Moonsong-Labs/moonwall/main/config_schema.json",
+        label: options.label,
+        defaultTestTimeout: options.timeout,
+        environments: [
+            {
+                name: options.environmentName,
+                testFileDir: [options.testDir],
+                multiThreads: false,
+                foundation: {
+                    type: "dev",
+                    launchSpec: [
+                        {
+                            name: "moonbeam",
+                            useDocker: true,
+                            newRpcBehaviour: true,
+                            binPath: "moonbeamfoundation/moonbeam",
+                        },
+                    ],
+                },
+            },
+        ],
+    };
+}
+async function createSampleTest(directory) {
+    await fs.mkdir(directory, { recursive: true });
+    await fs.writeFile(`${directory}/sample.test.ts`, sampleTest, "utf-8");
+}
+const sampleTest = `import { describeSuite, expect } from "moonwall";
+
+describeSuite({
+  id: "B01",
+  title: "Sample test suite for moonbeam network",
+  foundationMethods: "dev",
+  testCases: ({ context, it }) => {
+
+    const ALITH_ADDRESS = "0xf24FF3a9CF04c71Dbc94D0b566f7A27B94566cac"
+
+    it({
+      id: "T01",
+      title: "Test that API is connected correctly",
+      test: async () => {
+        const chainName = context.pjsApi.consts.system.version.specName.toString();
+        const specVersion = context.pjsApi.consts.system.version.specVersion.toNumber();
+        expect(chainName.length).toBeGreaterThan(0)
+        expect(chainName).toBe("moonbase")
+        expect(specVersion).toBeGreaterThan(0)
+      },
+    });
+
+    it({
+      id: "T02",
+      title: "Test that chain queries can be made",
+      test: async () => {
+        const balance = (await context.pjsApi.query.system.account(ALITH_ADDRESS)).data.free
+        expect(balance.toBigInt()).toBeGreaterThan(0n)
+      },
+    });
+
+  },
+});
+
+`;

package/dist/cli/internal/cmdFunctions/tempLogs.d.ts

@@ -0,0 +1,3 @@
+export declare function clearNodeLogs(silent?: boolean): void;
+export declare function reportLogLocation(silent?: boolean): string;
+//# sourceMappingURL=tempLogs.d.ts.map

package/dist/cli/internal/cmdFunctions/tempLogs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tempLogs.d.ts","sourceRoot":"","sources":["../../../../src/cli/internal/cmdFunctions/tempLogs.ts"],"names":[],"mappings":"AAGA,wBAAgB,aAAa,CAAC,MAAM,UAAO,QAa1C;AAED,wBAAgB,iBAAiB,CAAC,MAAM,UAAQ,UA2B/C"}