penguins-eggs 25.10.23 → 25.10.26

package/dist/classes/ovary.d/luks-root.d.ts

@@ -0,0 +1,15 @@
+/**
+ * ./src/classes/ovary.d/encrypt-live-fs.ts
+ * penguins-eggs v.25.10.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import Ovary from '../ovary.js';
+/**
+ * luksRoot()
+ *
+ * create a container LUKS with the entire
+ * filesystem.squashfs
+ */
+export declare function luksRoot(this: Ovary): Promise<void>;

package/dist/classes/ovary.d/luks-root.js

@@ -0,0 +1,185 @@
+/**
+ * ./src/classes/ovary.d/encrypt-live-fs.ts
+ * penguins-eggs v.25.10.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+// packages
+import fs from 'fs';
+import { spawn } from 'node:child_process';
+import Utils from '../utils.js';
+import { exec } from '../../lib/utils.js';
+const noop = () => { };
+/**
+ * luksRoot()
+ *
+ * create a container LUKS with the entire
+ * filesystem.squashfs
+ */
+export async function luksRoot() {
+    const loggers = {
+        log: this.hidden ? noop : console.log,
+        warning: this.hidden ? noop : Utils.warning,
+        success: this.hidden ? noop : Utils.success,
+        info: this.hidden ? noop : Utils.info,
+    };
+    const { log, warning, success, info } = loggers;
+    // filesystem.squashfs
+    const live_fs = `${this.settings.iso_work}live/filesystem.squashfs`;
+    try {
+        /**
+         * this.luksMappedName = 'luks.img';
+         * this.luksFile = `/tmp/${luksMappedName}`
+         * this.luksDevice = `/dev/mapper/${luksMappedName}`
+         * this.luksMountpoint = `/tmp/mnt/${luksMappedName}`
+         * this.luksPassword = '0'
+         */
+        if (this.hidden) {
+            Utils.warning("intentionally blank. System is working, please wait");
+        }
+        log();
+        log('====================================');
+        log(` Creating ${this.luksMappedName}`);
+        log('====================================');
+        if (!fs.existsSync(live_fs)) {
+            throw new Error(`filesystem.squashfs not found at: ${live_fs}`);
+        }
+        const stats = fs.statSync(live_fs);
+        let size = stats.size; // Dimensione REALE del file in Byte
+        // Add overhead * 1.25 per più sicurezza con file grandi
+        const luksSize = Math.ceil(size * 1.25);
+        warning(`filesystem.squashfs size: ${bytesToGB(size)}`);
+        warning(`partition LUKS ${this.luksFile} size: ${bytesToGB(luksSize)}`);
+        warning(`creating partition LUKS: ${this.luksFile}`);
+        await executeCommand('truncate', ['--size', `${luksSize}`, this.luksFile]);
+        warning(`formatting ${this.luksFile} as a LUKS volume...`);
+        // await executeCommand('cryptsetup', ['--batch-mode', 'luksFormat', this.luksFile], `${this.luksPassword}\n`);
+        const luksFormatArgs = buildLuksFormatArgs(this.luksConfig, this.luksFile);
+        await executeCommand('cryptsetup', luksFormatArgs, `${this.luksPassword}\n`);
+        warning(`opening the LUKS volume. It will be mapped to ${this.luksDevice}`);
+        await executeCommand('cryptsetup', ['luksOpen', this.luksFile, this.luksMappedName], `${this.luksPassword}\n`);
+        warning(`formatting ext4 (without journal)...`);
+        await exec(`mkfs.ext4 -O ^has_journal -L live-root ${this.luksDevice}`, this.echo);
+        warning(`mounting ${this.luksDevice} on ${this.luksMountpoint}`);
+        if (fs.existsSync(this.luksMountpoint)) {
+            if (!Utils.isMountpoint(this.luksMountpoint)) {
+                await exec(`rm -rf ${this.luksMountpoint}`, this.echo);
+            }
+            else {
+                throw new Error(`${this.luksMountpoint} is already mounted, process will abort!`);
+            }
+        }
+        await exec(`mkdir -p ${this.luksMountpoint}`, this.echo);
+        await exec(`mount /dev/mapper/${this.luksMappedName} ${this.luksMountpoint}`, this.echo);
+        warning(`moving ${live_fs} ${this.luksMountpoint}/filesystem.squashfs`);
+        await exec(`mv ${live_fs} ${this.luksMountpoint}/filesystem.squashfs`, this.echo);
+        warning(`Syncing filesystem on ${this.luksMountpoint}...`);
+        await exec('sync', this.echo); // Forza scrittura dati su disco
+        warning(`Attempting unmount ${this.luksMountpoint}...`);
+        try {
+            await exec(`umount ${this.luksMountpoint}`, this.echo);
+            success(`Unmounted ${this.luksMountpoint} successfully.`);
+        }
+        catch (umountError) {
+            Utils.error(`Failed to unmount ${this.luksMountpoint}! Trying force unmount...`);
+            // Tenta un unmount forzato/lazy come ultima risorsa
+            await exec(`umount -lf ${this.luksMountpoint}`).catch((forceError) => {
+                Utils.error(`Force unmount also failed: ${forceError}`);
+                // Considera se lanciare un errore qui per fermare il processo
+            });
+            // Lancia comunque l'errore originale per segnalare il problema
+            throw umountError;
+        }
+        warning(`closing LUKS volume ${this.luksFile}.`);
+        await executeCommand('cryptsetup', ['close', this.luksMappedName]);
+        warning(`moving ${this.luksMappedName} on (ISO)/live.`);
+        await exec(`mv ${this.luksFile} ${this.settings.iso_work}/live`, this.echo);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            Utils.error(`ERROR: ${error.message}`);
+        }
+        else {
+            Utils.error(`An unknown error has occurred.`);
+        }
+        Utils.warning('Cleaning performed following the error...');
+        if (fs.existsSync(this.luksMountpoint)) {
+            await exec(`umount -lf ${this.luksMountpoint}`).catch(() => { });
+        }
+        if (fs.existsSync(this.luksDevice)) {
+            await executeCommand('cryptsetup', ['close', this.luksMappedName]).catch(() => { });
+        }
+        await Utils.pressKeyToExit();
+        process.exit(1);
+    }
+}
+/**
+ * Funzione helper per eseguire comandi esterni in modo asincrono,
+ * gestendo lo standard input per passare le password.
+ * Restituisce una Promise che si risolve al successo o si rigetta in caso di errore.
+ */
+function executeCommand(command, args, stdinData) {
+    return new Promise((resolve, reject) => {
+        // Se passiamo dati a stdin, dobbiamo usare 'pipe'. Altrimenti, 'inherit'.
+        const stdioConfig = stdinData ? ['pipe', 'inherit', 'inherit'] : 'inherit';
+        const process = spawn(command, args, { stdio: stdioConfig });
+        // Se fornito, scriviamo i dati (es. la password) nello stdin del processo.
+        if (stdinData && process.stdin) {
+            process.stdin.write(stdinData);
+            process.stdin.end();
+        }
+        process.on('error', (err) => {
+            reject(new Error(`Error starting command "${command}": ${err.message}`));
+        });
+        process.on('close', (code) => {
+            if (code === 0) {
+                resolve(); // Success
+            }
+            else {
+                reject(new Error(`Command "${command} ${args.join(' ')}" ended with error code ${code}`));
+            }
+        });
+    });
+}
+/**
+ * Converte bytes in gigabytes per la visualizzazione.
+ */
+function bytesToGB(bytes) {
+    if (bytes === 0)
+        return '0.00 GB';
+    const gigabytes = bytes / (1024 * 1024 * 1024);
+    return gigabytes.toFixed(2) + ' GB';
+}
+/**
+ * buildLuksFormatArgs
+ */
+function buildLuksFormatArgs(config, luksFile) {
+    const args = [
+        '--batch-mode', // Per saltare la conferma "YES"
+        'luksFormat',
+        '--type', 'luks2',
+        // Parametri base
+        '--cipher', config.cipher,
+        '--key-size', config['key-size'].toString(),
+        '--hash', config.hash,
+        '--sector-size', config['sector-size'].toString(),
+        '--pbkdf', config.pbkdf,
+    ];
+    // Aggiungi i parametri condizionali del PBKDF
+    switch (config.pbkdf) {
+        case 'argon2id':
+        case 'argon2i':
+            const argonConfig = config;
+            args.push('--pbkdf-memory', argonConfig['pbkdf-memory (KiB)'].toString());
+            args.push('--pbkdf-parallel', argonConfig['pbkdf-parallel (threads)'].toString());
+            break;
+        case 'pbkdf2':
+            const pbkdf2Config = config;
+            args.push('--iter-time', pbkdf2Config['iter-time (ms)'].toString());
+            break;
+    }
+    // Aggiungi il file di destinazione
+    args.push(luksFile);
+    return args;
+}

package/dist/classes/ovary.d/make-dot-disk.d.ts

@@ -0,0 +1,12 @@
+/**
+ * ./src/classes/ovary.d/produce.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import Ovary from './../ovary.js';
+/**
+   * makeDotDisk
+   */
+export declare function makeDotDisk(this: Ovary, info?: string, mksquashfs?: string, mkisofs?: string): void;

package/dist/classes/ovary.d/make-dot-disk.js

@@ -0,0 +1,71 @@
+/**
+ * ./src/classes/ovary.d/produce.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+// packages
+import fs from 'node:fs';
+import shx from 'shelljs';
+import path from 'path';
+// interfaces
+// libraries
+// classes
+import Utils from './../utils.js';
+// _dirname
+const __dirname = path.dirname(new URL(import.meta.url).pathname);
+/**
+   * makeDotDisk
+   */
+export function makeDotDisk(info = '', mksquashfs = '', mkisofs = '') {
+    const dotDisk = this.settings.iso_work + '.disk';
+    if (fs.existsSync(dotDisk)) {
+        shx.rm('-rf', dotDisk);
+    }
+    shx.mkdir('-p', dotDisk);
+    /**
+     * write volid .disk/info
+     * Required
+     */
+    let volidContent = "Linux live";
+    if (this.hidden) {
+        fs.writeFileSync(path.join(dotDisk, 'info'), volidContent, 'utf-8');
+        return;
+    }
+    /**
+     * write volid .disk/info
+     * Complete
+     */
+    volidContent = this.settings.isoFilename;
+    fs.writeFileSync(path.join(dotDisk, 'info'), volidContent, 'utf-8');
+    /**
+     * A readme now replace the old .disk/info
+     */
+    let readme = ``;
+    readme += `# penguins_eggs\n`;
+    readme += `\n`;
+    readme += `Volinfo: ${this.volid}\n`;
+    readme += `Image created at: ${Utils.formatDate(new Date())} using penguins_eggs v. ${Utils.getPackageVersion()})\n`;
+    readme += `repo: [penguins-eggs](https://github.com/penguins-eggs)\n`;
+    readme += `blog: [penguins-eggs.net](https://penguins-eggs.net)\n`;
+    readme += `author: [Piero Proietti](mailto://piero.proietti@gmail.com)\n`;
+    fs.writeFileSync(path.join(dotDisk, 'README.md'), readme, 'utf-8');
+    /**
+     * write mksquashfs as .disk/mksquashfs
+     */
+    fs.writeFileSync(path.join(dotDisk, 'mksquashfs'), mksquashfs, 'utf-8');
+    /**
+     * write mkisofs as .disk/mkisofs
+     */
+    fs.writeFileSync(path.join(dotDisk, 'mkisofs'), mkisofs, 'utf-8');
+    /**
+     * touch uuid as file name on .disk/id
+     *
+     * This is a DEBIAN standard
+     */
+    if (this.uuid && this.uuid.trim() !== '') {
+        shx.mkdir(path.join(dotDisk, 'id'));
+        shx.touch(path.join(dotDisk, 'id', this.uuid));
+    }
+}

package/dist/classes/ovary.d/make-efi.d.ts

@@ -0,0 +1,14 @@
+/**
+ * ./src/classes/ovary.d/make-efi.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import Ovary from '../ovary.js';
+/**
+ *
+ * @param this
+ * @param theme
+ */
+export declare function makeEfi(this: Ovary, theme?: string): Promise<void>;

package/dist/classes/ovary.d/make-efi.js

@@ -0,0 +1,290 @@
+/**
+ * ./src/classes/ovary.d/make-efi.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import mustache from 'mustache';
+// packages
+import fs from 'node:fs';
+import path from 'node:path';
+// classes
+import { exec } from '../../lib/utils.js';
+import Diversions from '../diversions.js';
+import Utils from '../utils.js';
+// _dirname
+const __dirname = path.dirname(new URL(import.meta.url).pathname);
+/**
+ *
+ * @param this
+ * @param theme
+ */
+export async function makeEfi(theme = 'eggs') {
+    const bootloaders = Diversions.bootloaders(this.familyId);
+    /**
+     * except Debian/Devuan/Ubuntu all distros will use: not signed
+     * paths here for Ubuntu and Debian are the same, here checked!
+     */
+    let signed = false;
+    let grubEfi = path.resolve(bootloaders, `grub/x86_64-efi/monolithic/grubx64.efi`);
+    let shimEfi = path.resolve(bootloaders, `shim/shimx64.efi`);
+    if (this.familyId === "debian") {
+        signed = true;
+        if (process.arch === 'x64') {
+            grubEfi = path.resolve(bootloaders, `grub/x86_64-efi-signed/grubx64.efi.signed`);
+            shimEfi = path.resolve(bootloaders, `shim/shimx64.efi.signed`);
+        }
+        else if (process.arch === 'ia32') {
+            grubEfi = path.resolve(bootloaders, `grub/i386-efi-signed/grubia32.efi.signed`);
+            shimEfi = path.resolve(bootloaders, `shim/shimia32.efi.signed`);
+        }
+        else if (process.arch === 'arm64') {
+            grubEfi = path.resolve(bootloaders, `grub/arm64-efi-signed/grubaa64.efi.signed`);
+            shimEfi = path.resolve(bootloaders, `shim/shimaa64.efi.signed`);
+        }
+    }
+    if (signed) {
+        Utils.warning(`Your live system ${this.distroId}/${process.arch} can boot with Secure Boot enabled`);
+    }
+    else {
+        Utils.warning(`You must disable Secure Boot to boot live system ${this.distroId}/${process.arch}`);
+    }
+    // 2 secondi per leggere...    
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    const efiPath = path.join(this.settings.config.snapshot_mnt, '/efi/');
+    const efiWorkDir = path.join(efiPath, '/work/');
+    const efiMemdiskDir = path.join(efiPath, '/memdisk/');
+    const efiImgMnt = path.join(efiPath, 'mnt');
+    const isoDir = this.settings.iso_work;
+    // create (ISO)/boot/grub
+    await exec(`mkdir ${isoDir}/boot/grub/${Utils.uefiFormat()} -p`, this.echo);
+    // create (ISO)/EFI
+    await exec(`mkdir ${isoDir}/EFI/boot -p`, this.echo);
+    await exec(`cp ${shimEfi} ${isoDir}/EFI/boot/${bootEfiName()}`, this.echo);
+    await exec(`cp ${grubEfi} ${isoDir}/EFI/boot/${grubEfiName()}`, this.echo);
+    // clean/create all in efiPath
+    if (fs.existsSync(efiPath)) {
+        await exec(`rm -rf ${efiPath}`);
+    }
+    await exec(`mkdir ${efiPath}`, this.echo);
+    await exec(`mkdir ${efiMemdiskDir}`, this.echo);
+    await exec(`mkdir ${efiImgMnt}`, this.echo);
+    await exec(`mkdir ${efiWorkDir}`, this.echo);
+    /**
+     * create efi.img
+     */
+    let seeker = '';
+    seeker += `search --file --set=root /.disk/id/${this.uuid}\n`;
+    seeker += "set prefix=($root)/boot/grub\n";
+    seeker += "source $prefix/${grub_cpu}-efi/grub.cfg\n";
+    /**
+     * creating grub.cfg (1) seeker for usb on (efi.img)/boot/grub/grub.cfg
+     */
+    Utils.warning("creating grub.cfg seeker USB on (efi.img)/boot/grub");
+    await exec(`mkdir ${path.join(efiMemdiskDir, "/boot/grub -p")}`, this.echo);
+    const cfgSeekerUsb = `${efiMemdiskDir}/boot/grub/grub.cfg`;
+    let cfgSeekerUsbText = '';
+    cfgSeekerUsbText += `# grub.cfg seeker\n`;
+    cfgSeekerUsbText += `# created on ${efiMemdiskDir}, path ${cfgSeekerUsb}\n`;
+    cfgSeekerUsbText += `\n`;
+    cfgSeekerUsbText += seeker;
+    Utils.write(cfgSeekerUsb, cfgSeekerUsbText);
+    /**
+     * create grub.cfg (bridge) on (ISO)/boot/grub/x86_64-efi/grub.cfg
+     */
+    Utils.warning(`creating grub.cfg bridge to main. (ISO)/boot/grub/${Utils.uefiFormat()}`);
+    let cfgBridge = `${isoDir}/boot/grub/${Utils.uefiFormat()}/grub.cfg`;
+    let cfgBridgeText = `# grub.cfg bridge\n`;
+    cfgBridgeText += `# created on ${cfgBridge}\n`;
+    cfgBridgeText += `\n`;
+    cfgBridgeText += `source /boot/grub/grub.cfg\n`;
+    fs.writeFileSync(cfgBridge, cfgBridgeText);
+    /**
+     * grub bait: si applica a tutte le distro:
+     * /EFI/debian per tutti, tranne ubuntu
+     */
+    let pathBait = path.join(isoDir, '/EFI/debian');
+    if (this.distroLike === 'Ubuntu') {
+        pathBait = path.join(isoDir, '/EFI/ubuntu');
+    }
+    await exec(`mkdir ${pathBait} -p`, this.echo);
+    Utils.warning(`creating grub.cfg seeker ISO/DVD on (ISO)/EFI/${path.basename(pathBait)}`);
+    let cfgBait = path.join(pathBait, '/grub.cfg');
+    let cfgBaitText = '';
+    cfgBaitText += `\n`;
+    cfgBaitText += seeker;
+    Utils.write(cfgBait, cfgBaitText);
+    /**
+     * README.md, per tutti tranne distrolike Debian ed Ubuntu
+     */
+    let baitReadme = path.join(pathBait, '/README.md');
+    let baitReadmeText = ``;
+    if (this.distroLike !== 'Debian' && this.distroLike !== 'Ubuntu') {
+        baitReadmeText += `# penguins-eggs\n`;
+        baitReadmeText += '\n';
+        baitReadmeText += `This is just an hack, to let ${this.distroId} boot using Debian trixie bootloaders\n`;
+        fs.writeFileSync(baitReadme, baitReadmeText);
+    }
+    /**
+     * creating structure efiWordDir
+     */
+    await exec(`mkdir -p ${efiWorkDir}/boot/grub`, this.echo); // qua va grub.cfg 2
+    await exec(`mkdir -p ${efiWorkDir}/EFI/boot`);
+    /**
+     * create tarred efiMemdiskDir
+     */
+    const currentDir = process.cwd();
+    process.chdir(efiMemdiskDir);
+    await exec('tar -cvf memdisk boot', this.echo);
+    process.chdir(currentDir);
+    /**
+     * Create boot image "boot/grub/efi.img"
+     */
+    const efiImg = path.join(efiWorkDir, `boot/grub/efi.img`);
+    await exec(`dd if=/dev/zero of=${efiImg} bs=1M count=16`, this.echo);
+    await exec(`/sbin/mkdosfs -F 12 ${efiImg}`, this.echo);
+    await new Promise(resolve => setTimeout(resolve, 500));
+    // mount efi.img on mountpoint mnt-img
+    await exec(`mount --make-shared -o loop ${efiImg} ${efiImgMnt}`, this.echo);
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    // create structure inside (efi.img)
+    await exec(`mkdir -p ${efiImgMnt}/boot`, this.echo);
+    await exec(`mkdir -p ${efiImgMnt}/EFI/boot`, this.echo);
+    /**
+     * copy grubCfg1 (grub.cfg) to (efi.img)/boot/grub
+     */
+    await exec(`cp ${cfgSeekerUsb} ${efiImgMnt}/boot/grub.cfg`, this.echo);
+    await exec(`cp ${shimEfi} ${efiImgMnt}/EFI/boot/${bootEfiName()}`, this.echo);
+    await exec(`cp ${grubEfi} ${efiImgMnt}/EFI/boot/${grubEfiName()}`, this.echo);
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    if (!fs.existsSync(`${efiImgMnt}/boot/grub.cfg`)) {
+        console.log(`error copyng ${cfgSeekerUsb} seeker for USB on (efi.img)/boot/grub.cfg`);
+        process.exit(1);
+    }
+    await new Promise(resolve => setTimeout(resolve, 500));
+    await exec(`umount ${efiImgMnt}`, this.echo);
+    await new Promise(resolve => setTimeout(resolve, 500));
+    // Copy isoImg in ${${isoDir}/boot/grub
+    Utils.warning("copyng (efi.img) on (ISO)/boot/grub");
+    await exec(`cp ${efiImg} ${isoDir}/boot/grub`, this.echo);
+    /**
+     * creating grub.cfg (4) on (ISO)/boot/grub
+     */
+    Utils.warning("creating grub.cfg main on (ISO)/boot/grub");
+    // splash.png
+    let splashSrc = '';
+    const splashDest = `${efiWorkDir}/boot/grub/splash.png`;
+    let themeSrc = '';
+    const themeDest = `${isoDir}/boot/grub/theme.cfg`;
+    let grubTemplate = '';
+    if (this.hidden) {
+        splashSrc = path.resolve(__dirname, `../../../addons/${theme}/theme/livecd/generic-splash.png`);
+        grubTemplate = path.resolve(__dirname, '../../../addons/eggs/theme/livecd/generic.grub.main.cfg');
+        themeSrc = path.resolve(__dirname, '../../../addons/eggs/theme/livecd/generic.grub.theme.cfg');
+    }
+    else {
+        // copy splash to efiWorkDir
+        splashSrc = path.resolve(__dirname, `../../../addons/${theme}/theme/livecd/splash.png`);
+        if (this.theme.includes('/')) {
+            splashSrc = `${theme}/theme/livecd/splash.png`;
+        }
+        if (!fs.existsSync(splashSrc)) {
+            Utils.warning(`warning: ${splashSrc} does not exists`);
+            process.exit(1);
+        }
+        // select themeSrc
+        themeSrc = path.resolve(__dirname, `../../../addons/${theme}/theme/livecd/grub.theme.cfg`);
+        if (this.theme.includes('/')) {
+            themeSrc = `${theme}/theme/livecd/grub.theme.cfg`;
+        }
+        // copy theme
+        if (!fs.existsSync(themeSrc)) {
+            Utils.error(`error: ${themeSrc} does not exist`);
+            process.exit(1);
+        }
+        // selecting available fonts
+        if (fs.existsSync('/usr/share/grub/font.pf2')) {
+            await exec(`cp /usr/share/grub/font.pf2 ${efiWorkDir}boot/grub/font.pf2`, this.echo);
+        }
+        else if (fs.existsSync('/usr/share/grub/unicode.pf2')) {
+            await exec(`cp /usr/share/grub/unicode.pf2 ${efiWorkDir}boot/grub/font.pf2`, this.echo);
+        }
+        else if (fs.existsSync('/usr/share/grub/ascii.pf2')) {
+            await exec(`cp /usr/share/grub/ascii.pf2 ${efiWorkDir}boot/grub/font.pf2`, this.echo);
+        }
+        // Copy workdir files to ISO/boot
+        await exec(`rsync -avx  ${efiWorkDir}/boot ${isoDir}/`, this.echo);
+        /**
+         * prepare main grub.cfg from grub.main.cfg
+         */
+        grubTemplate = `${theme}/theme/livecd/grub.main.cfg`;
+        if (!fs.existsSync(grubTemplate)) {
+            grubTemplate = path.resolve(__dirname, '../../../addons/eggs/theme/livecd/grub.main.cfg');
+        }
+        if (!fs.existsSync(grubTemplate)) {
+            Utils.error(`error: ${grubTemplate} does not exist`);
+            process.exit(1);
+        }
+    }
+    // splash.png
+    await exec(`cp ${splashSrc} ${splashDest}`, this.echo);
+    // grub.theme.png
+    fs.copyFileSync(themeSrc, themeDest);
+    // grub.main.png
+    const kernel_parameters = Diversions.kernelParameters(this.familyId, this.volid, this.fullcrypt);
+    const cfgMain = path.join(isoDir, '/boot/grub/grub.cfg');
+    const template = fs.readFileSync(grubTemplate, 'utf8');
+    const view = {
+        fullname: this.settings.remix.fullname.toUpperCase(),
+        initrdImg: `/live/${path.basename(this.initrd)}`,
+        kernel: this.kernel,
+        kernel_parameters,
+        vmlinuz: `/live/${path.basename(this.vmlinuz)}`
+    };
+    let cfgMainText = '';
+    cfgMainText += `# grub.cfg (4) main\n`;
+    if (!this.hidden) {
+        cfgMainText += `# created on ${cfgMain}`;
+    }
+    cfgMainText += `\n`;
+    cfgMainText += mustache.render(template, view);
+    fs.writeFileSync(cfgMain, cfgMainText);
+}
+/**
+ * FUNCTIONS
+ */
+/**
+ *
+ * @returns
+ */
+function bootEfiName() {
+    let ben = '';
+    if (process.arch === 'x64') {
+        ben = 'bootx64.efi';
+    }
+    else if (process.arch === 'ia32') {
+        ben = 'bootia32.efi';
+    }
+    else if (process.arch === 'arm64') {
+        ben = 'bootaa64.efi';
+    }
+    return ben;
+}
+/**
+ *
+ * @returns
+ */
+function grubEfiName() {
+    let gen = '';
+    if (process.arch === 'x64') {
+        gen = 'grubx64.efi';
+    }
+    else if (process.arch === 'ia32') {
+        gen = 'grub ia32.efi';
+    }
+    else if (process.arch === 'arm64') {
+        gen = 'grubaa64.efi';
+    }
+    return gen;
+}

package/dist/classes/ovary.d/make-iso.d.ts

@@ -0,0 +1,13 @@
+/**
+ * ./src/classes/ovary.d/make-iso.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import Ovary from '../ovary.js';
+/**
+ * makeIso
+ * cmd: cmd 4 xorriso
+ */
+export declare function makeIso(this: Ovary, cmd: string, scriptOnly?: boolean): Promise<void>;

package/dist/classes/ovary.d/make-iso.js

@@ -0,0 +1,45 @@
+/**
+ * ./src/classes/ovary.d/make-iso.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+// packages
+import path from 'node:path';
+// classes
+import { exec } from '../../lib/utils.js';
+import Utils from '../utils.js';
+// _dirname
+const __dirname = path.dirname(new URL(import.meta.url).pathname);
+/**
+ * makeIso
+ * cmd: cmd 4 xorriso
+ */
+export async function makeIso(cmd, scriptOnly = false) {
+    // echo = { echo: true, ignore: false }
+    if (this.verbose) {
+        console.log('Ovary: makeIso');
+    }
+    Utils.writeX(`${this.settings.work_dir.ovarium}mkisofs`, cmd);
+    // Create link to iso ALLWAYS
+    const src = this.settings.config.snapshot_mnt + this.settings.isoFilename;
+    const dest = this.settings.config.snapshot_dir + this.settings.isoFilename;
+    await exec(`ln -s ${src} ${dest}`);
+    if (!scriptOnly) {
+        const test = (await exec(cmd, Utils.setEcho(true))).code;
+        if (test !== 0) {
+            process.exit();
+        }
+        // Create link to iso
+        const src = this.settings.config.snapshot_mnt + this.settings.isoFilename;
+        const dest = this.settings.config.snapshot_dir + this.settings.isoFilename;
+        await exec(`ln -s ${src} ${dest}`);
+        // Create md5sum, sha256sum
+        if (this.settings.config.make_md5sum) {
+            Utils.warning('creating md5, sha256');
+            await exec(`md5sum ${src} > ${dest.replace('.iso', '.md5')}`);
+            await exec(`sha256sum ${src} > ${dest.replace('.iso', '.sha256')}`);
+        }
+    }
+}

package/dist/classes/ovary.d/make-squashfs.d.ts

@@ -0,0 +1,18 @@
+/**
+ * ./src/classes/ovary.d/make-squashfs.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import Ovary from '../ovary.js';
+/**
+ * squashFs: crea in live filesystem.squashfs
+ */
+export declare function makeSquashfs(this: Ovary, scriptOnly?: boolean, includeRootHome?: boolean): Promise<string>;
+/**
+ * Add or remove exclusion
+ * @param add {boolean} true = add, false remove
+ * @param exclusion {string} path to add/remove
+ */
+export declare function addExclusion(this: Ovary, exclusion: string): void;