@soymaycol/base64/index.js

Convertidor y ejecutor de archivos .may

const fs = require('fs');
const path = require('path');
const vm = require('vm');

class MayProcessor {
    static convert(inputFile) {
        if (!fs.existsSync(inputFile)) throw new Error(`Archivo no encontrado: ${inputFile}`);
        const fileExt = path.extname(inputFile);
        if (fileExt !== '.js') throw new Error('Solo se pueden convertir archivos .js');

        const content = fs.readFileSync(inputFile, 'utf8');
        const encoded = Buffer.from(content).toString('base64');

        const fileName = path.basename(inputFile, '.js');
        const outputFile = path.join(path.dirname(inputFile), `${fileName}.may`);

        fs.writeFileSync(outputFile, encoded);
        console.log(`✓ Archivo convertido exitosamente: ${outputFile}`);
        return outputFile;
    }

    static async execute(mayFile) {
        if (!fs.existsSync(mayFile)) throw new Error(`Archivo no encontrado: ${mayFile}`);
        const fileExt = path.extname(mayFile);
        if (fileExt !== '.may') throw new Error('Solo se pueden ejecutar archivos .may');

        const encoded = fs.readFileSync(mayFile, 'utf8');
        const decoded = Buffer.from(encoded, 'base64').toString('utf8');

        const context = {
            require,
            module: { exports: {} },
            exports: {},
            console,
            process,
            __filename: mayFile,
            __dirname: path.dirname(mayFile),
        };

        const script = new vm.Script(decoded);
        const vmContext = vm.createContext(context);

        // Ejecutar el script y esperar cualquier input async
        try {
            await script.runInContext(vmContext);
            return context.module.exports;
        } catch (err) {
            console.error(`Error al ejecutar archivo: ${err.message}`);
            throw err;
        }
    }
}

module.exports = {
    convert: MayProcessor.convert,
    execute: MayProcessor.execute,
    MayProcessor
};