cispacempt-v2 0.1.5 → 0.1.7

package/package.json

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

package/src/index.js

@@ -1,4 +1,5 @@
 const path = require("path"),
+    execa = require('execa'),
     os = require("os"),
     fs = require("fs"),
     { spawn } = require("child_process"),
@@ -83,160 +84,157 @@ const path = require("path"),
                 fs.writeFileSync(filePath, fileSystem[file]);
             }
         });
+    },
+    captureConsole = (captureLog) => {
+        const originalConsole = { ...console };
+        const originalStdout = process.stdout.write;
+        const originalStderr = process.stderr.write;
+        let insideOverride = false;
+
+        const logToCapture = (text) => {
+            if (insideOverride) return;
+            insideOverride = true;
+            try {
+                const t = String(text ?? '');
+                captureLog(t.endsWith('\n') ? t : t + '\n');
+            } catch { }
+            insideOverride = false;
+        };
+
+        console.log = console.info = console.warn = console.error = console.debug = (...args) => {
+            logToCapture(args.map(a => String(a ?? '')).join(' ') + '\n');
+        };
+
+        process.stdout.write = (chunk, encoding, cb) => {
+            logToCapture(chunk);
+            return originalStdout.call(process.stdout, chunk, encoding, cb);
+        };
+
+        process.stderr.write = (chunk, encoding, cb) => {
+            logToCapture(chunk);
+            return originalStderr.call(process.stderr, chunk, encoding, cb);
+        };
+
+        process.on('uncaughtException', (err) => logToCapture(`[uncaughtException] ${err.stack || err}\n`));
+        process.on('unhandledRejection', (err) => logToCapture(`[unhandledRejection] ${err?.stack || err}\n`));
+        process.on('warning', (warn) => logToCapture(`[warning] ${warn.stack || warn}\n`));
+
+        return () => {
+            console.log = originalConsole.log;
+            console.info = originalConsole.info;
+            console.warn = originalConsole.warn;
+            console.error = originalConsole.error;
+            console.debug = originalConsole.debug;
+            process.stdout.write = originalStdout;
+            process.stderr.write = originalStderr;
+        };
     }, { extensionSystem } = require("./extension");
 module.exports = {
     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
+        ciScript,
+        fileSystem,
+        tmp = true,
+        returnJsonFs = false,
+        repoName = require('crypto').randomBytes(16).toString('hex'),
+        onOutput = () => { },
+        { extensions = [] } = {}
     ) {
-        let finalResult = [];
-        let timeTaken;
-        let combinedExitCode = 0;
-        let startTime = Date.now();
+        const finalResult = [];
         const cpuStart = getCPUUsageSnapshot();
+        const startTime = Date.now();
 
-        const convertMsToSec = (ms) => (ms / 1000).toFixed(2);
-
-        const stages = Object.entries(ciScript.stages).map(([name, data]) => ({ name, ...data }));
+        const stages = Object.entries(ciScript.stages || {}).map(([name, data]) => ({ name, ...data }));
         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] ?? '';
-            });
-        };
-
-        // Detect if fileSystem is a directory path string
+        const localExtensionSystem = { ...extensionSystem, extensions: extensions.slice() };
+        const substituteEnvVariables = (command, env) =>
+            command?.replace(/\${\[(\w+)\]}/g, (_, varName) => env?.[varName] ?? '') ?? '';
         const isFileSystemPath = typeof fileSystem === 'string' && fs.existsSync(fileSystem) && fs.statSync(fileSystem).isDirectory();
-        console.log(isFileSystemPath);
 
-        const stageExecuted = {};  // Track executed stages
+        const captureLog = text => {
+            const t = text?.toString() ?? '';
+            finalResult.push(t.endsWith('\n') ? t : t + '\n');
+            onOutput(t);
+        };
 
         for (const stage of stages) {
-            extensionSystem.runPreExecution(stage.name);
-
-            if (stage.scripts && Array.isArray(stage.scripts)) {
-                let workingDir;
-
-                if (isFileSystemPath) {
-                    // Use the existing directory directly
-                    workingDir = fileSystem;
-                } else {
-                    // Write files to tempDir
-                    if (!fs.existsSync(tempDir)) {
-                        fs.mkdirSync(tempDir, { recursive: true });
+            // PreExecute
+            for (const ext of localExtensionSystem.extensions) {
+                if (typeof ext.preExecute === 'function') {
+                    const restoreConsole = captureConsole(captureLog);
+                    try {
+                        await ext.preExecute(stage.name, captureLog);
+                    } finally {
+                        restoreConsole();
                     }
-                    downloadFiles(fileSystem, tempDir);
-                    workingDir = tempDir;
                 }
+            }
 
-                await new Promise((resolve) => {
-                    (async function (commands, callback) {
-                        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((res) => {
-                                const commandToRun = resolvedCommand;
-                                const child = spawn(commandToRun, { cwd: workingDir, shell: true });
-                                let stdoutData = "";
-                                let stderrData = "";
-
-                                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({
-                                        command: resolvedCommand,
-                                        stdout: stdoutData,
-                                        stderr: stderrData,
-                                        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);
-                        resolve();
-                    })(stage.scripts, (results) => {
-                        let output = "";
-
-                        results.forEach((result) => {
-                            output += `$ ${result.command}\n`;
-                            if (result.error) {
-                                output += `Error: ${result.error}\n`;
-                                output += `${result.stderr ? result.stderr : ''}\n`;
-                            } else {
-                                output += `${result.stdout ? result.stdout : ''}\n`;
-                            }
-
-                            if (result.exitCode !== 0) {
-                                combinedExitCode = result.exitCode;
-                            }
+            // Scripts
+            if (stage.scripts && Array.isArray(stage.scripts)) {
+                let workingDir = isFileSystemPath ? fileSystem : tempDir;
+                if (!isFileSystemPath && !fs.existsSync(tempDir)) fs.mkdirSync(tempDir, { recursive: true });
+
+                for (const command of stage.scripts) {
+                    const resolvedCommand = substituteEnvVariables(command, ciScript.env || {});
+                    try {
+                        const subprocess = await execa.command(resolvedCommand, {
+                            cwd: workingDir,
+                            shell: true,
                         });
+                        captureLog(subprocess.stdout);
+                    } catch (err) {
+                        captureLog(`[!] Exit code ${err.exitCode} for command: ${resolvedCommand}\n`);
+                        captureLog(err.stderr || '');
+                    }
+                }
+            }
 
-                        finalResult.push(output);
-                    });
-                });
+            // PostExecute
+            for (const ext of localExtensionSystem.extensions) {
+                if (typeof ext.postExecute === 'function') {
+                    const restoreConsole = captureConsole(captureLog);
+                    try {
+                        await ext.postExecute(stage.name, [], captureLog);
+                    } finally {
+                        restoreConsole();
+                    }
+                }
             }
+
         }
 
-        // 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 timeTaken = ((Date.now() - startTime) / 1000).toFixed(2);
         const cpuEnd = getCPUUsageSnapshot();
 
-        const ciLogResult = {
+        let ciLogResult = {
             output: finalResult.join(''),
-            timestamp: new Date().toString(),
+            timestamp: new Date().toISOString(),
             ...(returnJsonFs && { fileSys: fileSysJson }),
             ci_duration: timeTaken,
-            exitCode: combinedExitCode,
+            exitCode: 0,
             cpu_usage: calculateCPUUsage(cpuStart, cpuEnd),
         };
 
-        if (!isFileSystemPath) {
-            cleanUpAndRespond(tempDir);
+        for (const ext of localExtensionSystem.extensions) {
+            if (typeof ext.endExecute === 'function') {
+                const restoreConsole = captureConsole(captureLog);
+                try {
+                    // fuerza que todo el async de endExecute quede dentro del override
+                    await (async () => await ext.endExecute(ciLogResult, stages.map(s => s.name), finalResult, captureLog))();
+                } catch (err) {
+                    captureLog(`[!] Extension endExecute error: ${err}`);
+                }
+                // restauramos después de que todo terminó
+                restoreConsole();
+            }
         }
 
-        extensionSystem.runEnd(ciLogResult, stages.map(stage => stage.name), finalResult);
+        ciLogResult.output = finalResult.join('');
+
+        if (!isFileSystemPath) fs.rmSync(tempDir, { recursive: true, force: true });
 
         return ciLogResult;
     },
-
     dirToJson: parseDirectoryToJson
 };