moonwall 1.0.0-dev.0

package/dist/cli/internal/fileCheckers.js

@@ -0,0 +1,165 @@
+import fs from "node:fs";
+import { execSync } from "node:child_process";
+import chalk from "chalk";
+import os from "node:os";
+import path from "node:path";
+import { select } from "@inquirer/prompts";
+export async function checkExists(path) {
+    const binPath = path.split(" ")[0];
+    const fsResult = fs.existsSync(binPath);
+    if (!fsResult) {
+        throw new Error(`No binary file found at location: ${binPath} \n Are you sure your ${chalk.bgWhiteBright.blackBright("moonwall.config.json")} file has the correct "binPath" in launchSpec?`);
+    }
+    const binArch = await getBinaryArchitecture(binPath);
+    const currentArch = os.arch();
+    if (binArch !== currentArch && binArch !== "unknown") {
+        throw new Error(`The binary architecture ${chalk.bgWhiteBright.blackBright(binArch)} does not match this system's architecture ${chalk.bgWhiteBright.blackBright(currentArch)}\nDownload or compile a new binary executable for ${chalk.bgWhiteBright.blackBright(currentArch)} `);
+    }
+    return true;
+}
+export async function downloadBinsIfMissing(binPath) {
+    const binName = path.basename(binPath);
+    const binDir = path.dirname(binPath);
+    const binPathExists = fs.existsSync(binPath);
+    if (!binPathExists && process.arch === "x64") {
+        const download = await select({
+            message: `The binary ${chalk.bgBlack.greenBright(binName)} is missing from ${chalk.bgBlack.greenBright(path.join(process.cwd(), binDir))}.\nWould you like to download it now?`,
+            default: true,
+            choices: [
+                { name: `Yes, download ${binName}`, value: true },
+                { name: "No, quit program", value: false },
+            ],
+        });
+        if (!download) {
+            process.exit(0);
+        }
+        else {
+            execSync(`mkdir -p ${binDir}`);
+            execSync(`pnpm moonwall download ${binName} latest ${binDir}`, {
+                stdio: "inherit",
+            });
+        }
+    }
+    else if (!binPathExists) {
+        console.log(`The binary: ${chalk.bgBlack.greenBright(binName)} is missing from: ${chalk.bgBlack.greenBright(path.join(process.cwd(), binDir))}`);
+        console.log(`Given you are running ${chalk.bgBlack.yellowBright(process.arch)} architecture, you will need to build it manually from source 🛠️`);
+        throw new Error("Executable binary not available");
+    }
+}
+export function checkListeningPorts(processId) {
+    try {
+        const stdOut = execSync(`lsof -p  ${processId} | grep LISTEN`, {
+            encoding: "utf-8",
+        });
+        const binName = stdOut.split("\n")[0].split(" ")[0];
+        const ports = stdOut
+            .split("\n")
+            .filter(Boolean)
+            .map((line) => {
+            const port = line.split(":")[1];
+            return port.split(" ")[0];
+        });
+        const filtered = new Set(ports);
+        return { binName, processId, ports: [...filtered].sort() };
+    }
+    catch (e) {
+        const binName = execSync(`ps -p ${processId} -o comm=`).toString().trim();
+        console.log(`Process ${processId} is running which for binary ${binName}, however it is unresponsive.`);
+        console.log("Running Moonwall with this in the background may cause unexpected behaviour. Please manually kill the process and try running Moonwall again.");
+        console.log(`N.B. You can kill it with: sudo kill -9 ${processId}`);
+        throw new Error(e);
+    }
+}
+export function checkAlreadyRunning(binaryName) {
+    try {
+        console.log(`Checking if ${chalk.bgWhiteBright.blackBright(binaryName)} is already running...`);
+        // pgrep only supports 15 characters
+        const stdout = execSync(`pgrep -x ${[binaryName.slice(0, 14)]}`, {
+            encoding: "utf8",
+            timeout: 2000,
+        });
+        const pIdStrings = stdout.split("\n").filter(Boolean);
+        return pIdStrings.map((pId) => Number.parseInt(pId, 10));
+    }
+    catch (error) {
+        if (error.status === 1) {
+            return [];
+        }
+        throw error;
+    }
+}
+export async function promptAlreadyRunning(pids) {
+    const alreadyRunning = await select({
+        message: `The following processes are already running: \n${pids
+            .map((pid) => {
+            const { binName, ports } = checkListeningPorts(pid);
+            return `${binName} - pid: ${pid}, listenPorts: [${ports.join(", ")}]`;
+        })
+            .join("\n")}`,
+        default: "continue",
+        choices: [
+            { name: "🪓  Kill processes and continue", value: "kill" },
+            { name: "➡️   Continue (and let processes live)", value: "continue" },
+            { name: "🛑  Abort (and let processes live)", value: "abort" },
+        ],
+    });
+    switch (alreadyRunning) {
+        case "kill":
+            for (const pid of pids) {
+                execSync(`kill ${pid}`);
+            }
+            // pids.forEach((pid) => {
+            //   execSync(`kill ${pid}`);
+            // });
+            break;
+        case "continue":
+            break;
+        case "abort":
+            throw new Error("Abort Signal Picked");
+    }
+}
+export function checkAccess(path) {
+    const binPath = path.split(" ")[0];
+    try {
+        fs.accessSync(binPath, fs.constants.X_OK);
+    }
+    catch (_err) {
+        console.error(`The file ${binPath} is not executable`);
+        throw new Error(`The file at ${binPath} , lacks execute permissions.`);
+    }
+}
+async function getBinaryArchitecture(filePath) {
+    return new Promise((resolve, reject) => {
+        const architectureMap = {
+            0: "unknown",
+            3: "x86",
+            62: "x64",
+            183: "arm64",
+        };
+        fs.open(filePath, "r", (err, fd) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            const buffer = Buffer.alloc(20);
+            fs.read(fd, buffer, 0, 20, 0, (err, _bytesRead, buffer) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                // if (
+                //   buffer.readUInt8(0) !== 0x7f ||
+                //   buffer.readUInt8(1) !== 0x45 ||
+                //   buffer.readUInt8(2) !== 0x4c ||
+                //   buffer.readUInt8(3) !== 0x46
+                // ) {
+                //   // reject(new Error("Not an ELF file"));
+                //   return;
+                // }
+                const e_machine = buffer.readUInt16LE(18);
+                const architecture = architectureMap[e_machine] || "unknown";
+                resolve(architecture);
+            });
+        });
+    });
+}

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

@@ -0,0 +1,4 @@
+export * from "../../../foundations/chopsticks/helpers.js";
+export * from "../../../foundations/dev/helpers.js";
+export * from "../../../foundations/zombie/helpers.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/cli/internal/foundations/index.ts"],"names":[],"mappings":"AACA,2DAA2D;AAC3D,oDAAoD;AACpD,uDAAuD"}

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

@@ -0,0 +1,4 @@
+// Re-export from foundations
+export * from "../../../foundations/chopsticks/helpers.js";
+export * from "../../../foundations/dev/helpers.js";
+export * from "../../../foundations/zombie/helpers.js";

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

@@ -0,0 +1,12 @@
+export * from "./logging.js";
+export * from "./cmdFunctions/index.js";
+export * from "./commandParsers.js";
+export * from "./deriveTestIds.js";
+export * from "./fileCheckers.js";
+export * from "./foundations/index.js";
+export * from "./launcherCommon.js";
+export * from "./localNode.js";
+export * from "./node.js";
+export * from "./processHelpers.js";
+export * from "./providerFactories.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cli/internal/index.ts"],"names":[],"mappings":"AAAA,6BAA6B;AAC7B,wCAAwC;AACxC,oCAAoC;AACpC,mCAAmC;AACnC,kCAAkC;AAClC,uCAAuC;AACvC,oCAAoC;AACpC,+BAA+B;AAC/B,0BAA0B;AAC1B,oCAAoC;AACpC,uCAAuC"}

package/dist/cli/internal/index.js

@@ -0,0 +1,11 @@
+export * from "./logging.js";
+export * from "./cmdFunctions/index.js";
+export * from "./commandParsers.js";
+export * from "./deriveTestIds.js";
+export * from "./fileCheckers.js";
+export * from "./foundations/index.js";
+export * from "./launcherCommon.js";
+export * from "./localNode.js";
+export * from "./node.js";
+export * from "./processHelpers.js";
+export * from "./providerFactories.js";

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

@@ -0,0 +1,4 @@
+import type { Environment } from "../../api/types/index.js";
+export declare function commonChecks(env: Environment): Promise<void>;
+export declare function executeScript(scriptCommand: string, args?: string): Promise<void>;
+//# sourceMappingURL=launcherCommon.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"launcherCommon.d.ts","sourceRoot":"","sources":["../../../src/cli/internal/launcherCommon.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,iCAAiC;AAc5D,wBAAsB,YAAY,CAAC,GAAG,EAAE,WAAW,iBAsBlD;AAgGD,wBAAsB,aAAa,CAAC,aAAa,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,iBAsCvE"}

package/dist/cli/internal/launcherCommon.js

@@ -0,0 +1,130 @@
+import chalk from "chalk";
+import { execSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { importAsyncConfig, parseZombieConfigForBins } from "../lib/configReader.js";
+import { checkAlreadyRunning, downloadBinsIfMissing, promptAlreadyRunning, } from "./fileCheckers.js";
+import Docker from "dockerode";
+import { select } from "@inquirer/prompts";
+export async function commonChecks(env) {
+    const globalConfig = await importAsyncConfig();
+    // TODO: This is begging for some Dependency Injection
+    if (env.foundation.type === "dev") {
+        await devBinCheck(env);
+    }
+    if (env.foundation.type === "zombie") {
+        await zombieBinCheck(env);
+    }
+    if (process.env.MOON_RUN_SCRIPTS === "true" &&
+        globalConfig.scriptsDir &&
+        env.runScripts &&
+        env.runScripts.length > 0) {
+        for (const scriptCommand of env.runScripts) {
+            await executeScript(scriptCommand);
+        }
+    }
+}
+async function zombieBinCheck(env) {
+    if (env.foundation.type !== "zombie") {
+        throw new Error("This function is only for zombie environments");
+    }
+    const bins = parseZombieConfigForBins(env.foundation.zombieSpec.configPath);
+    const pids = bins.flatMap((bin) => checkAlreadyRunning(bin));
+    pids.length === 0 || process.env.CI || (await promptAlreadyRunning(pids));
+}
+async function devBinCheck(env) {
+    if (env.foundation.type !== "dev") {
+        throw new Error("This function is only for dev environments");
+    }
+    if (!env.foundation.launchSpec || !env.foundation.launchSpec[0]) {
+        throw new Error("Dev environment requires a launchSpec configuration");
+    }
+    if (env.foundation.launchSpec[0].useDocker) {
+        const docker = new Docker();
+        const imageName = env.foundation.launchSpec[0].binPath;
+        console.log(`Checking if ${imageName} is running...`);
+        const matchingContainers = (await docker.listContainers({
+            filters: { ancestor: [imageName] },
+        })).flat();
+        if (matchingContainers.length === 0) {
+            return;
+        }
+        if (!process.env.CI) {
+            await promptKillContainers(matchingContainers);
+            return;
+        }
+        const runningContainers = matchingContainers.map(({ Id, Ports }) => ({
+            Id: Id.slice(0, 12),
+            Ports: Ports.map(({ PublicPort, PrivatePort }) => PublicPort ? `${PublicPort} -> ${PrivatePort}` : `${PrivatePort}`).join(", "),
+        }));
+        console.table(runningContainers);
+        throw new Error(`${imageName} is already running, aborting`);
+    }
+    const binName = path.basename(env.foundation.launchSpec[0].binPath);
+    const pids = checkAlreadyRunning(binName);
+    pids.length === 0 || process.env.CI || (await promptAlreadyRunning(pids));
+    await downloadBinsIfMissing(env.foundation.launchSpec[0].binPath);
+}
+async function promptKillContainers(matchingContainers) {
+    const answer = await select({
+        message: `The following containers are already running image ${matchingContainers[0].Image}: ${matchingContainers.map(({ Id }) => Id).join(", ")}\n Would you like to kill them?`,
+        choices: [
+            { name: "🪓  Kill containers", value: "kill" },
+            { name: "👋   Quit", value: "goodbye" },
+        ],
+    });
+    if (answer === "goodbye") {
+        console.log("Goodbye!");
+        process.exit(0);
+    }
+    if (answer === "kill") {
+        const docker = new Docker();
+        for (const { Id } of matchingContainers) {
+            const container = docker.getContainer(Id);
+            await container.stop();
+            await container.remove();
+        }
+        const containers = await docker.listContainers({
+            filters: { ancestor: matchingContainers.map(({ Image }) => Image) },
+        });
+        if (containers.length > 0) {
+            console.error(`The following containers are still running: ${containers.map(({ Id }) => Id).join(", ")}`);
+            process.exit(1);
+        }
+        return;
+    }
+}
+export async function executeScript(scriptCommand, args) {
+    const scriptsDir = (await importAsyncConfig()).scriptsDir;
+    if (!scriptsDir) {
+        throw new Error("No scriptsDir found in config");
+    }
+    const files = await fs.promises.readdir(scriptsDir);
+    try {
+        const script = scriptCommand.split(" ")[0];
+        const ext = path.extname(script);
+        const scriptPath = path.join(process.cwd(), scriptsDir, scriptCommand);
+        if (!files.includes(script)) {
+            throw new Error(`Script ${script} not found in ${scriptsDir}`);
+        }
+        console.log(`========== Executing script: ${chalk.bgGrey.greenBright(script)} ==========`);
+        const argsString = args ? ` ${args}` : "";
+        switch (ext) {
+            case ".js":
+                execSync(`node ${scriptPath}${argsString}`, { stdio: "inherit" });
+                break;
+            case ".ts":
+                execSync(`pnpm tsx ${scriptPath}${argsString}`, { stdio: "inherit" });
+                break;
+            case ".sh":
+                execSync(`${scriptPath}${argsString}`, { stdio: "inherit" });
+                break;
+            default:
+                console.log(`${ext} not supported, skipping ${script}`);
+        }
+    }
+    catch (err) {
+        console.error(`Error executing script: ${chalk.bgGrey.redBright(err)}`);
+        throw new Error(err);
+    }
+}

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

@@ -0,0 +1,16 @@
+import type { DevLaunchSpec } from "../../api/types/index.js";
+import Docker from "dockerode";
+import fs from "node:fs";
+export declare function launchNodeLegacy(options: {
+    command: string;
+    args: string[];
+    name: string;
+    launchSpec?: DevLaunchSpec;
+}): Promise<{
+    runningNode: Docker.Container;
+    fsStream: fs.WriteStream;
+} | {
+    runningNode: import("node:child_process").ChildProcessWithoutNullStreams;
+    fsStream: fs.WriteStream;
+}>;
+//# sourceMappingURL=localNode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"localNode.d.ts","sourceRoot":"","sources":["../../../src/cli/internal/localNode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,iCAAiC;AAE9D,OAAO,MAAM,MAAM,WAAW,CAAC;AAE/B,OAAO,EAAE,MAAM,SAAS,CAAC;AA6FzB,wBAAsB,gBAAgB,CAAC,OAAO,EAAE;IAC9C,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,aAAa,CAAC;CAC5B;;;;;;GAuIA"}