moonwall 1.0.0-dev.0

package/dist/cli/internal/localNode.js

@@ -0,0 +1,362 @@
+import { createLogger } from "../../util/index.js";
+import Docker from "dockerode";
+import { exec, spawn, spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { setTimeout as timer } from "node:timers/promises";
+import util from "node:util";
+import invariant from "tiny-invariant";
+import WebSocket from "ws";
+import { isEthereumDevConfig, isEthereumZombieConfig } from "../lib/configReader.js";
+import { checkAccess, checkExists } from "./fileCheckers.js";
+const execAsync = util.promisify(exec);
+const logger = createLogger({ name: "localNode" });
+const debug = logger.debug.bind(logger);
+// TODO: Add multi-threading support
+async function launchDockerContainer(imageName, args, name, dockerConfig) {
+    const docker = new Docker();
+    const port = args.find((a) => a.includes("port"))?.split("=")[1];
+    debug(`\x1b[36mStarting Docker container ${imageName} on port ${port}...\x1b[0m`);
+    const dirPath = path.join(process.cwd(), "tmp", "node_logs");
+    const logLocation = path.join(dirPath, `${name}_docker_${Date.now()}.log`);
+    const fsStream = fs.createWriteStream(logLocation);
+    process.env.MOON_LOG_LOCATION = logLocation;
+    const portBindings = dockerConfig?.exposePorts?.reduce((acc, { hostPort, internalPort }) => {
+        acc[`${internalPort}/tcp`] = [{ HostPort: hostPort.toString() }];
+        return acc;
+    }, {});
+    const rpcPort = args.find((a) => a.includes("rpc-port"))?.split("=")[1];
+    invariant(rpcPort, "RPC port not found, this is a bug");
+    const containerOptions = {
+        Image: imageName,
+        platform: "linux/amd64",
+        Cmd: args,
+        name: dockerConfig?.containerName || `moonwall_${name}_${Date.now()}`,
+        ExposedPorts: {
+            ...Object.fromEntries(dockerConfig?.exposePorts?.map(({ internalPort }) => [`${internalPort}/tcp`, {}]) || []),
+            [`${rpcPort}/tcp`]: {},
+        },
+        HostConfig: {
+            PortBindings: {
+                ...portBindings,
+                [`${rpcPort}/tcp`]: [{ HostPort: rpcPort }],
+            },
+        },
+        Env: dockerConfig?.runArgs?.filter((arg) => arg.startsWith("env:")).map((arg) => arg.slice(4)),
+    };
+    try {
+        await pullImage(imageName, docker);
+        const container = await docker.createContainer(containerOptions);
+        await container.start();
+        const containerInfo = await container.inspect();
+        if (!containerInfo.State.Running) {
+            const errorMessage = `Container failed to start: ${containerInfo.State.Error}`;
+            console.error(errorMessage);
+            fs.appendFileSync(logLocation, `${errorMessage}\n`);
+            throw new Error(errorMessage);
+        }
+        for (let i = 0; i < 300; i++) {
+            const isReady = await checkWebSocketJSONRPC(Number.parseInt(rpcPort, 10));
+            if (isReady) {
+                break;
+            }
+            await timer(100);
+        }
+        return { runningNode: container, fsStream };
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error(`Docker container launch failed: ${error.message}`);
+            fs.appendFileSync(logLocation, `Docker launch error: ${error.message}\n`);
+        }
+        throw error;
+    }
+}
+export async function launchNodeLegacy(options) {
+    const { command: cmd, args, name, launchSpec: config } = options;
+    if (config?.useDocker) {
+        return launchDockerContainer(cmd, args, name, config.dockerConfig);
+    }
+    if (cmd.includes("moonbeam")) {
+        await checkExists(cmd);
+        checkAccess(cmd);
+    }
+    const port = args.find((a) => a.includes("port"))?.split("=")[1];
+    debug(`\x1b[36mStarting ${name} node on port ${port}...\x1b[0m`);
+    const dirPath = path.join(process.cwd(), "tmp", "node_logs");
+    const runningNode = spawn(cmd, args);
+    const logLocation = path
+        .join(dirPath, `${path.basename(cmd)}_node_${args.find((a) => a.includes("port"))?.split("=")[1]}_${runningNode.pid}.log`)
+        .replaceAll("node_node_undefined", "chopsticks");
+    process.env.MOON_LOG_LOCATION = logLocation;
+    const fsStream = fs.createWriteStream(logLocation);
+    runningNode.on("error", (err) => {
+        if (err.errno === "ENOENT") {
+            console.error(`\x1b[31mMissing Local binary at(${cmd}).\nPlease compile the project\x1b[0m`);
+        }
+        throw new Error(err.message);
+    });
+    const logHandler = (chunk) => {
+        if (fsStream.writable) {
+            fsStream.write(chunk, (err) => {
+                if (err)
+                    console.error(err);
+                else
+                    fsStream.emit("drain");
+            });
+        }
+    };
+    runningNode.stderr?.on("data", logHandler);
+    runningNode.stdout?.on("data", logHandler);
+    runningNode.once("exit", (code, signal) => {
+        const timestamp = new Date().toISOString();
+        let message;
+        // Check if this termination was initiated by Moonwall
+        const moonwallNode = runningNode;
+        if (moonwallNode.isMoonwallTerminating) {
+            message = `${timestamp} [moonwall] process killed. reason: ${moonwallNode.moonwallTerminationReason || "unknown"}`;
+        }
+        else if (code !== null) {
+            message = `${timestamp} [moonwall] process exited with status code ${code}`;
+        }
+        else if (signal !== null) {
+            message = `${timestamp} [moonwall] process terminated by signal ${signal}`;
+        }
+        else {
+            message = `${timestamp} [moonwall] process terminated unexpectedly`;
+        }
+        // Write the message before closing the stream
+        if (fsStream.writable) {
+            fsStream.write(`${message}\n`, (err) => {
+                if (err)
+                    console.error(`Failed to write exit message to log: ${err}`);
+                fsStream.end();
+            });
+        }
+        else {
+            // Fallback: append to file directly if stream is not writable
+            try {
+                fs.appendFileSync(logLocation, `${message}\n`);
+            }
+            catch (err) {
+                console.error(`Failed to append exit message to log file: ${err}`);
+            }
+            fsStream.end();
+        }
+        runningNode.stderr?.removeListener("data", logHandler);
+        runningNode.stdout?.removeListener("data", logHandler);
+    });
+    if (!runningNode.pid) {
+        const errorMessage = "Failed to start child process";
+        console.error(errorMessage);
+        fs.appendFileSync(logLocation, `${errorMessage}\n`);
+        throw new Error(errorMessage);
+    }
+    // Check if the process exited immediately
+    if (runningNode.exitCode !== null) {
+        const errorMessage = `Child process exited immediately with code ${runningNode.exitCode}`;
+        console.error(errorMessage);
+        fs.appendFileSync(logLocation, `${errorMessage}\n`);
+        throw new Error(errorMessage);
+    }
+    const isRunning = await isPidRunning(runningNode.pid);
+    if (!isRunning) {
+        const errorMessage = `Process with PID ${runningNode.pid} is not running`;
+        spawnSync(cmd, args, { stdio: "inherit" });
+        throw new Error(errorMessage);
+    }
+    probe: for (let i = 0;; i++) {
+        try {
+            const ports = await findPortsByPid(runningNode.pid);
+            if (ports) {
+                for (const port of ports) {
+                    try {
+                        const isReady = await checkWebSocketJSONRPC(port);
+                        if (isReady) {
+                            break probe;
+                        }
+                    }
+                    catch { }
+                }
+            }
+        }
+        catch {
+            if (i === 300) {
+                throw new Error("Could not find ports for node after 30 seconds");
+            }
+            await timer(100);
+            continue;
+        }
+        await timer(100);
+    }
+    return { runningNode, fsStream };
+}
+function isPidRunning(pid) {
+    return new Promise((resolve) => {
+        exec(`ps -p ${pid} -o pid=`, (error, stdout, _stderr) => {
+            if (error) {
+                resolve(false);
+            }
+            else {
+                resolve(stdout.trim() !== "");
+            }
+        });
+    });
+}
+async function checkWebSocketJSONRPC(port) {
+    try {
+        // Determine if this is an Ethereum-compatible chain from config
+        const isEthereumChain = isEthereumDevConfig() || isEthereumZombieConfig();
+        // First check WebSocket availability
+        const ws = new WebSocket(`ws://localhost:${port}`);
+        const checkWsMethod = async (method) => {
+            return new Promise((resolve) => {
+                const timeout = setTimeout(() => {
+                    resolve(false);
+                }, 5000);
+                ws.send(JSON.stringify({
+                    jsonrpc: "2.0",
+                    id: Math.floor(Math.random() * 10000),
+                    method,
+                    params: [],
+                }));
+                const messageHandler = (data) => {
+                    try {
+                        const response = JSON.parse(data.toString());
+                        if (response.jsonrpc === "2.0" && !response.error) {
+                            clearTimeout(timeout);
+                            ws.removeListener("message", messageHandler);
+                            resolve(true);
+                        }
+                    }
+                    catch (_e) {
+                        // Ignore parse errors
+                    }
+                };
+                ws.on("message", messageHandler);
+            });
+        };
+        const wsResult = await new Promise((resolve) => {
+            ws.on("open", async () => {
+                try {
+                    // Check system_chain first via WebSocket (works for all chains)
+                    const systemChainAvailable = await checkWsMethod("system_chain");
+                    if (!systemChainAvailable) {
+                        resolve(false);
+                        return;
+                    }
+                    // For Ethereum-compatible chains, also check eth_chainId via WebSocket
+                    if (isEthereumChain) {
+                        const ethChainIdAvailable = await checkWsMethod("eth_chainId");
+                        if (!ethChainIdAvailable) {
+                            resolve(false);
+                            return;
+                        }
+                    }
+                    // WebSocket checks passed
+                    resolve(true);
+                }
+                catch (_e) {
+                    resolve(false);
+                }
+            });
+            ws.on("error", () => {
+                resolve(false);
+            });
+        });
+        ws?.close();
+        if (!wsResult) {
+            return false;
+        }
+        // Now also check HTTP service is ready
+        const httpUrl = `http://localhost:${port}`;
+        const checkHttpMethod = async (method) => {
+            try {
+                const response = await fetch(httpUrl, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({
+                        jsonrpc: "2.0",
+                        id: Math.floor(Math.random() * 10000),
+                        method,
+                        params: [],
+                    }),
+                });
+                if (!response.ok) {
+                    return false;
+                }
+                const data = await response.json();
+                return !data.error;
+            }
+            catch (_e) {
+                return false;
+            }
+        };
+        try {
+            // Always check system_chain via HTTP (works for all chains)
+            const systemChainAvailable = await checkHttpMethod("system_chain");
+            if (!systemChainAvailable) {
+                return false;
+            }
+            // For Ethereum chains, also verify eth_chainId is available via HTTP
+            if (isEthereumChain) {
+                const ethChainIdAvailable = await checkHttpMethod("eth_chainId");
+                return ethChainIdAvailable;
+            }
+            // For non-Ethereum chains, system_chain being available is enough
+            return true;
+        }
+        catch (_e) {
+            // HTTP service not ready yet
+            return false;
+        }
+    }
+    catch {
+        return false;
+    }
+}
+async function findPortsByPid(pid, retryCount = 600, retryDelay = 100) {
+    for (let i = 0; i < retryCount; i++) {
+        try {
+            const { stdout } = await execAsync(`lsof -p ${pid} -n -P | grep LISTEN`);
+            const ports = [];
+            const lines = stdout.split("\n");
+            for (const line of lines) {
+                // Example outputs:
+                // - lsof node      97796 romarq   26u  IPv6 0xb6c3e894a2247189      0t0  TCP *:8000 (LISTEN)
+                // - lsof node      97242 romarq   26u  IPv6 0x330c461cca8d2b63      0t0  TCP [::1]:8000 (LISTEN)
+                const regex = /(?:.+):(\d+)/;
+                const match = line.match(regex);
+                if (match) {
+                    ports.push(Number(match[1]));
+                }
+            }
+            if (ports.length) {
+                return ports;
+            }
+            throw new Error("Could not find any ports");
+        }
+        catch (error) {
+            if (i === retryCount - 1) {
+                throw error;
+            }
+        }
+        await new Promise((resolve) => setTimeout(resolve, retryDelay));
+    }
+    return [];
+}
+async function pullImage(imageName, docker) {
+    console.log(`Pulling Docker image: ${imageName}`);
+    const pullStream = await docker.pull(imageName);
+    // Dockerode pull doesn't wait for completion by default 🫠
+    await new Promise((resolve, reject) => {
+        docker.modem.followProgress(pullStream, (err, output) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve(output);
+            }
+        });
+    });
+}

package/dist/cli/internal/logging.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=logging.d.ts.map

package/dist/cli/internal/logging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging.d.ts","sourceRoot":"","sources":["../../../src/cli/internal/logging.ts"],"names":[],"mappings":""}

package/dist/cli/internal/logging.js

@@ -0,0 +1,26 @@
+const originalWrite = process.stderr.write.bind(process.stderr);
+const blockList = [
+    "has multiple versions, ensure that there is only one installed",
+    "Unable to map [u8; 32] to a lookup index",
+    "Either remove and explicitly install matching versions or dedupe using your package manager.",
+];
+process.stderr.write = (chunk, encodingOrCallback, callback) => {
+    let shouldWrite = true;
+    if (typeof chunk === "string") {
+        shouldWrite = !blockList.some((phrase) => chunk.includes(phrase));
+    }
+    if (shouldWrite) {
+        if (typeof encodingOrCallback === "function") {
+            // Second argument must always be BufferEncoding or undefined.
+            // When encodingOrCallback is a function, pass as cb; encoding is undefined.
+            return originalWrite.call(process.stderr, chunk, undefined, encodingOrCallback);
+        }
+        return originalWrite.call(process.stderr, chunk, encodingOrCallback, callback);
+    }
+    // Suppress output but invoke callback if present
+    const cb = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
+    if (cb)
+        cb(null);
+    return true;
+};
+export {};

package/dist/cli/internal/node.d.ts

@@ -0,0 +1,33 @@
+import type { ChildProcess } from "node:child_process";
+import fs from "node:fs";
+import type { DevLaunchSpec } from "../../api/types/index.js";
+import Docker from "dockerode";
+/**
+ * Extended ChildProcess interface with Moonwall termination tracking
+ */
+export interface MoonwallProcess extends ChildProcess {
+    /**
+     * Flag indicating if this process is being terminated by Moonwall
+     */
+    isMoonwallTerminating?: boolean;
+    /**
+     * Reason for Moonwall-initiated termination
+     */
+    moonwallTerminationReason?: string;
+    /**
+     * Effect-based cleanup function for automatic resource management
+     */
+    effectCleanup?: () => Promise<void>;
+}
+export declare function launchNode(options: {
+    command: string;
+    args: string[];
+    name: string;
+    launchSpec?: DevLaunchSpec;
+}): Promise<{
+    runningNode: Docker.Container;
+    fsStream: fs.WriteStream;
+} | {
+    runningNode: MoonwallProcess;
+}>;
+//# sourceMappingURL=node.d.ts.map

package/dist/cli/internal/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/cli/internal/node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,MAAM,SAAS,CAAC;AAMzB,OAAO,KAAK,EAAE,aAAa,EAAE,iCAAiC;AAC9D,OAAO,MAAM,MAAM,WAAW,CAAC;AAQ/B;;GAEG;AACH,MAAM,WAAW,eAAgB,SAAQ,YAAY;IACnD;;OAEG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAEhC;;OAEG;IACH,yBAAyB,CAAC,EAAE,MAAM,CAAC;IAEnC;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACrC;AAiFD,wBAAsB,UAAU,CAAC,OAAO,EAAE;IACxC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,aAAa,CAAC;CAC5B;;;;;GAwCA"}

package/dist/cli/internal/node.js

@@ -0,0 +1,228 @@
+import fs from "node:fs";
+import path from "node:path";
+import WebSocket from "ws";
+import { checkAccess, checkExists } from "./fileCheckers.js";
+import { createLogger } from "../../util/index.js";
+import { setTimeout as timer } from "node:timers/promises";
+import Docker from "dockerode";
+import invariant from "tiny-invariant";
+import { isEthereumDevConfig, isEthereumZombieConfig } from "../lib/configReader.js";
+import { launchNodeEffect } from "./effect/index.js";
+const logger = createLogger({ name: "node" });
+const debug = logger.debug.bind(logger);
+// TODO: Add multi-threading support
+async function launchDockerContainer(imageName, args, name, dockerConfig) {
+    const docker = new Docker();
+    const port = args.find((a) => a.includes("port"))?.split("=")[1];
+    debug(`\x1b[36mStarting Docker container ${imageName} on port ${port}...\x1b[0m`);
+    const dirPath = path.join(process.cwd(), "tmp", "node_logs");
+    const logLocation = path.join(dirPath, `${name}_docker_${Date.now()}.log`);
+    const fsStream = fs.createWriteStream(logLocation);
+    process.env.MOON_LOG_LOCATION = logLocation;
+    const portBindings = dockerConfig?.exposePorts?.reduce((acc, { hostPort, internalPort }) => {
+        acc[`${internalPort}/tcp`] = [{ HostPort: hostPort.toString() }];
+        return acc;
+    }, {});
+    const rpcPort = args.find((a) => a.includes("rpc-port"))?.split("=")[1];
+    invariant(rpcPort, "RPC port not found, this is a bug");
+    const containerOptions = {
+        Image: imageName,
+        platform: "linux/amd64",
+        Cmd: args,
+        name: dockerConfig?.containerName || `moonwall_${name}_${Date.now()}`,
+        ExposedPorts: {
+            ...Object.fromEntries(dockerConfig?.exposePorts?.map(({ internalPort }) => [`${internalPort}/tcp`, {}]) || []),
+            [`${rpcPort}/tcp`]: {},
+        },
+        HostConfig: {
+            PortBindings: {
+                ...portBindings,
+                [`${rpcPort}/tcp`]: [{ HostPort: rpcPort }],
+            },
+        },
+        Env: dockerConfig?.runArgs?.filter((arg) => arg.startsWith("env:")).map((arg) => arg.slice(4)),
+    };
+    try {
+        await pullImage(imageName, docker);
+        const container = await docker.createContainer(containerOptions);
+        await container.start();
+        const containerInfo = await container.inspect();
+        if (!containerInfo.State.Running) {
+            const errorMessage = `Container failed to start: ${containerInfo.State.Error}`;
+            console.error(errorMessage);
+            fs.appendFileSync(logLocation, `${errorMessage}\n`);
+            throw new Error(errorMessage);
+        }
+        for (let i = 0; i < 300; i++) {
+            const isReady = await checkWebSocketJSONRPC(Number.parseInt(rpcPort, 10));
+            if (isReady) {
+                break;
+            }
+            await timer(100);
+        }
+        return { runningNode: container, fsStream };
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error(`Docker container launch failed: ${error.message}`);
+            fs.appendFileSync(logLocation, `Docker launch error: ${error.message}\n`);
+        }
+        throw error;
+    }
+}
+export async function launchNode(options) {
+    const { command: cmd, args, name, launchSpec: config } = options;
+    if (config?.useDocker) {
+        return launchDockerContainer(cmd, args, name, config.dockerConfig);
+    }
+    if (cmd.includes("moonbeam")) {
+        await checkExists(cmd);
+        checkAccess(cmd);
+    }
+    // Determine if this is an Ethereum chain based on args
+    const isEthereumChain = args.some((arg) => arg.includes("--ethapi") || arg.includes("--eth-rpc") || arg.includes("--enable-evm"));
+    const { result, cleanup } = await launchNodeEffect({
+        command: cmd,
+        args,
+        name,
+        launchSpec: config,
+        isEthereumChain,
+    });
+    logger.debug(`✅ Node '${name}' started with PID ${result.runningNode.pid} on port ${result.port}`);
+    process.env.MOON_LOG_LOCATION = result.logPath;
+    // CRITICAL: Set MOONWALL_RPC_PORT and WSS_URL so tests can connect
+    process.env.MOONWALL_RPC_PORT = result.port.toString();
+    process.env.WSS_URL = `ws://127.0.0.1:${result.port}`;
+    debug(`Set MOONWALL_RPC_PORT=${result.port}, WSS_URL=${process.env.WSS_URL}`);
+    // Store cleanup function for later teardown
+    const moonwallNode = result.runningNode;
+    moonwallNode.effectCleanup = cleanup;
+    return { runningNode: moonwallNode };
+}
+async function checkWebSocketJSONRPC(port) {
+    try {
+        // Determine if this is an Ethereum-compatible chain from config
+        const isEthereumChain = isEthereumDevConfig() || isEthereumZombieConfig();
+        // First check WebSocket availability
+        const ws = new WebSocket(`ws://localhost:${port}`);
+        const checkWsMethod = async (method) => {
+            return new Promise((resolve) => {
+                const timeout = setTimeout(() => {
+                    resolve(false);
+                }, 5000);
+                ws.send(JSON.stringify({
+                    jsonrpc: "2.0",
+                    id: Math.floor(Math.random() * 10000),
+                    method,
+                    params: [],
+                }));
+                const messageHandler = (data) => {
+                    try {
+                        const response = JSON.parse(data.toString());
+                        if (response.jsonrpc === "2.0" && !response.error) {
+                            clearTimeout(timeout);
+                            ws.removeListener("message", messageHandler);
+                            resolve(true);
+                        }
+                    }
+                    catch (_error) {
+                        // Ignore parse errors
+                    }
+                };
+                ws.on("message", messageHandler);
+            });
+        };
+        const wsResult = await new Promise((resolve) => {
+            ws.on("open", async () => {
+                try {
+                    // Check system_chain first via WebSocket (works for all chains)
+                    const systemChainAvailable = await checkWsMethod("system_chain");
+                    if (!systemChainAvailable) {
+                        resolve(false);
+                        return;
+                    }
+                    // For Ethereum-compatible chains, also check eth_chainId via WebSocket
+                    if (isEthereumChain) {
+                        const ethChainIdAvailable = await checkWsMethod("eth_chainId");
+                        if (!ethChainIdAvailable) {
+                            resolve(false);
+                            return;
+                        }
+                    }
+                    // WebSocket checks passed
+                    resolve(true);
+                }
+                catch (_error) {
+                    resolve(false);
+                }
+            });
+            ws.on("error", () => {
+                resolve(false);
+            });
+        });
+        ws?.close();
+        if (!wsResult) {
+            return false;
+        }
+        // Now also check HTTP service is ready
+        const httpUrl = `http://localhost:${port}`;
+        const checkHttpMethod = async (method) => {
+            try {
+                const response = await fetch(httpUrl, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({
+                        jsonrpc: "2.0",
+                        id: Math.floor(Math.random() * 10000),
+                        method,
+                        params: [],
+                    }),
+                });
+                if (!response.ok) {
+                    return false;
+                }
+                const data = await response.json();
+                return !data.error;
+            }
+            catch (_error) {
+                return false;
+            }
+        };
+        try {
+            // Always check system_chain via HTTP (works for all chains)
+            const systemChainAvailable = await checkHttpMethod("system_chain");
+            if (!systemChainAvailable) {
+                return false;
+            }
+            // For Ethereum chains, also verify eth_chainId is available via HTTP
+            if (isEthereumChain) {
+                const ethChainIdAvailable = await checkHttpMethod("eth_chainId");
+                return ethChainIdAvailable;
+            }
+            // For non-Ethereum chains, system_chain being available is enough
+            return true;
+        }
+        catch (_error) {
+            // HTTP service not ready yet
+            return false;
+        }
+    }
+    catch {
+        return false;
+    }
+}
+async function pullImage(imageName, docker) {
+    console.log(`Pulling Docker image: ${imageName}`);
+    const pullStream = await docker.pull(imageName);
+    // Dockerode pull doesn't wait for completion by default 🫠
+    await new Promise((resolve, reject) => {
+        docker.modem.followProgress(pullStream, (err, output) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve(output);
+            }
+        });
+    });
+}

package/dist/cli/internal/processHelpers.d.ts

@@ -0,0 +1,17 @@
+import type { ChildProcessWithoutNullStreams } from "node:child_process";
+/**
+ * Wraps a promise with a timeout. If the original promise does not resolve within the specified time, it rejects.
+ * @param promise The original promise to wrap.
+ * @param ms The timeout duration in milliseconds.
+ * @returns A promise that either resolves/rejects with the original promise or rejects with a timeout error.
+ */
+export declare const withTimeout: <T>(promise: Promise<T>, ms: number) => Promise<T>;
+export declare function runTask(cmd: string, { cwd, env }?: {
+    cwd: string;
+    env?: NodeJS.ProcessEnv;
+}, title?: string): Promise<string>;
+export declare function spawnTask(cmd: string, { cwd, env }?: {
+    cwd: string;
+    env?: NodeJS.ProcessEnv;
+}, title?: string): Promise<ChildProcessWithoutNullStreams>;
+//# sourceMappingURL=processHelpers.d.ts.map

package/dist/cli/internal/processHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processHelpers.d.ts","sourceRoot":"","sources":["../../../src/cli/internal/processHelpers.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,oBAAoB,CAAC;AAKzE;;;;;GAKG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,EAAE,SAAS,OAAO,CAAC,CAAC,CAAC,EAAE,IAAI,MAAM,KAAG,OAAO,CAAC,CAAC,CAOzE,CAAC;AAGF,wBAAsB,OAAO,CAC3B,GAAG,EAAE,MAAM,EACX,EAAE,GAAG,EAAE,GAAG,EAAE,GAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAA;CAEnD,EACD,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,MAAM,CAAC,CAWjB;AAGD,wBAAsB,SAAS,CAC7B,GAAG,EAAE,MAAM,EACX,EAAE,GAAG,EAAE,GAAG,EAAE,GAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAA;CAEnD,EACD,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,8BAA8B,CAAC,CAqBzC"}