penguins-eggs 25.8.6 → 25.9.2

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

@@ -19,54 +19,117 @@ const __dirname = path.dirname(new URL(import.meta.url).pathname);
  *
  * @param this
  * @param theme
- * cp /usr/lib/grub/x86_64-efi-signed/grubx64.efi.signed ./bootloaders/
- * cp /usr/lib/shim/shimx64.efi.signed ./bootloaders/
  */
 export async function makeEfi(theme = 'eggs') {
-    const bootloaders = path.resolve(__dirname, `../../../bootloaders`);
-    const grubEfi = path.resolve(bootloaders, `grubx64.efi`);
-    const shimEfi = path.resolve(bootloaders, `shimx64.efi`);
-    let signed = '';
-    if (this.distroLike === 'Debian') {
-        Utils.warning(`Secure boot enabled on ${this.distroLike}`);
-        signed = '.signed';
+    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 efiMnt = path.join(efiPath, 'mnt');
+    const efiImgMnt = path.join(efiPath, 'mnt');
     const isoDir = this.settings.iso_work;
-    // creo e copio direttamente in ${isdDir} il folder ${bootloaders}/grub/x86_64-efi
-    await exec(`mkdir ${isoDir}/boot/grub/ -p`, this.echo);
-    await exec(`cp -r ${bootloaders}/grub/x86_64-efi ${isoDir}/boot/grub/`, this.echo);
+    // 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}${signed} ${isoDir}/EFI/boot/${bootEFI()}`, this.echo);
-    await exec(`cp ${grubEfi}${signed} ${isoDir}/EFI/boot/${grubEFI()}`, 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 ${efiMnt}`, this.echo);
+    await exec(`mkdir ${efiImgMnt}`, this.echo);
     await exec(`mkdir ${efiWorkDir}`, this.echo);
     /**
      * create efi.img
      */
-    Utils.warning("creating grub.cfg (1) on 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 grubCfg1 = `${efiMemdiskDir}/boot/grub/grub.cfg`;
-    let grubText1 = `# grub.cfg 1\n`;
-    grubText1 += `# created on ${efiMemdiskDir}\n`;
-    grubText1 += `\n`;
-    grubText1 += `search --set=root --file /.disk/id/${this.uuid}\n`;
-    grubText1 += 'set prefix=($root)/boot/grub\n';
-    grubText1 += `configfile ($root)/boot/grub/grub.cfg\n`;
-    Utils.write(grubCfg1, grubText1);
+    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);
+    await exec(`mkdir -p ${efiWorkDir}/boot/grub`, this.echo); // qua va grub.cfg 2
     await exec(`mkdir -p ${efiWorkDir}/EFI/boot`);
     /**
      * create tarred efiMemdiskDir
@@ -78,31 +141,37 @@ export async function makeEfi(theme = 'eggs') {
     /**
      * Create boot image "boot/grub/efi.img"
      */
-    const efiImg = `${efiWorkDir}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, 2000))
+    await new Promise(resolve => setTimeout(resolve, 500));
     // mount efi.img on mountpoint mnt-img
-    await exec(`mount --make-shared -o loop ${efiImg} ${efiMnt}`, this.echo);
-    // await new Promise(resolve => setTimeout(resolve, 2000))
+    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 ${efiMnt}/boot/grub`, this.echo);
-    await exec(`mkdir -p ${efiMnt}/EFI/boot`, this.echo);
+    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 ${grubCfg1} ${efiMnt}/boot/grub`, this.echo);
-    await exec(`cp ${shimEfi}${signed} ${efiMnt}/EFI/boot/${bootEFI()}`, this.echo);
-    await exec(`cp ${grubEfi}${signed} ${efiMnt}/EFI/boot/${grubEFI()}`, this.echo);
-    //await Utils.pressKeyToExit(`controlla ${efiMnt}`)
-    await exec(`umount ${efiMnt}`, this.echo);
+    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");
+    Utils.warning("copyng (efi.img) on (ISO)/boot/grub");
     await exec(`cp ${efiImg} ${isoDir}/boot/grub`, this.echo);
     /**
-     * creating grub.cfg (2) on (iso)/boot/grub
+     * creating grub.cfg (4) on (ISO)/boot/grub
      */
-    Utils.warning("creating grub.cfg (2) on (iso)/boot/grub");
+    Utils.warning("creating grub.cfg main on (ISO)/boot/grub");
     // copy splash to efiWorkDir
     const splashDest = `${efiWorkDir}/boot/grub/splash.png`;
     let splashSrc = path.resolve(__dirname, `../../../addons/${theme}/theme/livecd/splash.png`);
@@ -150,7 +219,7 @@ export async function makeEfi(theme = 'eggs') {
         process.exit(1);
     }
     const kernel_parameters = Diversions.kernelParameters(this.familyId, this.volid); // this.kernelParameters()
-    const grubCfg2 = path.join(isoDir, '/boot/grub/grub.cfg');
+    const cfgMain = path.join(isoDir, '/boot/grub/grub.cfg');
     const template = fs.readFileSync(grubTemplate, 'utf8');
     const view = {
         fullname: this.settings.remix.fullname.toUpperCase(),
@@ -159,23 +228,12 @@ export async function makeEfi(theme = 'eggs') {
         kernel_parameters,
         vmlinuz: `/live/${path.basename(this.vmlinuz)}`
     };
-    let grubText2 = `# grub.cfg 2\n`;
-    grubText2 += ` # created on ${grubCfg2}`;
-    grubText2 += `\n`;
-    grubText2 += mustache.render(template, view);
-    fs.writeFileSync(grubCfg2, grubText2);
-    /**
-     * create loopback.cfg
-     */
-    fs.writeFileSync(`${isoDir}/boot/grub/loopback.cfg`, 'source /boot/grub/grub.cfg\n');
-    /**
-     * create (iso)/boot/grub/x86_64-efi/grub.cfg
-     */
-    fs.writeFileSync(`${isoDir}/boot/grub/${Utils.uefiFormat()}/grub.cfg`, 'source /boot/grub/grub.cfg\n');
-    /**
-     * config.cfg
-     */
-    await exec(`cp ${path.resolve(__dirname, `../../../assets/config.cfg`)} ${isoDir}/boot/grub`);
+    let cfgMainText = '';
+    cfgMainText += `# grub.cfg (4) main\n`;
+    cfgMainText += `# created on ${cfgMain}`;
+    cfgMainText += `\n`;
+    cfgMainText += mustache.render(template, view);
+    fs.writeFileSync(cfgMain, cfgMainText);
 }
 /**
  * FUNCTIONS
@@ -184,30 +242,33 @@ export async function makeEfi(theme = 'eggs') {
  *
  * @returns
  */
-function bootEFI() {
-    let bn = 'bootia32.efi'; // Per l'architettura i686 EFI è: bootia32.efi
+function bootEfiName() {
+    let ben = '';
     if (process.arch === 'x64') {
-        bn = 'bootx64.efi';
+        ben = 'bootx64.efi';
+    }
+    else if (process.arch === 'ia32') {
+        ben = 'bootia32.efi';
     }
     else if (process.arch === 'arm64') {
-        bn = 'bootaa64.efi';
+        ben = 'bootaa64.efi';
     }
-    return bn;
+    return ben;
 }
 /**
  *
  * @returns
  */
-function grubEFI() {
-    let gn = 'grubia32.efi'; // Per l'architettura i686 EFI è: grubia32.efi
+function grubEfiName() {
+    let gen = '';
     if (process.arch === 'x64') {
-        gn = 'grubx64.efi';
+        gen = 'grubx64.efi';
+    }
+    else if (process.arch === 'ia32') {
+        gen = 'grub ia32.efi';
     }
     else if (process.arch === 'arm64') {
-        gn = 'grubaa64.efi';
+        gen = 'grubaa64.efi';
     }
-    return gn;
-}
-function moduleEFI() {
-    return `x86_64-efi`;
+    return gen;
 }

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

@@ -22,7 +22,7 @@ export async function makeIso(cmd, scriptOnly = false) {
         console.log('Ovary: makeIso');
     }
     Utils.writeX(`${this.settings.work_dir.ovarium}mkisofs`, cmd);
-    // Create link to iso ALLWAYES
+    // 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}`);

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

@@ -85,7 +85,7 @@ export async function makeSquashfs(scriptOnly = false, unsecure = false) {
     cmd = cmd.replaceAll(/\s\s+/g, ' ');
     Utils.writeX(`${this.settings.work_dir.ovarium}mksquashfs`, cmd);
     if (!scriptOnly) {
-        Utils.warning('creating filesystem.squashfs on ISO/live');
+        Utils.warning('creating filesystem.squashfs on (ISO)/live');
         // Utils.warning(`compression: ` + compression)
         const test = (await exec(cmd, Utils.setEcho(true))).code;
         if (test !== 0) {

package/dist/classes/ovary.d/produce.js

@@ -187,7 +187,11 @@ export async function produce(kernel = '', clone = false, cryptedclone = false,
              */
             this.incubator = new Incubator(this.settings.remix, this.settings.distro, this.settings.config.user_opt, this.theme, this.clone, verbose);
             await this.incubator.config(release);
-            await this.syslinux(this.theme);
+            // need syslinux?
+            const arch = process.arch;
+            if (arch === 'ia32' || arch === 'x64') {
+                await this.syslinux(this.theme);
+            }
             await this.kernelCopy();
             /**
              * spostare alla fine per dracut
@@ -244,8 +248,8 @@ export async function produce(kernel = '', clone = false, cryptedclone = false,
                 synctoCmd += ' --excludes'; // from Marco, usa home.list
             }
             await exec(synctoCmd, Utils.setEcho(true));
-            Utils.warning(`moving ${luksFile} in ${this.nest}iso/live`);
-            await exec(`mv ${luksFile} ${this.nest}iso/live`, this.echo);
+            Utils.warning(`moving ${luksFile} in ${this.nest}(ISO)/live`);
+            await exec(`mv ${luksFile} ${this.nest}(ISO)/live`, this.echo);
         }
         const mkIsofsCmd = (await this.xorrisoCommand(clone, cryptedclone)).replaceAll(/\s\s+/g, ' ');
         this.makeDotDisk(this.volid, mksquashfsCmd, mkIsofsCmd);

package/dist/classes/ovary.d/syslinux.js

@@ -17,20 +17,22 @@ import Diversions from './../diversions.js';
 import Utils from './../utils.js';
 // _dirname
 const __dirname = path.dirname(new URL(import.meta.url).pathname);
-const bootloaders = path.resolve(__dirname, `../../../bootloaders`);
+let bootloaders = '/usr/lib/';
 /**
    * syslinux: da syspath
    */
 export async function syslinux(theme = 'eggs') {
-    let syspath = path.join(bootloaders, 'syslinux');
-    await exec(`cp ${syspath}/chain.c32 ${this.settings.iso_work}/isolinux/`, this.echo);
-    await exec(`cp ${syspath}/isohdpfx.bin ${this.settings.iso_work}/isolinux/`, this.echo);
-    // just fo x64 arch
-    await exec(`cp ${syspath}/isolinux.bin ${this.settings.iso_work}/isolinux/`, this.echo);
-    await exec(`cp ${syspath}/ldlinux.c32 ${this.settings.iso_work}/isolinux/`, this.echo);
-    await exec(`cp ${syspath}/libcom32.c32 ${this.settings.iso_work}/isolinux/`, this.echo);
-    await exec(`cp ${syspath}/libutil.c32 ${this.settings.iso_work}/isolinux/`, this.echo);
-    await exec(`cp ${syspath}/vesamenu.c32 ${this.settings.iso_work}/isolinux/`, this.echo);
+    const bootloaders = Diversions.bootloaders(this.familyId);
+    let sysPath = path.join(bootloaders, 'syslinux/modules/bios');
+    let isoPath = path.join(bootloaders, 'ISOLINUX');
+    await exec(`cp ${sysPath}/chain.c32 ${this.settings.iso_work}/isolinux/`, this.echo);
+    await exec(`cp ${isoPath}/isohdpfx.bin ${this.settings.iso_work}/isolinux/`, this.echo);
+    // just for x64 arch
+    await exec(`cp ${isoPath}/isolinux.bin ${this.settings.iso_work}/isolinux/`, this.echo);
+    await exec(`cp ${sysPath}/ldlinux.c32 ${this.settings.iso_work}/isolinux/`, this.echo);
+    await exec(`cp ${sysPath}/libcom32.c32 ${this.settings.iso_work}/isolinux/`, this.echo);
+    await exec(`cp ${sysPath}/libutil.c32 ${this.settings.iso_work}/isolinux/`, this.echo);
+    await exec(`cp ${sysPath}/vesamenu.c32 ${this.settings.iso_work}/isolinux/`, this.echo);
     const isolinuxThemeDest = this.settings.iso_work + 'isolinux/isolinux.theme.cfg';
     let isolinuxThemeSrc = path.resolve(__dirname, `../../../addons/${theme}/theme/livecd/isolinux.theme.cfg`);
     if (this.theme.includes('/')) {

package/dist/classes/ovary.d/xorriso-command.js

@@ -10,6 +10,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import Pacman from '../pacman.js';
 import Utils from '../utils.js';
+import Diversions from '../diversions.js';
 // _dirname
 const __dirname = path.dirname(new URL(import.meta.url).pathname);
 /**
@@ -45,15 +46,60 @@ export async function xorrisoCommand(clone = false, cryptedclone = false) {
     // const preparer = '-preparer "prepared by eggs <https://penguins-eggs.net>" '
     let isoHybridMbr = '';
     if (this.settings.config.make_isohybrid) {
-        const isolinuxFile = path.resolve(__dirname, `../../../bootloaders/syslinux/isohdpfx.bin`);
-        if (fs.existsSync(isolinuxFile)) {
-            isoHybridMbr = `-isohybrid-mbr ${isolinuxFile}`;
+        const bootloaders = Diversions.bootloaders(this.familyId);
+        const isohybridFile = path.resolve(bootloaders, `ISOLINUX/isohdpfx.bin`);
+        if (fs.existsSync(isohybridFile)) {
+            isoHybridMbr = `-isohybrid-mbr ${isohybridFile}`;
         }
         else {
-            Utils.warning(`Can't create isohybrid image. File: ${isolinuxFile} not found. \nThe resulting image will be a standard iso file`);
+            Utils.warning(`Can't create isohybrid image, file: ${isohybridFile} not found!`);
+            process.exit();
         }
     }
-    if (Pacman.packageIsInstalled('genisoimage')) {
+    // su arm no isolinux
+    let isolinuxBin = '';
+    let isolinuxCat = '';
+    let noemulboot = '';
+    let bootloadsize = '';
+    let bootinfotable = '';
+    if (process.arch !== 'arm64') {
+        isolinuxBin = `-b isolinux/isolinux.bin`;
+        isolinuxCat = `-c isolinux/boot.cat`;
+        noemulboot = '-no-emul-boot';
+        bootloadsize = '-boot-load-size 4';
+        bootinfotable = '-boot-info-table';
+    }
+    if (Pacman.packageIsInstalled('xorriso')) {
+        let uefi_elToritoAltBoot = '';
+        let uefi_e = '';
+        let uefi_isohybridGptBasdat = '';
+        let uefi_noEmulBoot = '';
+        if (this.settings.config.make_efi) {
+            uefi_elToritoAltBoot = '-eltorito-alt-boot';
+            uefi_e = '-e boot/grub/efi.img';
+            uefi_isohybridGptBasdat = '-isohybrid-gpt-basdat';
+            uefi_noEmulBoot = '-no-emul-boot';
+        }
+        command = `xorriso -as mkisofs \
+                    -J \
+                    -joliet-long \
+                    -l \
+                    -iso-level 3 \
+                    ${isoHybridMbr} \
+                    -partition_offset 16 \
+                    -V ${this.volid} \
+                    ${isolinuxBin} \
+                    ${isolinuxCat} \
+                    -no-emul-boot \
+                    -boot-load-size 4 \
+                    -boot-info-table \
+                    ${uefi_elToritoAltBoot} \
+                    ${uefi_e} \
+                    ${uefi_isohybridGptBasdat} \
+                    ${uefi_noEmulBoot} \
+                    -o ${output} ${this.settings.iso_work}`;
+    }
+    else {
         this.genisoimage = true;
         command = `genisoimage \
         -iso-level 3 \
@@ -71,49 +117,7 @@ export async function xorrisoCommand(clone = false, cryptedclone = false) {
         -boot-info-table \
         -eltorito-alt-boot \
         -e boot/grub/efi.img \
-        -no-emul-boot \
         -o ${output} ${this.settings.iso_work}`;
-        return command;
-    }
-    /**
-     * xorriso
-     */
-    // uefi_opt="-uefi_elToritoAltBoot-alt-boot -e boot/grub/efi.img -isohybrid-gpt-basdat -no-emul-boot"
-    let uefi_elToritoAltBoot = '';
-    let uefi_e = '';
-    let uefi_isohybridGptBasdat = '';
-    let uefi_noEmulBoot = '';
-    if (this.settings.config.make_efi) {
-        uefi_elToritoAltBoot = '-eltorito-alt-boot';
-        uefi_e = '-e boot/grub/efi.img';
-        uefi_isohybridGptBasdat = '-isohybrid-gpt-basdat';
-        uefi_noEmulBoot = '-no-emul-boot';
     }
-    /**
-     * L'immagine efi è efi.img ed è
-     * presente in boot/grub/efi.img
-     * per cui:
-     * -append_partition 2 0xef efi.img
-     * --efi-boot efi.img
-     * non sono necessari
-     */
-    command = `xorriso -as mkisofs \
-     -J \
-     -joliet-long \
-     -l \
-     -iso-level 3 \
-     ${isoHybridMbr} \
-     -partition_offset 16 \
-     -V ${this.volid} \
-     -b isolinux/isolinux.bin \
-     -c isolinux/boot.cat \
-     -no-emul-boot \
-     -boot-load-size 4 \
-     -boot-info-table \
-     ${uefi_elToritoAltBoot} \
-     ${uefi_e} \
-     ${uefi_isohybridGptBasdat} \
-     ${uefi_noEmulBoot} \
-     -o ${output} ${this.settings.iso_work}`;
     return command;
 }

package/dist/classes/pacman.js

@@ -380,6 +380,13 @@ export default class Pacman {
         else if (codenameLikeId === 'trixie') {
             const dest = '/etc/penguins-eggs.d/distros/trixie';
             await exec(`cp -r ${buster}/calamares ${dest}/calamares`, echo);
+            /**
+             * Debian 14 forky eredita tutto da buster
+             */
+        }
+        else if (codenameLikeId === 'forky') {
+            const dest = '/etc/penguins-eggs.d/distros/forky';
+            await exec(`cp -r ${buster}/calamares ${dest}/calamares`, echo);
             /***********************************************************************************
              * Devuan
              **********************************************************************************/

package/dist/classes/pxe.d.ts

@@ -21,14 +21,13 @@ export default class Pxe {
     pxeRoot: string;
     distro: Distro;
     settings: Settings;
-    verbose: boolean;
     vmlinuz: string;
     /**
      * constructor
      * @param nest
      * @param pxeRoot
      */
-    constructor(nest?: string, pxeRoot?: string);
+    constructor(nest?: string, pxeRoot?: string, verbose?: boolean);
     /**
      * fertilization()
      *

package/dist/classes/pxe.js

@@ -18,7 +18,6 @@ import Utils from './utils.js';
 import Diversions from './diversions.js';
 // _dirname
 const __dirname = path.dirname(new URL(import.meta.url).pathname);
-const bootloaders = path.resolve(__dirname, `../../bootloaders`);
 /**
  * Pxe:
  */
@@ -32,16 +31,16 @@ export default class Pxe {
     pxeRoot = '';
     distro = {};
     settings = {};
-    verbose = false;
     vmlinuz = '';
     /**
      * constructor
      * @param nest
      * @param pxeRoot
      */
-    constructor(nest = '', pxeRoot = '') {
+    constructor(nest = '', pxeRoot = '', verbose = false) {
         this.nest = nest;
         this.pxeRoot = pxeRoot;
+        this.echo = Utils.setEcho(verbose);
     }
     /**
      * fertilization()
@@ -206,19 +205,22 @@ export default class Pxe {
      * configure PXE bios
      */
     async bios() {
+        const bootloaders = Diversions.bootloaders(this.distro.familyId);
         await exec(`cp ${__dirname}/../../addons/eggs/theme/livecd/isolinux.theme.cfg ${this.pxeRoot}/isolinux.theme.cfg`, this.echo);
         await exec(`cp ${__dirname}/../../addons/eggs/theme/livecd/splash.png ${this.pxeRoot}/splash.png`, this.echo);
         // ipxe.pxe
-        await exec(`ln -s ${bootloaders}ipxe.pxe ${this.pxeRoot}/ipxe.pxe`, this.echo);
+        await exec(`ln -s ${bootloaders}ipxe/ipxe.pxe ${this.pxeRoot}/ipxe.pxe`, this.echo);
+        // snponly.efi
+        await exec(`ln -s ${bootloaders}ipxe/snponly.efi ${this.pxeRoot}/snponly.efi`, this.echo);
         // pxe
-        await exec(`cp ${bootloaders}/syslinux/pxelinux.0 ${this.pxeRoot}/pxelinux.0`, this.echo);
-        await exec(`cp ${bootloaders}/syslinux/lpxelinux.0 ${this.pxeRoot}/lpxelinux.0`, this.echo);
+        await exec(`cp ${bootloaders}PXELINUX/pxelinux.0 ${this.pxeRoot}/pxelinux.0`, this.echo);
+        await exec(`cp ${bootloaders}PXELINUX/lpxelinux.0 ${this.pxeRoot}/lpxelinux.0`, this.echo);
         // syslinux
-        await exec(`ln -s ${bootloaders}/syslinux/ldlinux.c32 ${this.pxeRoot}/ldlinux.c32`, this.echo);
-        await exec(`ln -s ${bootloaders}/syslinux/vesamenu.c32 ${this.pxeRoot}/vesamenu.c32`, this.echo);
-        await exec(`ln -s ${bootloaders}/syslinux/libcom32.c32 ${this.pxeRoot}/libcom32.c32`, this.echo);
-        await exec(`ln -s ${bootloaders}/syslinux/libutil.c32 ${this.pxeRoot}/libutil.c32`, this.echo);
-        await exec(`ln -s ${bootloaders}/syslinux/memdisk ${this.pxeRoot}/memdisk`, this.echo);
+        await exec(`ln -s ${bootloaders}syslinux/modules/bios/ldlinux.c32 ${this.pxeRoot}/ldlinux.c32`, this.echo);
+        await exec(`ln -s ${bootloaders}syslinux/modules/bios/vesamenu.c32 ${this.pxeRoot}/vesamenu.c32`, this.echo);
+        await exec(`ln -s ${bootloaders}syslinux/modules/bios/libcom32.c32 ${this.pxeRoot}/libcom32.c32`, this.echo);
+        await exec(`ln -s ${bootloaders}syslinux/modules/bios/libutil.c32 ${this.pxeRoot}/libutil.c32`, this.echo);
+        await exec(`ln -s ${bootloaders}syslinux/modules/bios/memdisk ${this.pxeRoot}/memdisk`, this.echo);
         await exec(`mkdir ${this.pxeRoot}/pxelinux.cfg`, this.echo);
         let content = '';
         content += '# eggs: pxelinux.cfg/default\n';
@@ -254,21 +256,33 @@ export default class Pxe {
      * @param familyId
      */
     async grubCfg() {
+        const bootloaders = Diversions.bootloaders(this.distro.familyId);
         const echoYes = Utils.setEcho(true);
         /**
          * On Debian bookworm:
-         * cd ~/penguins-eggs
-         * cp /usr/lib/grub/x86_64-efi-signed/grubnetx64.efi.signed ./bootloaders/
-         * cp -r /usr/lib/grub/x86_64-efi/ ./bootloaders/grub/x86_64-efi/
          */
         await exec(`mkdir -p ${this.pxeRoot}/grub`, this.echo);
-        /**
-         * Si potrebbe usare:
-         * ${bootloaders}/grub/x86_64-efi/monolithic/grubnetx64.efi
-         * come alternativa per distroname!=="Debian"
-         */
-        await exec(`cp ${bootloaders}/grubnetx64.efi.signed ${this.pxeRoot}/grub.efi`, this.echo);
-        await exec(`cp -r ${bootloaders}/grub/x86_64-efi ${this.pxeRoot}/grub`, this.echo);
+        if (this.distro.familyId === 'debian') {
+            if (process.arch === 'x64') {
+                await exec(`cp ${bootloaders}/grub/x86_64-efi-signed/grubnetx64.efi.signed ${this.pxeRoot}/grub.efi`, this.echo);
+                await exec(`cp -r ${bootloaders}/grub/x86_64-efi ${this.pxeRoot}/grub`, this.echo);
+            }
+            else if (process.arch === 'ia32') {
+                await exec(`cp ${bootloaders}/grub/i386-efi-signed/grubnetia32.efi.signed ${this.pxeRoot}/grub.efi`, this.echo);
+                await exec(`cp -r ${bootloaders}/grub/i386-efi ${this.pxeRoot}/grub`, this.echo);
+            }
+            else if (process.arch === 'arm64') {
+                await exec(`cp ${bootloaders}/grub/arm64-efi-signed/grubnetaa64.efi.signed ${this.pxeRoot}/grub.efi`, this.echo);
+                await exec(`cp -r ${bootloaders}/grub/arm64-efi ${this.pxeRoot}/grub`, this.echo);
+            }
+        }
+        else {
+            /**
+             * le altre distribuzione not signed
+             */
+            await exec(`cp ${bootloaders}grub/x86_64-efi/monolithic/grubnetx64.efi ${this.pxeRoot}/grub.efi`, this.echo);
+            await exec(`cp -r ${bootloaders}/grub/x86_64-efi ${this.pxeRoot}/grub`, this.echo);
+        }
         // Genera il file grub.cfg
         const grubName = `${this.pxeRoot}/grub/grub.cfg`; // Il file deve chiamarsi grub.cfg
         let grubContent = '';
@@ -320,15 +334,7 @@ export default class Pxe {
                 ip=dhcp`;
                 break;
             case 'fedora':
-                lp = `initrd=http://${Utils.address()}/live/${path.basename(this.initrdImg)} \
-               root=live:http://${Utils.address()}/live/filesystem.squashfs \
-               rootfstype=auto \
-               ro \
-               rd.live.image \
-               rd.luks=0 \
-               rd.md=0 \
-               rd.dm=0\n`;
-                break;
+            case 'openmamba':
             case 'opensuse':
                 lp = `initrd=http://${Utils.address()}/live/${path.basename(this.initrdImg)} \
                root=live:http://${Utils.address()}/live/filesystem.squashfs \