penguins-eggs 25.8.6 → 25.8.28

package/dist/classes/diversions.js

@@ -123,4 +123,11 @@ export default class Diversions {
         }
         return found;
     }
+    static bootloaders(familyId) {
+        let bootloaders = '/usr/lib/';
+        if (familyId !== 'debian') {
+            bootloaders = '/usr/lib/penguins-eggs/bootloaders/';
+        }
+        return bootloaders;
+    }
 }

package/dist/classes/incubation/incubator.d.ts

@@ -41,4 +41,8 @@ export default class Incubator {
      *
      */
     private createInstallerDirs;
+    /**
+     * soluzione tampone from Glenn
+     */
+    private sudoers;
 }

package/dist/classes/incubation/incubator.js

@@ -69,6 +69,7 @@ export default class Incubator {
         Utils.warning(`creating ${installer().name} configuration files on ${installer().configRoot}`);
         this.createInstallerDirs();
         this.createBranding();
+        this.sudoers();
         const codenameLikeId = this.distro.codenameLikeId;
         try {
             /**
@@ -111,6 +112,10 @@ export default class Incubator {
             else if (codenameLikeId === 'trixie') {
                 const trixie = new Buster(this.installer, this.remix, this.distro, this.user_opt, release, this.theme, this.isClone, this.verbose);
                 await trixie.create();
+            }
+            else if (codenameLikeId === 'forky') {
+                const forky = new Buster(this.installer, this.remix, this.distro, this.user_opt, release, this.theme, this.isClone, this.verbose);
+                await forky.create();
                 /**
                  * Devuan
                  */
@@ -349,6 +354,15 @@ export default class Incubator {
         shx.cp(path.resolve(__dirname, '../../../assets/calamares/install-system.sh'), '/usr/sbin/install-system.sh');
         shx.chmod('+x', '/usr/sbin/install-system.sh');
     }
+    /**
+     * soluzione tampone from Glenn
+     */
+    sudoers() {
+        let live = 'live';
+        let content = `${live} ALL=(ALL) NOPASSWD: /usr/bin/calamares`;
+        let fname = '/etc/sudoers.d/calamares';
+        fs.writeFileSync(fname, content, 'utf-8');
+    }
 }
 /**
  *

package/dist/classes/ovary.d/bind-live-fs.js

@@ -64,7 +64,7 @@ export async function bindLiveFs() {
                     cmds.push(`# /${dir} is copied if not exists on filesystem.squashfs`);
                     let chkDir = path.join(this.settings.config.snapshot_mnt, 'filesystem.squashfs', dir);
                     cmds.push(`if ! [ -d "${chkDir}" ]; then`);
-                    cmds.push(await rexec(`   cp -r /${dir} ${this.settings.config.snapshot_mnt}filesystem.squashfs`, this.verbose));
+                    cmds.push(await rexec(`   cp -a /${dir} ${this.settings.config.snapshot_mnt}filesystem.squashfs`, this.verbose));
                     cmds.push(`fi`);
                     continue;
                 }
@@ -99,7 +99,7 @@ export async function bindLiveFs() {
                 cmds.push('# file exist... skip');
             }
             else {
-                cmds.push(await rexec(`cp /${dir} ${this.settings.work_dir.merged}`, this.verbose));
+                cmds.push(await rexec(`cp -p /${dir} ${this.settings.work_dir.merged}`, this.verbose));
             }
         }
         cmds.push(endLine);

package/dist/classes/ovary.d/live-create-structure.js

@@ -29,7 +29,7 @@ export async function liveCreateStructure() {
         tryCatch(cmd, this.verbose);
     }
     if (!fs.existsSync(this.settings.config.snapshot_dir + '/README.md')) {
-        cmd = `cp ${path.resolve(__dirname, '../../conf/README.md')} ${this.settings.config.snapshot_dir}README.md`;
+        cmd = `cp ${path.resolve(__dirname, '../../../conf/README.md')} ${this.settings.config.snapshot_dir}README.md`;
         tryCatch(cmd, this.verbose);
     }
     // Ovarium

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

@@ -24,12 +24,24 @@ export function makeDotDisk(info = '', mksquashfs = '', mkisofs = '') {
         shx.rm('-rf', dotDisk);
     }
     shx.mkdir('-p', dotDisk);
-    let text = `# Created at: ${Utils.formatDate(new Date())}\n`;
-    text += `# penguins_eggs v. ${Utils.getPackageVersion()}\n`;
     /**
-     * write test as .disk/info
+     * write volid .disk/info
+     * Required
      */
-    fs.writeFileSync(path.join(dotDisk, 'info'), text, 'utf-8');
+    let 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
      */

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

@@ -10,7 +10,5 @@ import Ovary from '../ovary.js';
  *
  * @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 declare function makeEfi(this: Ovary, theme?: string): Promise<void>;

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)/${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");
     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/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

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()
      *