cispacempt-v2 0.0.5 → 0.0.7

package/package.json

@@ -1,7 +1,7 @@
 {
   "main": "src/index.js",
   "name": "cispacempt-v2",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "Fast CI engine for CodespaceMPT with script stages and file system hooks",
   "author": "argentidev",
   "license": "MIT",

package/src/index.js

@@ -2,6 +2,8 @@ const path = require("path"),
     os = require("os"),
     fs = require("fs"),
     { spawn } = require("child_process"),
+    { prepareProotEnv } = require("./lib/prootEnv"),
+    yaml = require("js-yaml"),
     getCPUUsageSnapshot = function () {
         const cpus = os.cpus();
         return cpus.map(cpu => ({ ...cpu.times }));
@@ -108,6 +110,49 @@ module.exports = {
             });
         };
 
+        const findFileInMap = function (fileSystem, searchFilePath) {
+            const pathParts = searchFilePath.split("/");
+            let currentMap = fileSystem;
+
+            for (let i = 0; i < pathParts.length; i++) {
+                const part = pathParts[i];
+
+                if (currentMap[part]) {
+                    if (typeof currentMap[part] === "object") {
+                        currentMap = currentMap[part];
+                    } else {
+                        return currentMap[part]; // Return the found file if it exists
+                    }
+                } else {
+                    return null; // Return null if not found at all
+                }
+            }
+
+            return null; // Return null if path doesn't exist
+        }
+
+        if (ciScript.include) {
+            for (const includePath of ciScript.include) {
+                const templateContent = findFileInMap(fileSystem, includePath);
+                if (!templateContent) {
+                    console.warn(`Included file '${includePath}' not found`);
+                    continue;
+                }
+
+                const includedYaml = yaml.load(templateContent);
+
+                // Merge included content
+                ciScript.stages = {
+                    ...(includedYaml.stages || {}),
+                    ...(ciScript.stages || {})
+                };
+                ciScript.env = {
+                    ...(includedYaml.env || {}),
+                    ...(ciScript.env || {}),
+                };
+            }
+        }
+
         for (const stage of stages) {
             extensionSystem.runPreExecution(stage.name); // <-- pre execution hook
 
@@ -140,9 +185,17 @@ module.exports = {
                         for (const command of commands) {
                             const resolvedCommand = substituteEnvVariables(command, ciScript.env || {});
 
-                            await new Promise((res) => {
+                            await new Promise(async (res) => {
                                 const commandToRun = resolvedCommand;
-                                const child = spawn(commandToRun, { cwd: tempDir, shell: true });
+                                let finalCommand;
+                                if (ciScript.os && Object.keys(require("./lib/prootEnv").prepareProotEnv.rootfsMap || {}).includes(ciScript.os)) {
+                                    const { prootBin, rootfsDir } = await prepareProotEnv(ciScript.os, path.join(__dirname, "ci_proot_cache"));
+
+                                    finalCommand = `${prootBin} -R ${rootfsDir} -b ${tempDir}:/sandbox -w /sandbox /bin/sh -c "${commandToRun.replace(/"/g, '\\"')}"`;
+                                } else {
+                                    finalCommand = commandToRun;
+                                }
+                                const child = spawn(finalCommand, { cwd: tempDir, shell: true });
                                 let stdoutData = "";
                                 let stderrData = "";
 
@@ -191,6 +244,7 @@ module.exports = {
             }
         }
 
+        console.log(successIn, errorIn);
         const finalResultEndTime = Date.now();
         timeTaken = convertMsToSec(finalResultEndTime - startTime);
         const cpuEnd = getCPUUsageSnapshot();

package/src/lib/prootEnv.js

@@ -0,0 +1,59 @@
+const fs = require("fs");
+const path = require("path");
+const { spawnSync } = require("child_process");
+const https = require("https");
+
+const rootfsMap = {
+    debian: "https://github.com/Proot-me/proot-distro/releases/download/20240515/debian-rootfs.tar.gz",
+    alpine: "https://dl-cdn.alpinelinux.org/alpine/latest-stable/releases/x86_64/alpine-minirootfs-3.19.1-x86_64.tar.gz",
+    ubuntu: "https://partner-images.canonical.com/core/focal/current/ubuntu-focal-core-cloudimg-amd64-root.tar.gz",
+    arch: "https://mirror.rackspace.com/archlinux/iso/latest/archlinux-bootstrap-x86_64.tar.gz",
+    void: "https://repo-default.voidlinux.org/live/current/void-x86_64-ROOTFS-20230628.tar.xz",
+    fedora: "https://download.fedoraproject.org/pub/fedora/linux/releases/39/Container/x86_64/images/Fedora-Container-Base-39-1.5.x86_64.tar.xz",
+    centos: "https://buildlogs.centos.org/centos/7/container/x86_64/images/CentOS-7-Container-7.9.2009-20210916.0.x86_64.tar.xz"
+};
+
+const downloadFile = (url, dest) => new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(dest);
+    https.get(url, (response) => {
+        response.pipe(file);
+        file.on("finish", () => {
+            file.close(resolve);
+        });
+    }).on("error", (err) => {
+        fs.unlinkSync(dest);
+        reject(err);
+    });
+});
+
+async function prepareProotEnv(osName, cacheDir) {
+    const prootBin = path.join(cacheDir, "proot");
+    const rootfsDir = path.join(cacheDir, `rootfs_${osName}`);
+    const tarball = path.join(cacheDir, `${osName}.tar.${osName.includes("xz") ? "xz" : "gz"}`);
+
+    // Descargar proot
+    if (!fs.existsSync(prootBin)) {
+        const url = "https://github.com/proot-me/proot/releases/download/v5.3.0/proot-static";
+        await downloadFile(url, prootBin);
+        fs.chmodSync(prootBin, 0o755);
+    }
+
+    // Descargar rootfs
+    if (!fs.existsSync(rootfsDir)) {
+        const url = rootfsMap[osName];
+        if (!url) throw new Error(`Unsupported OS "${osName}"`);
+        await downloadFile(url, tarball);
+
+        fs.mkdirSync(rootfsDir, { recursive: true });
+
+        // Extraer el tarball
+        const extCmd = tarball.endsWith(".xz") ? "tar -xJf" : "tar -xzf";
+        spawnSync(extCmd, [tarball, "-C", rootfsDir], { shell: true });
+
+        fs.unlinkSync(tarball); // limpiar
+    }
+
+    return { prootBin, rootfsDir };
+}
+
+module.exports = { prepareProotEnv };