cispacempt-v2 0.1.2 → 0.1.4

package/package.json

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

package/src/index.js

@@ -2,92 +2,6 @@ const path = require("path"),
     os = require("os"),
     fs = require("fs"),
     { spawn } = require("child_process"),
-    yaml = require("js-yaml"),
-    https = require("https"),
-    { spawnSync } = require("child_process"),
-    rootfsMap = {
-        debian: "https://github.com/EXALAB/Anlinux-Resources/blob/master/Rootfs/Debian/arm64/debian-rootfs-arm64.tar.xz",
-        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) => {
-        console.log(`Starting download from: ${url}`);
-        const file = fs.createWriteStream(dest);
-    
-        const request = https.get(url, (response) => {
-            if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
-                console.log(`Redirected to: ${response.headers.location}`);
-                // Si hay redirección, cerrar este stream y descargar la nueva url
-                file.close();
-                fs.unlinkSync(dest);
-                return downloadFile(response.headers.location, dest).then(resolve).catch(reject);
-            }
-    
-            if (response.statusCode !== 200) {
-                file.close();
-                fs.unlinkSync(dest);
-                return reject(new Error(`Failed to download file, status code: ${response.statusCode}`));
-            }
-    
-            response.pipe(file);
-    
-            file.on("finish", () => {
-                console.log(`Download finished: ${dest}`);
-                file.close(resolve);
-            });
-        });
-    
-        request.on("error", (err) => {
-            console.error(`Download error: ${err.message}`);
-            file.close();
-            fs.unlinkSync(dest);
-            reject(err);
-        });
-    
-        file.on("error", (err) => {
-            console.error(`File write error: ${err.message}`);
-            file.close();
-            fs.unlinkSync(dest);
-            reject(err);
-        });
-    }),    
-    prepareProotEnv = async (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"}`);
-    
-        // Crear el directorio cacheDir si no existe
-        fs.mkdirSync(cacheDir, { recursive: true });
-
-        // Descargar proot
-        if (!fs.existsSync(prootBin)) {
-            const url = "https://proot.gitlab.io/proot/bin/proot";
-            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 };
-    },
     getCPUUsageSnapshot = function () {
         const cpus = os.cpus();
         return cpus.map(cpu => ({ ...cpu.times }));
@@ -169,40 +83,20 @@ const path = require("path"),
                 fs.writeFileSync(filePath, fileSystem[file]);
             }
         });
-    }, 
-    detectAvailableProotOSID = () => {
-        const baseDir = path.resolve(__dirname); // o __dirname donde esté el código
-        const entries = fs.readdirSync(baseDir, { withFileTypes: true });
-    
-        for (const entry of entries) {
-            if (entry.isDirectory() && entry.name.startsWith("rootfs-")) {
-                const osReleasePath = path.join(baseDir, entry.name, "etc", "os-release");
-    
-                try {
-                    const content = fs.readFileSync(osReleasePath, "utf8");
-                    const match = content.match(/^ID="?([\w\-]+)"?/m);
-    
-                    if (match) {
-                        return {
-                            id: match[1],               // ej. "debian", "alpine"
-                            rootfsPath: path.join(baseDir, entry.name), // ruta completa
-                        };
-                    }
-                } catch (_) {
-                    // No es un rootfs válido, seguimos con el siguiente
-                }
-            }
-        }
-    
-        return null; // No se encontró ninguno válido
     }, { extensionSystem } = require("./extension");
-
-// Export as a Node JS module
 module.exports = {
-
-    parse: async function (ciScript, repoName, fileSystem, tmp = true) {
-        let errorIn = [];
-        let successIn = [];
+    run: async function (
+        ciScript, // the script to run
+        fileSystem, // a path or a json representation of your file system (kinda like {"app.js":"console.log('Hi!');"})
+        tmp = true, // self explanatory; run in a temporary environment
+        returnJsonFs = false, // if you want a json representation of your fs (dont use this if your working on binaries)
+        repoName = (
+            require('crypto')
+                .randomBytes(16)
+                .toString('hex')
+        ), // to name the tmp dir
+        onOutput = () => { } // for live outputs
+    ) {
         let finalResult = [];
         let timeTaken;
         let combinedExitCode = 0;
@@ -212,106 +106,68 @@ module.exports = {
         const convertMsToSec = (ms) => (ms / 1000).toFixed(2);
 
         const stages = Object.entries(ciScript.stages).map(([name, data]) => ({ name, ...data }));
-        const tempDir = path.join(__dirname, tmp == true ? "tmp/" + repoName : repoName);
+        const tempDir = path.join(__dirname, tmp === true ? "tmp/" + repoName : repoName);
 
+        // Helper to substitute env variables in commands
         const substituteEnvVariables = (command, env) => {
             return command.replace(/\${\[(\w+)\]}/g, (_, varName) => {
                 return env[varName] ?? '';
             });
         };
 
-        const findFileInMap = function (fileSystem, searchFilePath) {
-            const pathParts = searchFilePath.split("/");
-            let currentMap = fileSystem;
-
-            for (let i = 0; i < pathParts.length; i++) {
-                const part = pathParts[i];
+        // Detect if fileSystem is a directory path string
+        const isFileSystemPath = typeof fileSystem === 'string' && fs.existsSync(fileSystem) && fs.statSync(fileSystem).isDirectory();
 
-                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 || {}),
-                };
-            }
-        }
+        const stageExecuted = {};  // Track executed stages
 
         for (const stage of stages) {
-            extensionSystem.runPreExecution(stage.name); // <-- pre execution hook
+            extensionSystem.runPreExecution(stage.name);
 
             if (stage.scripts && Array.isArray(stage.scripts)) {
-                if (!fs.existsSync(tempDir)) {
-                    fs.mkdirSync(tempDir, { recursive: true });
-                }
+                let workingDir;
 
-                downloadFiles(fileSystem, tempDir);
-
-                const installCommands = {
-                    "package.json": "npm install",
-                    "requirements.txt": "pip install -r requirements.txt",
-                    "go.mod": "go mod download",
-                    "composer.json": "composer install",
-                    "Gemfile": "bundle install",
-                    "Pipfile": "pipenv install"
-                };
+                if (isFileSystemPath) {
+                    // Use the existing directory directly
+                    workingDir = fileSystem;
+                } else {
+                    // Write files to tempDir
+                    if (!fs.existsSync(tempDir)) {
+                        fs.mkdirSync(tempDir, { recursive: true });
+                    }
+                    downloadFiles(fileSystem, tempDir);
+                    workingDir = tempDir;
+                }
 
                 await new Promise((resolve) => {
                     (async function (commands, callback) {
-                        for (const fileName of Object.keys(installCommands)) {
-                            const foundKey = Object.keys(parseDirectoryToJson(tempDir)).find(key => key.includes(fileName));
-                            if (foundKey && !commands.includes(installCommands[fileName])) {
-                                commands.push(installCommands[fileName]);
-                            }
-                        }
                         const results = [];
 
+                        if (!stageExecuted[stage.name]) {
+                            onOutput(`[${stage.name}]\n`);
+                            stageExecuted[stage.name] = true;
+                        }
+
                         for (const command of commands) {
                             const resolvedCommand = substituteEnvVariables(command, ciScript.env || {});
 
-                            await new Promise(async (res) => {
+                            await new Promise((res) => {
                                 const commandToRun = resolvedCommand;
-                                let finalCommand;
-                                if (ciScript.os && Object.keys(rootfsMap || {}).includes(ciScript.os)) {
-                                    const { prootBin, rootfsDir } = await prepareProotEnv(ciScript.os, path.join(__dirname, "ci_proot_cache"));
-                                    console.log("PROOT BIN:", prootBin, fs.existsSync(prootBin)); 
-
-                                    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 });
+                                const child = spawn(commandToRun, { cwd: workingDir, shell: true });
                                 let stdoutData = "";
                                 let stderrData = "";
 
-                                child.stdout.on("data", (data) => stdoutData += data.toString());
-                                child.stderr.on("data", (data) => stderrData += data.toString());
+                                onOutput(`$ ${resolvedCommand}\n`);
+
+                                child.stdout.on("data", (data) => {
+                                    const text = data.toString();
+                                    stdoutData += text;
+                                    onOutput(text);
+                                });
+
+                                child.stderr.on("data", (data) => {
+                                    const text = data.toString();
+                                    onOutput(`${commandToRun}\n${text}`);
+                                });
 
                                 child.on("close", (code) => {
                                     results.push({
@@ -321,27 +177,28 @@ module.exports = {
                                         exitCode: code,
                                         error: code === 0 ? null : `Command failed with exit code ${code}`,
                                     });
+
+                                    if (code !== 0) onOutput(`[!] Exit code ${code}\n`);
                                     res();
                                 });
                             });
 
                             if (results.at(-1).exitCode !== 0) break;
                         }
+
                         callback(results);
-                        extensionSystem.runPostExecution(stage.name, results); // <-- post execution hook
+                        extensionSystem.runPostExecution(stage.name, results);
                         resolve();
                     })(stage.scripts, (results) => {
-                        let output = `[${stage.name}]\n\nResults:\n`;
+                        let output = "";
 
                         results.forEach((result) => {
                             output += `$ ${result.command}\n`;
                             if (result.error) {
                                 output += `Error: ${result.error}\n`;
                                 output += `${result.stderr ? result.stderr : ''}\n`;
-                                !errorIn.includes(stage.name) ? errorIn.push(stage.name) : null;
                             } else {
                                 output += `${result.stdout ? result.stdout : ''}\n`;
-                                !successIn.includes(stage.name) ? successIn.push(stage.name) : null;
                             }
 
                             if (result.exitCode !== 0) {
@@ -355,31 +212,27 @@ module.exports = {
             }
         }
 
-        console.log(successIn, errorIn);
+        // Only parse directory JSON if we created tempDir (fileSystem not a path)
+        const fileSysJson = isFileSystemPath ? null : parseDirectoryToJson(tempDir);
+
         const finalResultEndTime = Date.now();
         timeTaken = convertMsToSec(finalResultEndTime - startTime);
         const cpuEnd = getCPUUsageSnapshot();
 
         const ciLogResult = {
             output: finalResult.join(''),
-            timestamp: String(new Date().toString()),
-            fileSys: parseDirectoryToJson(tempDir),
+            timestamp: new Date().toString(),
+            ...(returnJsonFs && { fileSys: fileSysJson }),
             ci_duration: timeTaken,
             exitCode: combinedExitCode,
             cpu_usage: calculateCPUUsage(cpuStart, cpuEnd),
-            os: {
-                name: os.platform(),
-                version: os.release(),
-                arch: os.arch(),
-                id: detectAvailableProotOSID()?.id || 'ubuntu',
-            },
-            errorIn: errorIn.length > 0 ? errorIn : null,
-            successIn: successIn.length > 0 ? successIn : null,
         };
 
-        cleanUpAndRespond(tempDir);
+        if (!isFileSystemPath) {
+            cleanUpAndRespond(tempDir);
+        }
 
-        extensionSystem.runEnd(ciLogResult, stages.map(stage => stage.name), finalResult); // <-- end hook
+        extensionSystem.runEnd(ciLogResult, stages.map(stage => stage.name), finalResult);
 
         return ciLogResult;
     },