cispacempt-v2 0.0.1

package/.codespacempt/origin

@@ -0,0 +1 @@
+codespacempt_ci

package/.csmptignore

@@ -0,0 +1,3 @@
+tmp/
+test.test.js
+// jfksdhfkjshfjskdhfkjhdfkjhsfdkjfhds

package/README.md

@@ -0,0 +1,108 @@
+# CodespaceMPT CI
+
+**CodespaceMPT CI** (CISpaceMPT) is a fast, efficient, and scalable Continuous Integration (CI) server that automates the execution of scripts in various stages of your CI pipeline. It is designed to integrate seamlessly with your repository, run defined commands, and log detailed results.
+
+## Installation
+
+## How It Works
+
+### CI Script Structure
+
+Your CI pipeline is defined in a JSON-based script. Each CI script contains several stages, each with its own set of commands to run. Below is an example of how to structure the CI script:
+
+```json
+{
+  "stages": {
+    "build": {
+      "scripts": [
+        "npm install",
+        "npm run build"
+      ]
+    },
+    "test": {
+      "scripts": [
+        "npm test"
+      ]
+    }
+  }
+}
+```
+
+- **stages**: Defines the different stages of the CI pipeline.
+- **scripts**: Lists the commands to be executed in each stage.
+
+### Execution Flow
+
+1. **Clone Repository**: The CI server clones the repository and checks out the required branch.
+2. **Parse Directory**: The file system of the repository is recursively traversed (excluding `node_modules`), capturing the directory structure and content.
+3. **Stage Execution**: For each stage defined in the CI script, the server executes the specified commands sequentially.
+4. **Log Results**: The output (stdout, stderr) from each command is captured and logged along with any errors and exit codes.
+5. **Time Tracking**: The duration of the CI process is calculated and logged.
+6. **Clean-up**: Once the pipeline is complete, temporary directories are deleted.
+
+### Example Usage
+
+Here’s how you can use the `parse` function to execute a CI script:
+
+```js
+const ci = require('codespacempt-ci');
+
+// Sample CI script
+const ciScript = {
+  stages: {
+    "build": {
+      scripts: [
+        "npm install",
+        "npm run build"
+      ]
+    },
+    "test": {
+      scripts: [
+        "npm test"
+      ]
+    }
+  }
+};
+
+// Repository name
+const repoName = "my-repo";
+
+// File system content to be used during execution
+const fileSystem = {/* your repository's file system in a json */};
+
+ci.parse(ciScript, repoName, fileSystem)
+  .then(result => {
+    console.log("CI Log Result:", result);
+  })
+  .catch(err => {
+    console.error("CI process failed:", err);
+  });
+```
+
+### Output
+
+The `parse` function returns an object containing the CI process result:
+
+```json
+{
+  "output": "CI logs for each stage",
+  "timestamp": "2025-04-14 12:00:00",
+  "fileSys": { /* Parsed file system after ci */ },
+  "ci_duration": "10.23",  // Duration in seconds
+  "exitCode": 0  // Exit code (0 for success, non-zero for failure)
+}
+```
+
+- **output**: Logs from each stage.
+- **timestamp**: The timestamp of when the CI process was run.
+- **fileSys**: A JSON object representing the repository’s file structure.
+- **ci_duration**: Total time taken for the CI process (in seconds).
+- **exitCode**: The exit code from the final stage (0 if all commands succeed).
+
+### Clean-Up
+
+After the execution, temporary directories are automatically cleaned up to save disk space.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

package/package.json

@@ -0,0 +1,20 @@
+{
+  "main": "src/index.js",
+  "name": "cispacempt-v2",
+  "version": "0.0.1",
+  "description": "Fast CI engine for CodespaceMPT with script stages and file system hooks",
+  "author": "argentidev",
+  "license": "MIT",
+  "homepage": "https://codespacemptio.onrender.com/home",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "csmpt",
+    "url": "https://codespacemptio.onrender.com/codespacempt/ci"
+  },
+  "keywords": [],
+  "dependencies": {
+    "typescript": "^5.8.3"
+  }
+}

package/src/extension.js

@@ -0,0 +1,31 @@
+// Extension system
+const extensionSystem = {
+    extensions: [],
+    loadExtension: function (extension) {
+        this.extensions.push(extension);
+    },
+    runPreExecution: function (stageName) {
+        this.extensions.forEach((extension) => {
+            if (extension.preExecute) {
+                extension.preExecute(stageName);
+            }
+        });
+    },
+    runPostExecution: function (stageName, results) {
+        this.extensions.forEach((extension) => {
+            if (extension.postExecute) {
+                extension.postExecute(stageName, results);
+            }
+        });
+    },
+    runEnd: function (ciLogResult, stageNames, finalResult) {
+        this.extensions.forEach((extension) => {
+            if (extension.endExecute) {
+                extension.endExecute(ciLogResult, stageNames, finalResult);
+            }
+        });
+    },
+};
+
+// Export the extension system
+module.exports.extensionSystem = extensionSystem;

package/src/index.js

@@ -0,0 +1,199 @@
+const path = require("path"),
+    os = require("os"),
+    fs = require("fs"),
+    { spawn } = require("child_process"),
+    getCPUUsageSnapshot = function () {
+        const cpus = os.cpus();
+        return cpus.map(cpu => ({ ...cpu.times }));
+    },
+    calculateCPUUsage = function (startSnapshot, endSnapshot) {
+        let idleDiff = 0;
+        let totalDiff = 0;
+
+        for (let i = 0; i < startSnapshot.length; i++) {
+            const start = startSnapshot[i];
+            const end = endSnapshot[i];
+
+            const idle = end.idle - start.idle;
+            const total = Object.keys(end).reduce((acc, key) => acc + (end[key] - start[key]), 0);
+
+            idleDiff += idle;
+            totalDiff += total;
+        }
+
+        const usage = 1 - idleDiff / totalDiff;
+        return (usage * 100).toFixed(2); // Percentage string
+    },
+    parseDirectoryToJson = function (directory) {
+        function parse(dirPath) {
+            let result = {};
+
+            const walkSync = (dir) => {
+                const files = fs.readdirSync(dir);
+                const dirs = files.filter((file) =>
+                    fs.statSync(path.join(dir, file)).isDirectory(),
+                );
+
+                const currentFolder = {};
+
+                // Excluir el directorio node_modules
+                const dirsToProcess = dirs.filter((dirName) => dirName !== 'node_modules');
+
+                dirsToProcess.forEach((dirName) => {
+                    const dirPath = path.join(dir, dirName);
+                    walkSync(dirPath); // Recursively process subdirectories
+                });
+
+                files.forEach((fileName) => {
+                    const filePath = path.join(dir, fileName);
+                    if (fs.statSync(filePath).isFile()) {
+                        const content = fs.readFileSync(filePath, "utf8");
+                        if (dir === directory) {
+                            result[fileName] = content; // Add files directly to the root
+                        } else {
+                            currentFolder[fileName] = content; // File content as string
+                        }
+                    }
+                });
+
+                // Agregar la estructura de carpetas, excepto node_modules
+                if (Object.keys(currentFolder).length > 0) {
+                    const relativePath = path.relative(directory, dir);
+                    if (relativePath !== 'node_modules') {
+                        result[relativePath] = currentFolder; // Add folder structure
+                    }
+                }
+            };
+
+            walkSync(dirPath);
+            return result;
+        }
+
+        return parse(directory);
+    }, cleanUpAndRespond = (tempDir) => fs.rmSync(tempDir, { recursive: true, force: true }),
+    downloadFiles = (fileSystem, baseDir) => {
+        Object.keys(fileSystem).forEach((file) => {
+            const filePath = path.join(baseDir, file);
+            if (typeof fileSystem[file] === "object") {
+                if (!fs.existsSync(filePath)) {
+                    fs.mkdirSync(filePath, { recursive: true });
+                }
+                downloadFiles(fileSystem[file], filePath);
+            } else {
+                fs.writeFileSync(filePath, fileSystem[file]);
+            }
+        });
+    }, { extensionSystem } = require("./extension");
+
+// Export as a Node JS module
+module.exports = {
+
+    parse: async function (ciScript, repoName, fileSystem, tmp = true) {
+        const isLinux = os.platform() === "linux";
+        const isRoot = process.getuid && process.getuid() === 0;
+        let finalResult = [];
+        let timeTaken;
+        let combinedExitCode = 0;
+        let startTime = Date.now();
+        const cpuStart = getCPUUsageSnapshot();
+
+        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 substituteEnvVariables = (command, env) => {
+            return command.replace(/\${\[(\w+)\]}/g, (_, varName) => {
+                return env[varName] ?? '';
+            });
+        };
+
+        for (const stage of stages) {
+            extensionSystem.runPreExecution(stage.name); // <-- pre execution hook
+
+            if (stage.scripts && Array.isArray(stage.scripts)) {
+                if (!fs.existsSync(tempDir)) {
+                    fs.mkdirSync(tempDir, { recursive: true });
+                }
+
+                downloadFiles(fileSystem, tempDir);
+
+                await new Promise((resolve) => {
+                    (async function (commands, callback) {
+                        const results = [];
+
+                        for (const command of commands) {
+                            const resolvedCommand = substituteEnvVariables(command, ciScript.env || {});
+
+                            await new Promise((res) => {
+                                const commandToRun = resolvedCommand;
+                                const child = spawn(commandToRun, { cwd: tempDir, shell: true });
+                                let stdoutData = "";
+                                let stderrData = "";
+
+                                child.stdout.on("data", (data) => stdoutData += data.toString());
+                                child.stderr.on("data", (data) => stderrData += data.toString());
+
+                                child.on("close", (code) => {
+                                    results.push({
+                                        command: resolvedCommand,
+                                        stdout: stdoutData,
+                                        stderr: stderrData,
+                                        exitCode: code,
+                                        error: code === 0 ? null : `Command failed with exit code ${code}`,
+                                    });
+                                    res();
+                                });
+                            });
+
+                            if (results.at(-1).exitCode !== 0) break;
+                        }
+
+                        callback(results);
+                        extensionSystem.runPostExecution(stage.name, results); // <-- post execution hook
+                        resolve();
+                    })(stage.scripts, (results) => {
+                        let output = `[${stage.name}]\n\nResults:\n`;
+
+                        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;
+                            }
+                        });
+
+                        finalResult.push(output);
+                    });
+                });
+            }
+        }
+
+        const finalResultEndTime = Date.now();
+        timeTaken = convertMsToSec(finalResultEndTime - startTime);
+        const cpuEnd = getCPUUsageSnapshot();
+
+        const ciLogResult = {
+            output: finalResult.join(''),
+            timestamp: String(new Date().toString()),
+            fileSys: parseDirectoryToJson(tempDir),
+            ci_duration: timeTaken,
+            exitCode: combinedExitCode,
+            cpu_usage: calculateCPUUsage(cpuStart, cpuEnd),
+        };
+
+        cleanUpAndRespond(tempDir);
+
+        extensionSystem.runEnd(ciLogResult, stages.map(stage => stage.name), finalResult); // <-- end hook
+
+        return ciLogResult;
+    },
+
+    dirToJson: parseDirectoryToJson
+};