cispacempt-v2 0.1.3 → 0.1.4

package/package.json

@@ -1,7 +1,7 @@
 {
   "main": "src/index.js",
   "name": "cispacempt-v2",
-  "version": "0.1.3",
+  "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,7 +2,6 @@ const path = require("path"),
     os = require("os"),
     fs = require("fs"),
     { spawn } = require("child_process"),
-    yaml = require("js-yaml"),
     getCPUUsageSnapshot = function () {
         const cpus = os.cpus();
         return cpus.map(cpu => ({ ...cpu.times }));
@@ -84,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;
@@ -127,97 +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];
-
-                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
-        }
+        // Detect if fileSystem is a directory path string
+        const isFileSystemPath = typeof fileSystem === 'string' && fs.existsSync(fileSystem) && fs.statSync(fileSystem).isDirectory();
 
-        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 });
-                }
-
-                downloadFiles(fileSystem, tempDir);
+                let workingDir;
 
-                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;
-                                const child = spawn(commandToRun, { 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({
@@ -227,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) {
@@ -261,30 +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(),
-            },
-            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;
     },