moonwall 1.0.0-dev.0

package/dist/cli/cmds/components/LogViewer.js

@@ -0,0 +1,171 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState, useEffect, useCallback } from "react";
+import { Box, Text, useInput, useApp } from "ink";
+import fs from "node:fs";
+import { executeTests } from "../runTests.js";
+export const LogViewer = ({ env, logFilePath, onExit, onNextLog, onPrevLog, zombieInfo, }) => {
+    const [lines, setLines] = useState([]);
+    const [paused, setPaused] = useState(false);
+    const [scrollOffset, setScrollOffset] = useState(0);
+    const [testing, setTesting] = useState(false);
+    const [grepMode, setGrepMode] = useState(false);
+    const [grepInput, setGrepInput] = useState(process.env.MOON_GREP ?? "");
+    const [testOutput, setTestOutput] = useState([]);
+    const [testRun, setTestRun] = useState(null);
+    const { exit } = useApp();
+    const terminalRows = process.stdout.rows ?? 24;
+    const terminalCols = process.stdout.columns ?? 80;
+    const showTestPanel = testing || testOutput.length > 0 || testRun !== null;
+    const testPanelHeight = showTestPanel
+        ? Math.min(10, Math.max(5, Math.floor(terminalRows / 3)))
+        : 0;
+    const logPanelHeight = terminalRows - testPanelHeight - (grepMode ? 5 : 4);
+    const visibleLines = Math.max(3, logPanelHeight);
+    const testOutputLines = Math.max(1, testPanelHeight - 3);
+    const readLogFile = useCallback(() => {
+        if (paused || !fs.existsSync(logFilePath))
+            return;
+        try {
+            const content = fs.readFileSync(logFilePath, "utf-8");
+            setLines(content.split("\n").filter((l) => l.trim()));
+        }
+        catch {
+            // File may be temporarily unavailable
+        }
+    }, [logFilePath, paused]);
+    useEffect(() => {
+        readLogFile();
+        if (paused)
+            return;
+        fs.watchFile(logFilePath, { interval: 100 }, readLogFile);
+        return () => {
+            fs.unwatchFile(logFilePath);
+        };
+    }, [logFilePath, paused, readLogFile]);
+    // Hide cursor
+    useEffect(() => {
+        process.stdout.write("\x1B[?25l");
+        return () => {
+            process.stdout.write("\x1B[?25h");
+        };
+    }, []);
+    const runTests = useCallback(async (pattern) => {
+        if (testing)
+            return;
+        setTesting(true);
+        setTestOutput([]);
+        setTestRun({ pattern, done: false });
+        process.env.MOON_RECYCLE = "true";
+        if (pattern) {
+            process.env.MOON_GREP = pattern;
+        }
+        try {
+            await executeTests(env, {
+                testNamePattern: pattern,
+                silent: true,
+                subDirectory: process.env.MOON_SUBDIR,
+                reporters: ["dot"],
+                onConsoleLog: (log) => {
+                    if (log.includes("has multiple versions"))
+                        return false;
+                    setTestOutput((prev) => [...prev.slice(-50), log]);
+                    return false;
+                },
+            });
+        }
+        catch {
+            // Test failures are expected
+        }
+        finally {
+            setTesting(false);
+            setTestRun((prev) => (prev ? { ...prev, done: true } : null));
+        }
+    }, [env, testing]);
+    useInput((input, key) => {
+        // Grep mode input handling
+        if (grepMode) {
+            if (key.escape) {
+                setGrepMode(false);
+                return;
+            }
+            if (key.return) {
+                const pattern = grepInput.trim();
+                if (pattern) {
+                    setGrepMode(false);
+                    runTests(pattern);
+                }
+                return;
+            }
+            if (key.backspace || key.delete) {
+                setGrepInput((prev) => prev.slice(0, -1));
+                return;
+            }
+            if (input && !key.ctrl && !key.meta) {
+                setGrepInput((prev) => prev + input);
+            }
+            return;
+        }
+        // Normal mode
+        if (input === "q") {
+            fs.unwatchFile(logFilePath);
+            onExit();
+            exit();
+            return;
+        }
+        if (input === "p") {
+            setPaused(true);
+        }
+        if (input === "r") {
+            setPaused(false);
+            setScrollOffset(0);
+        }
+        if (input === "t" && !testing) {
+            runTests();
+        }
+        if (input === "T" && !testing) {
+            setGrepMode(true);
+        }
+        if (input === "c") {
+            setTestOutput([]);
+            setTestRun(null);
+        }
+        const maxOffset = Math.max(0, lines.length - visibleLines);
+        if (key.pageUp) {
+            setScrollOffset((prev) => Math.min(prev + visibleLines, maxOffset));
+        }
+        if (key.pageDown) {
+            setScrollOffset((prev) => Math.max(prev - visibleLines, 0));
+        }
+        if (input === "g") {
+            setScrollOffset(maxOffset);
+        }
+        if (input === "G") {
+            setScrollOffset(0);
+        }
+        if (input === "," && onNextLog) {
+            fs.unwatchFile(logFilePath);
+            onNextLog();
+            exit();
+        }
+        if (input === "." && onPrevLog) {
+            fs.unwatchFile(logFilePath);
+            onPrevLog();
+            exit();
+        }
+    });
+    const startIndex = Math.max(0, lines.length - visibleLines - scrollOffset);
+    const visible = lines.slice(startIndex, startIndex + visibleLines);
+    const shortPath = logFilePath.split("/").slice(-2).join("/");
+    const visibleTestOutput = testOutput.slice(-testOutputLines);
+    const getLineColor = (line) => {
+        if (/error|panic|fail/i.test(line))
+            return "red";
+        if (/warn/i.test(line))
+            return "yellow";
+        return "white";
+    };
+    const truncate = (text, maxLen) => {
+        return text.length > maxLen ? `${text.slice(0, maxLen - 1)}…` : text;
+    };
+    return (_jsxs(Box, { flexDirection: "column", height: terminalRows, children: [_jsxs(Box, { borderStyle: "single", borderColor: paused ? "yellow" : "green", paddingX: 1, children: [_jsx(Text, { color: paused ? "yellow" : "green", bold: true, children: paused ? "PAUSED" : "LIVE" }), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: shortPath }), _jsx(Text, { children: " " }), _jsxs(Text, { dimColor: true, children: ["(", lines.length, " lines)"] }), zombieInfo && (_jsxs(_Fragment, { children: [_jsx(Text, { children: " " }), _jsxs(Text, { color: "cyan", children: ["[", zombieInfo.currentNode, " ", zombieInfo.position, "/", zombieInfo.total, "]"] })] })), scrollOffset > 0 && (_jsxs(_Fragment, { children: [_jsx(Text, { children: " " }), _jsxs(Text, { color: "yellow", children: ["\u2191", scrollOffset] })] }))] }), _jsxs(Box, { flexDirection: "column", height: visibleLines, paddingX: 1, children: [visible.map((line, i) => (_jsx(Text, { color: getLineColor(line), wrap: "truncate", children: truncate(line, terminalCols - 4) }, startIndex + i))), visible.length === 0 && _jsx(Text, { dimColor: true, children: "Waiting for logs..." })] }), showTestPanel && (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: testing ? "magenta" : "blue", children: [_jsxs(Box, { paddingX: 1, children: [_jsx(Text, { color: testing ? "magenta" : "blue", bold: true, children: testing ? "TESTING..." : "TESTS" }), testRun && (_jsxs(_Fragment, { children: [testRun.done && (_jsxs(_Fragment, { children: [_jsx(Text, { children: " " }), _jsx(Text, { color: "green", children: "done" })] })), testRun.pattern && (_jsxs(_Fragment, { children: [_jsx(Text, { children: " " }), _jsxs(Text, { dimColor: true, children: ["(", testRun.pattern, ")"] })] }))] }))] }), _jsx(Box, { flexDirection: "column", height: testOutputLines, paddingX: 1, overflow: "hidden", children: visibleTestOutput.map((line, i) => (_jsx(Text, { wrap: "truncate", dimColor: true, children: truncate(line, terminalCols - 4) }, i))) })] })), grepMode ? (_jsxs(Box, { paddingX: 1, borderStyle: "single", borderColor: "cyan", children: [_jsx(Text, { color: "cyan", children: "Grep pattern: " }), _jsx(Text, { children: grepInput }), _jsx(Text, { color: "cyan", children: "\u258B" }), _jsx(Text, { dimColor: true, children: " (Enter=run, Esc=cancel)" })] })) : (_jsx(Box, { paddingX: 1, children: _jsxs(Text, { dimColor: true, children: ["q:quit t:test T:grep", showTestPanel && " c:clear", " p:pause r:resume g:top G:bottom PgUp/PgDn", onNextLog && " ,/.:node"] }) }))] }));
+};

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

@@ -0,0 +1,6 @@
+export type RunCommandArgs = {
+    envName: string;
+    GrepTest?: string;
+    subDirectory?: string;
+};
+//# sourceMappingURL=entrypoint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"entrypoint.d.ts","sourceRoot":"","sources":["../../../src/cli/cmds/entrypoint.ts"],"names":[],"mappings":"AAkDA,MAAM,MAAM,cAAc,GAAG;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC"}

package/dist/cli/cmds/entrypoint.js

@@ -0,0 +1,192 @@
+import dotenv from "dotenv";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { fetchArtifact, deriveTestIds, generateConfig, } from "../internal/index.js";
+import { main } from "./main.js";
+import { runNetworkCmd } from "./runNetwork.js";
+import { testCmd } from "./runTests.js";
+import { configSetup } from "../lib/configReader.js";
+dotenv.config({
+    quiet: true,
+});
+function handleCursor() {
+    const hideCursor = "\x1B[?25l";
+    const showCursor = "\x1B[?25h";
+    process.stdout.write(hideCursor);
+    process.on("exit", () => {
+        process.stdout.write(showCursor);
+    });
+    process.on("SIGINT", async () => {
+        process.stdout.write(showCursor);
+        global.MOONWALL_TERMINATION_REASON = "cancelled by user";
+        // Import dynamically to avoid circular dependency
+        const { MoonwallContext } = await import("../lib/globalContext.js");
+        await MoonwallContext.destroy("cancelled by user");
+        process.exit(130); // Standard exit code for SIGINT
+    });
+    process.on("SIGTERM", async () => {
+        process.stdout.write(showCursor);
+        global.MOONWALL_TERMINATION_REASON = "terminated by system";
+        // Import dynamically to avoid circular dependency
+        const { MoonwallContext } = await import("../lib/globalContext.js");
+        await MoonwallContext.destroy("terminated by system");
+        process.exit(143); // Standard exit code for SIGTERM
+    });
+}
+handleCursor();
+configSetup(process.argv);
+yargs(hideBin(process.argv))
+    .wrap(null)
+    .usage("Usage: $0")
+    .version("2.0.0")
+    .options({
+    configFile: {
+        type: "string",
+        alias: "c",
+        description: "path to MoonwallConfig file",
+        default: "moonwall.config.json",
+    },
+})
+    .command("init", "Run tests for a given Environment", (yargs) => yargs.option("acceptAllDefaults", {
+    type: "boolean",
+    description: "Accept all defaults",
+    alias: "A",
+}), async (argv) => {
+    await generateConfig(argv);
+})
+    .command("download <bin> [ver] [path]", "Download x86 artifact from GitHub", (yargs) => {
+    return yargs
+        .positional("bin", {
+        describe: "Name of artifact to download\n[ moonbeam | polkadot | *-runtime ]",
+        type: "string",
+    })
+        .positional("ver", {
+        describe: "Artifact version to download",
+        type: "string",
+        default: "latest",
+    })
+        .positional("path", {
+        describe: "Path where to save artifacts",
+        type: "string",
+        default: "./",
+    })
+        .option("overwrite", {
+        describe: "If file exists, should it be overwritten?",
+        type: "boolean",
+        alias: "d",
+        default: false,
+    })
+        .option("output-name", {
+        describe: "Rename downloaded file to this name",
+        alias: "o",
+        type: "string",
+    });
+}, async (argv) => {
+    await fetchArtifact(argv);
+})
+    .command("test <envName> [GrepTest]", "Run tests for a given Environment", (yargs) => {
+    return yargs
+        .positional("envName", {
+        describe: "Network environment to run tests against",
+        array: true,
+        string: true,
+    })
+        .positional("GrepTest", {
+        type: "string",
+        description: "Pattern to grep test ID/Description to run",
+    })
+        .option("subDirectory", {
+        describe: "Additional sub-directory filter for test suites",
+        alias: "d",
+        type: "string",
+    })
+        .option("testShard", {
+        describe: "Test Shard info for CI",
+        alias: "ts",
+        type: "string",
+    })
+        .option("update", {
+        describe: "Update all snapshots",
+        alias: "u",
+        type: "boolean",
+    })
+        .option("vitestArgPassthrough", {
+        describe: "Arguments to pass directly to Vitest (space-delimited)",
+        alias: "vitest",
+        type: "string",
+    });
+}, async (args) => {
+    if (args.envName) {
+        process.env.MOON_RUN_SCRIPTS = "true";
+        if (!(await testCmd(args.envName.toString(), {
+            testNamePattern: args.GrepTest,
+            subDirectory: args.subDirectory,
+            shard: args.testShard,
+            update: args.update,
+            vitestPassthroughArgs: args.vitestArgPassthrough?.split(" "),
+        }))) {
+            process.exitCode = 1;
+        }
+    }
+    else {
+        console.log("❌ No environment specified");
+        console.log(`👉 Run 'pnpm moonwall --help' for more information`);
+        process.exitCode = 1;
+    }
+})
+    .command("run <envName> [GrepTest]", "Start new network found in global config", (yargs) => {
+    return yargs
+        .positional("envName", {
+        describe: "Network environment to start. Must be defined in the global config file.",
+        type: "string",
+    })
+        .positional("GrepTest", {
+        type: "string",
+        description: "Pattern to grep test ID/Description to run",
+    })
+        .option("subDirectory", {
+        describe: "Additional sub-directory filter for test suites",
+        alias: "d",
+        type: "string",
+    });
+}, async (argv) => {
+    process.env.MOON_RUN_SCRIPTS = "true";
+    await runNetworkCmd(argv);
+})
+    .command("derive <suitesRootDir>", "Derive test IDs based on positional order in the directory tree", (yargs) => {
+    return yargs
+        .positional("suitesRootDir", {
+        describe: "Root directory of the suites",
+        type: "string",
+    })
+        .option("prefixPhrase", {
+        describe: "Root phrase to generate prefixes from (e.g. DEV)",
+        alias: "p",
+        type: "string",
+    })
+        .option("singlePrefix", {
+        describe: "Use a single prefix for all suites, instead of deriving from folder names",
+        alias: "l",
+        default: false,
+        type: "boolean",
+    });
+}, async ({ suitesRootDir, prefixPhrase, singlePrefix }) => {
+    await deriveTestIds({
+        rootDir: suitesRootDir,
+        prefixPhrase,
+        singlePrefix,
+    });
+})
+    .demandCommand(1)
+    .fail(async (msg) => {
+    console.log(msg);
+    await main();
+})
+    .help("h")
+    .alias("h", "help")
+    .parseAsync()
+    .then(async () => {
+    if (process.env.MOON_EXIT) {
+        process.exit();
+    }
+});

package/dist/cli/cmds/interactiveCmds/chopsticksIntCmds.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveChopsticksInteractiveCmdChoice(): Promise<void>;
+//# sourceMappingURL=chopsticksIntCmds.d.ts.map

package/dist/cli/cmds/interactiveCmds/chopsticksIntCmds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chopsticksIntCmds.d.ts","sourceRoot":"","sources":["../../../../src/cli/cmds/interactiveCmds/chopsticksIntCmds.ts"],"names":[],"mappings":"AAqBA,wBAAsB,qCAAqC,kBAgJ1D"}

package/dist/cli/cmds/interactiveCmds/chopsticksIntCmds.js

@@ -0,0 +1,117 @@
+import { promises as fsPromises } from "node:fs";
+import { parse } from "yaml";
+import { getEnvironmentFromConfig } from "../../lib/configReader.js";
+import { MoonwallContext } from "../../lib/globalContext.js";
+import { jumpBlocksChopsticks, jumpRoundsChopsticks, jumpToRoundChopsticks, } from "../../../util/index.js";
+import { number, select, Separator } from "@inquirer/prompts";
+import assert from "node:assert";
+export async function resolveChopsticksInteractiveCmdChoice() {
+    const config = getEnvironmentFromConfig();
+    if (config.foundation.type !== "chopsticks") {
+        throw new Error("Only chopsticks is supported, this is a bug please raise an issue.");
+    }
+    const isMultiChain = config.foundation.launchSpec.length > 1;
+    const promptNode = async () => {
+        if (config.foundation.type !== "chopsticks") {
+            throw new Error("Only chopsticks is supported, this is a bug please raise an issue.");
+        }
+        const nodes = config.foundation.launchSpec.map(({ name }) => name);
+        const name = await select({
+            choices: nodes,
+            message: "Which network would you like to interact with? ",
+        });
+        return name;
+    };
+    const nodeSelected = isMultiChain ? await promptNode() : config.foundation.launchSpec[0].name;
+    const ctx = await (await MoonwallContext.getContext()).connectEnvironment();
+    const provider = ctx.providers.find((a) => a.type === "polkadotJs" && a.name === nodeSelected);
+    if (!provider) {
+        throw new Error(`Provider ${nodeSelected} not found. Verify moonwall config has matching pair of launchSpec and Connection names.`);
+    }
+    const api = provider.api;
+    const ports = await Promise.all(config.foundation.launchSpec
+        .filter(({ name }) => name === nodeSelected)
+        .map(async ({ configPath }) => {
+        const yaml = parse((await fsPromises.readFile(configPath)).toString());
+        return yaml.port || "8000";
+    }));
+    const port = Number.parseInt(ports[0], 10);
+    const choices = [
+        { name: "🆗  Create Block", value: "createblock" },
+        { name: "➡️  Create N Blocks", value: "createNBlocks" },
+    ];
+    const containsPallet = (polkadotJsApi, palletName) => {
+        const metadata = polkadotJsApi.runtimeMetadata.asLatest;
+        const systemPalletIndex = metadata.pallets.findIndex((pallet) => pallet.name.toString() === palletName);
+        return systemPalletIndex !== -1;
+    };
+    if (containsPallet(api, "ParachainStaking")) {
+        choices.push(...[
+            { name: "🔼  Jump To Round", value: "jumpToRound" },
+            { name: "⏫  Jump N Rounds", value: "jumpRounds" },
+        ]);
+    }
+    choices.push(...[new Separator(), { name: "🔙  Go Back", value: "back" }]);
+    const cmd = await select({
+        choices,
+        message: "What command would you like to run? ",
+        default: "createBlock",
+    });
+    switch (cmd) {
+        case "createblock":
+            try {
+                await jumpBlocksChopsticks(port, 1);
+            }
+            catch (e) {
+                console.error(e.message);
+            }
+            break;
+        case "createNBlocks": {
+            try {
+                const nBlocks = await number({
+                    message: "How many blocks? ",
+                });
+                assert(typeof nBlocks === "number", "Number must be a number");
+                assert(nBlocks > 0, "Number must be greater than 0");
+                await jumpBlocksChopsticks(port, nBlocks);
+            }
+            catch (e) {
+                console.error(e.message);
+            }
+            break;
+        }
+        case "jumpToRound": {
+            try {
+                const round = await number({
+                    message: "Which round to jump to (in future)? ",
+                });
+                assert(typeof round === "number", "Number must be a number");
+                assert(round > 0, "Number must be greater than 0");
+                console.log("💤 This may take a while....");
+                await jumpToRoundChopsticks(api, port, round);
+            }
+            catch (e) {
+                console.error(e.message);
+            }
+            break;
+        }
+        case "jumpRounds": {
+            try {
+                const rounds = await number({
+                    message: "How many rounds? ",
+                });
+                assert(typeof rounds === "number", "Number must be a number");
+                assert(rounds > 0, "Number must be greater than 0");
+                console.log("💤 This may take a while....");
+                await jumpRoundsChopsticks(api, port, rounds);
+            }
+            catch (e) {
+                console.error(e.message);
+            }
+            break;
+        }
+        case "back":
+            break;
+    }
+    return;
+}

package/dist/cli/cmds/interactiveCmds/devIntCmds.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveDevInteractiveCmdChoice(): Promise<void>;
+//# sourceMappingURL=devIntCmds.d.ts.map

package/dist/cli/cmds/interactiveCmds/devIntCmds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"devIntCmds.d.ts","sourceRoot":"","sources":["../../../../src/cli/cmds/interactiveCmds/devIntCmds.ts"],"names":[],"mappings":"AAMA,wBAAsB,8BAA8B,kBAwHnD"}

package/dist/cli/cmds/interactiveCmds/devIntCmds.js

@@ -0,0 +1,103 @@
+import { MoonwallContext } from "../../lib/globalContext.js";
+import { jumpRoundsDev, jumpToRoundDev } from "../../../util/index.js";
+import { Separator, rawlist, number } from "@inquirer/prompts";
+import assert from "node:assert";
+export async function resolveDevInteractiveCmdChoice() {
+    const ctx = await (await MoonwallContext.getContext()).connectEnvironment();
+    const prov = ctx.providers.find((a) => a.type === "polkadotJs");
+    if (!prov) {
+        throw new Error("Provider not found. This is a bug, please raise an issue.");
+    }
+    const api = prov.api;
+    const choices = [
+        { name: "🆗  Create Block", value: "createblock" },
+        { name: "🆕  Create Unfinalized Block", value: "createUnfinalizedBlock" },
+        { name: "➡️   Create N Blocks", value: "createNBlocks" },
+    ];
+    const containsPallet = (polkadotJsApi, palletName) => {
+        const metadata = polkadotJsApi.runtimeMetadata.asLatest;
+        const systemPalletIndex = metadata.pallets.findIndex((pallet) => pallet.name.toString() === palletName);
+        return systemPalletIndex !== -1;
+    };
+    if (containsPallet(api, "ParachainStaking")) {
+        choices.push(...[
+            { name: "🔼  Jump To Round", value: "jumpToRound" },
+            { name: "⏫  Jump N Rounds", value: "jumpRounds" },
+        ]);
+    }
+    choices.push(...[new Separator(), { name: "🔙  Go Back", value: "back" }]);
+    const choice = await rawlist({
+        choices,
+        message: "What command would you like to run? ",
+    });
+    switch (choice) {
+        case "createblock":
+            try {
+                await api.rpc.engine.createBlock(true, true);
+            }
+            catch (e) {
+                console.error(e);
+            }
+            break;
+        case "createUnfinalizedBlock":
+            try {
+                await api.rpc.engine.createBlock(true, false);
+            }
+            catch (e) {
+                console.error(e);
+            }
+            break;
+        case "createNBlocks": {
+            try {
+                const result = await number({
+                    message: "How many blocks? ",
+                });
+                assert(typeof result === "number", "result should be a number");
+                assert(result > 0, "result should be greater than 0");
+                const executeSequentially = async (remaining) => {
+                    if (remaining === 0) {
+                        return;
+                    }
+                    await api.rpc.engine.createBlock(true, true);
+                    await executeSequentially(remaining - 1);
+                };
+                await executeSequentially(result);
+            }
+            catch (e) {
+                console.error(e);
+            }
+            break;
+        }
+        case "jumpToRound": {
+            try {
+                const round = await number({
+                    message: "Which round to jump to (in future)? ",
+                });
+                assert(typeof round === "number", "round should be a number");
+                assert(round > 0, "round should be greater than 0");
+                await jumpToRoundDev(api, round);
+            }
+            catch (e) {
+                console.error(e);
+            }
+            break;
+        }
+        case "jumpRounds": {
+            try {
+                const rounds = await number({
+                    message: "How many rounds? ",
+                });
+                assert(typeof rounds === "number", "rounds should be a number");
+                assert(rounds > 0, "rounds should be greater than 0");
+                await jumpRoundsDev(api, rounds);
+            }
+            catch (e) {
+                console.error(e);
+            }
+            break;
+        }
+        case "back":
+            break;
+    }
+    return;
+}

package/dist/cli/cmds/interactiveCmds/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./chopsticksIntCmds.js";
+export * from "./devIntCmds.js";
+export * from "./zombieIntCmds.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/cmds/interactiveCmds/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/cli/cmds/interactiveCmds/index.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,gCAAgC;AAChC,mCAAmC"}

package/dist/cli/cmds/interactiveCmds/index.js

@@ -0,0 +1,3 @@
+export * from "./chopsticksIntCmds.js";
+export * from "./devIntCmds.js";
+export * from "./zombieIntCmds.js";

package/dist/cli/cmds/interactiveCmds/zombieIntCmds.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveZombieInteractiveCmdChoice(): Promise<void>;
+//# sourceMappingURL=zombieIntCmds.d.ts.map

package/dist/cli/cmds/interactiveCmds/zombieIntCmds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zombieIntCmds.d.ts","sourceRoot":"","sources":["../../../../src/cli/cmds/interactiveCmds/zombieIntCmds.ts"],"names":[],"mappings":"AAGA,wBAAsB,iCAAiC,kBA+BtD"}

package/dist/cli/cmds/interactiveCmds/zombieIntCmds.js

@@ -0,0 +1,32 @@
+import { sendIpcMessage } from "../../internal/foundations/index.js";
+import { input, select, Separator } from "@inquirer/prompts";
+export async function resolveZombieInteractiveCmdChoice() {
+    const cmd = await select({
+        choices: [
+            { name: "♻️  Restart Node", value: "restart" },
+            { name: "🗡️  Kill Node", value: "kill" },
+            new Separator(),
+            { name: "🔙  Go Back", value: "back" },
+        ],
+        message: "What command would you like to run? ",
+        default: "back",
+    });
+    if (cmd === "back") {
+        return;
+    }
+    const whichNode = await input({
+        message: `Which node would you like to ${cmd}? `,
+    });
+    try {
+        await sendIpcMessage({
+            cmd: cmd,
+            nodeName: whichNode,
+            text: `Running ${cmd} on ${whichNode}`,
+        });
+    }
+    catch (e) {
+        console.error("Error: ");
+        console.error(e.message);
+    }
+    return;
+}

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

@@ -0,0 +1,2 @@
+export declare function main(): Promise<void>;
+//# sourceMappingURL=main.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../src/cli/cmds/main.ts"],"names":[],"mappings":"AAkCA,wBAAsB,IAAI,kBAWzB"}