penguins-eggs 25.9.2 → 25.9.7

package/dist/commands/update.js

@@ -53,20 +53,16 @@ export default class Update extends Command {
         const choose = await this.choosePkg();
         Utils.titles(`updating via ${choose}`);
         switch (choose) {
-            case 'repos': {
-                await this.getPkgFromRepo();
-                break;
-            }
-            case 'lan': {
+            case 'LAN': {
                 await this.getPkgFromLan();
                 break;
             }
-            case 'sourceforge': {
-                this.getPkgFromSourceforge();
+            case 'Package_Manager': {
+                await this.getPkgFromPackageManager();
                 break;
             }
-            case 'sources': {
-                this.getFromSources();
+            case 'Source': {
+                this.getFromSource();
                 break;
             }
             // No default
@@ -76,18 +72,18 @@ export default class Update extends Command {
      *
      */
     async choosePkg() {
-        const choices = ['abort'];
-        choices.push('lan', 'repos', 'sourceforge', 'sources');
+        const choices = ['Abort'];
+        choices.push('LAN', 'Source', 'Package_Manager');
         const questions = [
             {
                 choices,
-                message: 'select update method',
+                message: 'Select update method',
                 name: 'selected',
                 type: 'list'
             }
         ];
         const answer = await inquirer.prompt(questions);
-        if (answer.selected === 'abort') {
+        if (answer.selected === 'Abort') {
             process.exit(0);
         }
         return answer.selected;
@@ -95,19 +91,31 @@ export default class Update extends Command {
     /**
      *
      */
-    async getPkgFromRepo() {
+    async getPkgFromPackageManager() {
         let cmd = "";
-        if (this.distro.familyId === "debian") {
-            cmd = 'apt install penguins-eggs';
+        if (this.distro.familyId === 'alpine') {
+            cmd = `doas apk add penguins-egga`;
         }
         else if (this.distro.familyId === 'archlinux') {
-            cmd = 'pacman -S penguins-eggs';
+            cmd = 'sudo pacman -S penguins-eggs';
+        }
+        else if (this.distro.familyId === "debian") {
+            cmd = 'sudo apt install penguins-eggs';
         }
-        else if (this.distro.familyId === 'alpine') {
-            cmd = `apk add penguins-egga`;
+        else if (this.distro.familyId === "fedora") {
+            cmd = 'sudo dnf install penguins-eggs\nsudo dnf install penguins-eggs';
         }
+        else if (this.distro.familyId === "openmamba") {
+            cmd = 'sudo dnf install penguins-eggs\nsudo dnf install penguins-eggs';
+        }
+        else if (this.distro.familyId === "opensuse") {
+            cmd = 'sudo zypper install penguins-eggs';
+        }
+        Utils.titles(`update`);
+        Utils.warning(`To update/install penguins-eggs cut and copy follow commands`);
+        console.log();
         console.log(cmd);
-        await exec(cmd);
+        console.log();
     }
     /**
      * download da LAN
@@ -115,92 +123,95 @@ export default class Update extends Command {
     async getPkgFromLan() {
         const Tu = new Tools();
         await Tu.loadSettings();
-        Utils.warning('Update from LAN');
-        if (this.distro.familyId === 'archlinux') {
+        Utils.warning('Update penguins-eggs from LAN');
+        let filter = '';
+        let copy = '';
+        let install = '';
+        /**
+         * Alpine
+         */
+        if (this.distro.familyId === 'alpine') {
+            let repo = `alpine/x86_64`;
+            filter = `penguins-eggs-*-*.*.?-r?.apk`;
+            copy = `scp ${Tu.config.remoteUser}@${Tu.config.remoteHost}:${Tu.config.remotePathPackages}/${repo}/${filter} /tmp`;
+            install = `apk add /tmp/${filter}`;
+            /**
+             * Arch
+             */
+        }
+        else if (this.distro.familyId === 'archlinux') {
             let repo = "aur";
+            filter = `penguins-eggs-??.*.*-?-any.pkg.tar.zst`;
             if (Diversions.isManjaroBased(this.distro.distroId)) {
                 repo = 'manjaro';
+                filter = `penguins-eggs-??.*.*-?-any.pkg.tar.*`;
             }
-            const filter = `penguins-eggs-25.*.*-?-any.pkg.tar.zst`;
-            const cmd = `scp ${Tu.config.remoteUser}@${Tu.config.remoteHost}:${Tu.config.remotePathPackages}/${repo}/${filter} /tmp`;
-            await exec(cmd, { capture: true, echo: true });
-            if (await Utils.customConfirm(`Want to install ${filter}`)) {
-                await exec(`pacman -U /tmp/${filter}`);
-            }
-        }
-        else if (this.distro.familyId === 'alpine') {
-            let arch = 'x86_64';
-            if (process.arch === 'ia32') {
-                arch = 'i386';
-            }
-            const filter = `penguins-eggs-25.*.*-r*.apk`;
-            const cmd = `scp ${Tu.config.remoteUser}@${Tu.config.remoteHost}:${Tu.config.remotePathPackages}/alpine/${filter} /tmp`;
-            await exec(cmd, { capture: true, echo: true });
-            if (await Utils.customConfirm(`Want to install ${filter}`)) {
-                await exec(`apk add /tmp/${filter}`);
-            }
+            copy = `scp ${Tu.config.remoteUser}@${Tu.config.remoteHost}:${Tu.config.remotePathPackages}/${repo}/${filter} /tmp`;
+            install = `pacman -U /tmp/${filter}`;
+            /**
+            * Devuan/Debian/Ubuntu
+            */
         }
         else if (this.distro.familyId === "debian") {
-            const filter = `penguins-eggs_25.*.*-*_${Utils.uefiArch()}.deb`;
-            const cmd = `scp ${Tu.config.remoteUser}@${Tu.config.remoteHost}:${Tu.config.remotePathPackages}/debs/${filter} /tmp`;
-            await exec(cmd, { capture: true, echo: true });
-            if (await Utils.customConfirm(`Want to install ${filter}`)) {
-                await exec(`dpkg -i /tmp/${filter}`);
-            }
+            let repo = 'debs';
+            filter = `penguins-eggs_??.*.*-?_${Utils.uefiArch()}.deb`;
+            copy = `scp ${Tu.config.remoteUser}@${Tu.config.remoteHost}:${Tu.config.remotePathPackages}/${repo}/${filter} /tmp`;
+            install = `dpkg -i /tmp/${filter}`;
+            /**
+            * fedora/el9
+            */
         }
-    }
-    /**
-     *
-     */
-    async getPkgFromSourceforge() {
-        let repo = '';
-        let cmd = '';
-        let url = 'https://sourceforge.net/projects/penguins-eggs/files/Packages';
-        let filter = `penguins-eggs`;
-        if (this.distro.familyId === 'archlinux') {
-            repo = "aur";
-            filter = `penguins-eggs-10.?.*-?-any.pkg.tar.zst`;
-            cmd = `sudo pacman -U ${filter}`;
-            if (Diversions.isManjaroBased(this.distro.distroId)) {
-                repo = 'manjaro';
+        else if (this.distro.familyId === "fedora") {
+            let repo = 'fedora';
+            let ftype = 'fc??';
+            if (this.distro.distroId !== 'Fedora') {
+                repo = 'el9';
+                ftype = 'el?';
             }
-            url = `${url}/${repo}`;
+            filter = `penguins-eggs-??.*.*-?.${ftype}.x86_64.rpm`;
+            copy = `scp ${Tu.config.remoteUser}@${Tu.config.remoteHost}:${Tu.config.remotePathPackages}/${repo}/${filter} /tmp`;
+            install = `dnf reinstall /tmp/${filter} || dnf install /tmp/${filter}`;
+            /**
+             * openmamba
+             */
         }
-        else if (this.distro.familyId === "alpine") {
-            let arch = 'x86_64';
-            if (process.arch === 'ia32') {
-                arch = 'i386';
-            }
-            repo = "alpine";
-            url = `${url}/${repo}/$arch/${Utils.uefiArch()}`;
-            const filter = `penguins-eggs-25.*.*-r*.apk`;
-            cmd = `doas apk add ${filter}`;
+        else if (this.distro.familyId === "openmamba") {
+            let repo = 'openmamba';
+            filter = `penguins-eggs-??.*.*-?mamba.x86_64.rpm`;
+            copy = `scp ${Tu.config.remoteUser}@${Tu.config.remoteHost}:${Tu.config.remotePathPackages}/${repo}/${filter} /tmp`;
+            install = `dnf reinstall /tmp/${filter} || dnf install /tmp/${filter}`;
+            /**
+             * opensuse
+             */
+        }
+        else if (this.distro.familyId === "opensuse") {
+            let repo = 'opensuse';
+            filter = `penguins-eggs-*.*.*-?.opensuse.x86_64.rpm`;
+            copy = `scp ${Tu.config.remoteUser}@${Tu.config.remoteHost}:${Tu.config.remotePathPackages}/${repo}/${filter} /tmp`;
+            install = `zypper install /tmp/${filter}`;
+        }
+        /**
+         * copy and install
+         */
+        if (await Utils.customConfirm(`Want to update/reinstall penguins-eggs`)) {
+            await exec(copy, { capture: true, echo: true });
+            await exec(install);
         }
-        else if (this.distro.familyId === "debian") {
-            repo = "debs";
-            url = `${url}/${repo}`;
-            filter = `penguins-eggs_25.*.*-*_${Utils.uefiArch()}.deb`;
-            cmd = `sudo apt-get install ./${filter}`;
-        }
-        let command = `- open your browser at ${url}\n`;
-        command += `- select and download last package: ${filter}\n`;
-        command += `- ${cmd}\n`;
-        console.log(command);
-        this.show(url);
     }
     /**
-   *
-   * @param aptVersion
-   */
-    getFromSources() {
-        console.log('You can get a fresh installation, cloning penguins-eggs:');
+     *
+     */
+    getFromSource() {
+        console.log('Use the following commands to use penguins-eggs from source:');
+        console.log('');
         console.log('cd ~');
         console.log('git clone https://github.com/pieroproietti/penguins-eggs');
+        console.log('cd penguins-eggs');
+        console.log('pnpm install');
+        console.log('pnpm build');
+        console.log('./eggs');
         console.log('');
-        console.log('Then, open your browser to read detailed instructions:');
-        console.log('https://github.com/pieroproietti/penguins-eggs/blob/master/PREREQUISITES/README.md');
-        console.log('');
-        console.log('');
+        console.log('NOTE: requires nodejs>18 and pnpm installed');
     }
     /**
      * show

package/dist/krill/classes/sequence.d/bootloader.js

@@ -18,18 +18,32 @@ import path from 'node:path';
 export default async function bootloader() {
     let grubName = Diversion.grubName(this.distro.familyId);
     let grubForce = Diversion.grubForce(this.distro.familyId);
-    /**
-     * grub-install: added --force per fedora family
-     */
-    // define grub-install --target=${target}
-    let target = `x86_64-efi`;
-    if (!this.efi) {
-        target = 'i386-pc';
+    let cmd = '';
+    if (this.efi) {
+        /**
+         * UEFI Installation
+         * This is the correct way to install GRUB for UEFI systems.
+         * --target: Specifies the EFI architecture (x86_64-efi or arm64-efi).
+         * --efi-directory: Tells GRUB where the EFI System Partition is mounted. CRITICAL.
+         * --bootloader-id: Creates the \EFI\fedora directory on the ESP and labels the NVRAM entry. CRITICAL.
+         * We do NOT specify the device (e.g., /dev/sda) for UEFI.
+         */
+        let target = `x86_64-efi`;
+        if (process.arch === 'arm64') {
+            target = `arm64-efi`;
+        }
+        let bootloaderId = this.distro.distroLike.toLowerCase();
+        cmd = `chroot ${this.installTarget} ${grubName}-install --target=${target} --efi-directory=/boot/efi --bootloader-id=${bootloaderId} --recheck ${grubForce}`;
     }
-    if (process.arch === 'arm64') {
-        target = `arm64-efi`;
+    else {
+        /**
+         * MBR (Legacy BIOS) Installation
+         * For legacy boot, we specify the installation device directly.
+         */
+        const target = 'i386-pc';
+        cmd = `chroot ${this.installTarget} ${grubName}-install --target=${target} ${this.partitions.installationDevice} ${grubForce}`;
     }
-    let cmd = `chroot ${this.installTarget} ${grubName}-install --target=${target} ${this.partitions.installationDevice} ${grubForce} ${this.toNull}`;
+    // await Utils.debug(`grub-install: ${cmd}`)
     await exec(cmd, this.echo);
     /**
      * grub-mkconfig

package/dist/krill/classes/sequence.d/bootloader_config.js

@@ -20,7 +20,7 @@ export default async function bootloaderConfig() {
     if (this.distro.familyId === 'alpine') {
         if (this.efi) {
             try {
-                cmd = `chroot ${this.installTarget} apk add grub grub-efi efibootmgr} ${this.toNull}`;
+                cmd = `chroot ${this.installTarget} apk add grub grub-efi efibootmgr shim} ${this.toNull}`;
                 await exec(cmd, this.echo);
             }
             catch (error) {
@@ -43,7 +43,7 @@ export default async function bootloaderConfig() {
     else if (this.distro.familyId === 'archlinux') {
         if (this.efi) {
             try {
-                cmd = `chroot ${this.installTarget} pacman -Sy grub efibootmgr} ${this.toNull}`;
+                cmd = `chroot ${this.installTarget} pacman -Sy grub efibootmgr shim} ${this.toNull}`;
                 await exec(cmd, this.echo);
             }
             catch (error) {
@@ -75,7 +75,7 @@ export default async function bootloaderConfig() {
         const aptInstallOptions = ' apt install -y --no-upgrade --allow-unauthenticated -o Acquire::gpgv::Options::=--ignore-time-conflict ';
         if (this.efi) {
             try {
-                cmd = `chroot ${this.installTarget} ${aptInstallOptions} grub-efi-${Utils.uefiArch()} --allow-unauthenticated ${this.toNull}`;
+                cmd = `chroot ${this.installTarget} ${aptInstallOptions} grub-efi-${Utils.uefiArch()} efibootmgr shim-signed --allow-unauthenticated ${this.toNull}`;
                 await exec(cmd, this.echo);
             }
             catch (error) {
@@ -92,13 +92,19 @@ export default async function bootloaderConfig() {
             }
         }
         /**
-         * fedora/openmamba
+         * fedora
          */
     }
-    else if (this.distro.familyId === 'fedora' || this.distro.familyId === 'openmamba') {
+    else if (this.distro.familyId === 'fedora') {
         if (this.efi) {
             try {
-                cmd = `chroot ${this.installTarget} dnf -y install grub2 grub2-efi-x64 efibootmgr shim ${this.toNull}`;
+                cmd = ``;
+                cmd += `chroot ${this.installTarget} `;
+                cmd += `dnf -y install grub2 `;
+                cmd += `grub2-efi-${process.arch} `;
+                cmd += `grub2-efi-${process.arch}-modules `;
+                cmd += `efibootmgr `;
+                cmd += `shim-${process.arch} ${this.toNull}`;
                 await exec(cmd, this.echo);
             }
             catch (error) {
@@ -107,7 +113,41 @@ export default async function bootloaderConfig() {
         }
         else {
             try {
-                cmd = `chroot ${this.installTarget} dnf -y install grub2 grub2-pc ${this.toNull}`;
+                cmd = ``;
+                cmd += `chroot ${this.installTarget} `;
+                cmd += `dnf -y install grub2 `;
+                cmd += `grub2-pc `;
+                cmd += `grub2-pc-modules ${this.toNull}`;
+                await exec(cmd, this.echo);
+            }
+            catch (error) {
+                await showError(cmd, error);
+            }
+        }
+        /**
+         * openmamba
+         */
+    }
+    else if (this.distro.familyId === 'openmamba') {
+        if (this.efi) {
+            try {
+                cmd = ``;
+                cmd += `chroot ${this.installTarget} `;
+                cmd += `dnf -y install grub `;
+                cmd += `grub-efi-x86_64 `;
+                cmd += `efibootmgr `;
+                cmd += `shim-signed ${this.toNull}`;
+                await exec(cmd, this.echo);
+            }
+            catch (error) {
+                await showError(cmd, error);
+            }
+        }
+        else {
+            try {
+                cmd = ``;
+                cmd += `chroot ${this.installTarget} `;
+                cmd += `dnf -y install grub ${this.toNull}`;
                 await exec(cmd, this.echo);
             }
             catch (error) {
@@ -121,7 +161,16 @@ export default async function bootloaderConfig() {
     else if (this.distro.familyId === 'opensuse') {
         if (this.efi) {
             try {
-                cmd = `chroot ${this.installTarget} zypper install -y grub2 grub2-i386-pc grub2-x86_64-efi- efibootmgr} ${this.toNull}`;
+                cmd = `chroot ${this.installTarget} zypper install -y grub2 grub2-x86_64-efi efibootmgr shim} ${this.toNull}`;
+                await exec(cmd, this.echo);
+            }
+            catch (error) {
+                await showError(cmd, error);
+            }
+        }
+        else {
+            try {
+                cmd = `chroot ${this.installTarget} zypper install -y zypper install -y grub2 grub2-i386-pc ${this.toNull}`;
                 await exec(cmd, this.echo);
             }
             catch (error) {
@@ -129,6 +178,7 @@ export default async function bootloaderConfig() {
             }
         }
     }
+    // await Utils.debug(`grub packages install cmd: ${cmd}`)
 }
 /**
  *

package/dist/krill/classes/sequence.d/mkfs.js

@@ -29,9 +29,11 @@ export default async function mkfs() {
         this.devices.efi.name = 'none'; // Trovare il modo
     }
     if (this.partitions.filesystemType === 'ext4') {
-        // efi
+        /**
+         * EFI
+         */
         if (this.efi) {
-            await exec(`mkdosfs -F 32 -I ${this.devices.efi.name} ${this.toNull}`, this.echo);
+            await exec(`mkfs.vfat -F 32 ${this.devices.efi.name} ${this.toNull}`, this.echo);
         }
         // boot
         if (this.devices.boot.name !== 'none') {
@@ -39,11 +41,13 @@ export default async function mkfs() {
                 this.devices.boot.fsType = 'ext2';
                 this.devices.boot.mountPoint = '/boot';
             }
-            await exec(`mke2fs -Ft ${this.devices.boot.fsType} ${this.devices.boot.name} ${this.toNull}`, this.echo);
+            // await exec(`mke2fs -Ft ${this.devices.boot.fsType} ${this.devices.boot.name} ${this.toNull}`, this.echo)
+            await exec(`mkfs.${this.devices.boot.fsType} -F ${this.devices.boot.name} ${this.toNull}`, this.echo);
         }
         // root 
         if (this.devices.root.name !== 'none') {
-            await exec(`mke2fs -Ft ${this.devices.root.fsType} ${this.devices.root.name} ${this.toNull}`, this.echo);
+            // await exec(`mke2fs -Ft ${this.devices.root.fsType} ${this.devices.root.name} ${this.toNull}`, this.echo)
+            await exec(`mkfs.ext4 -F ${this.devices.root.name} ${this.toNull}`, this.echo);
         }
         // data
         if (this.devices.data.name !== 'none') {

package/dist/krill/classes/sequence.d/mount_vfs.js

@@ -11,18 +11,37 @@ import { exec } from '../../../lib/utils.js';
  * mountvfs()
  */
 export async function mountVfs() {
+    /**
+     * dev
+     */
     await exec(`mkdir ${this.installTarget}/dev ${this.toNull}`, this.echo);
-    await exec(`mkdir ${this.installTarget}/dev/pts ${this.toNull}`, this.echo);
-    await exec(`mkdir ${this.installTarget}/proc ${this.toNull}`, this.echo);
-    await exec(`mkdir ${this.installTarget}/sys ${this.toNull}`, this.echo);
-    await exec(`mkdir ${this.installTarget}/run ${this.toNull}`, this.echo);
     await exec(`mount -o bind /dev ${this.installTarget}/dev ${this.toNull}`, this.echo);
+    /**
+     * dev/pts
+     */
+    await exec(`mkdir ${this.installTarget}/dev/pts ${this.toNull}`, this.echo);
     await exec(`mount -o bind /dev/pts ${this.installTarget}/dev/pts ${this.toNull}`, this.echo);
+    /**
+     * proc
+     */
+    await exec(`mkdir ${this.installTarget}/proc ${this.toNull}`, this.echo);
     await exec(`mount -o bind /proc ${this.installTarget}/proc ${this.toNull}`, this.echo);
+    /**
+    * sys
+    */
+    await exec(`mkdir ${this.installTarget}/sys ${this.toNull}`, this.echo);
     await exec(`mount -o bind /sys ${this.installTarget}/sys ${this.toNull}`, this.echo);
+    /**
+    * sys/efivar
+    */
     if (this.efi) {
-        await exec(`mount -o bind /sys/firmware/efi/efivars ${this.installTarget}/sys/firmware/efi/efivars ${this.toNull}`, this.echo);
+        await exec(`mkdir -p ${this.installTarget}/sys/firmware/efi/efivars ${this.toNull}`, this.echo);
+        await exec(`mount -o bind /sys/firmware/efi/efivars ${this.installTarget}/sys/firmware/efi/efivars`);
     }
+    /**
+     * run: use recursive binding rbins
+     */
+    await exec(`mkdir ${this.installTarget}/run ${this.toNull}`, this.echo);
     await exec(`mount -o rbind /run ${this.installTarget}/run ${this.toNull}`, this.echo);
 }
 /**

package/dist/krill/classes/sequence.d/partition.d/uefi_standard.js

@@ -9,11 +9,13 @@
 import { exec } from '../../../../lib/utils.js';
 export default async function uefiStandard(installDevice = "", p = "") {
     await exec(`parted --script ${installDevice} mklabel gpt`, this.echo);
-    await exec(`parted --script ${installDevice} mkpart efi  fat32      34s                256MiB`, this.echo); // sda1 EFI
-    await exec(`parted --script ${installDevice} mkpart swap linux-swap 256MiB ${this.swapSize + 256}Mib`, this.echo); // sda2 swap
-    await exec(`parted --script ${installDevice} mkpart root ext4 ${this.swapSize + 256}MiB         100%`, this.echo); // sda3 root
-    await exec(`parted --script ${installDevice} set 1 boot on`, this.echo); // sda1
-    await exec(`parted --script ${installDevice} set 1 esp on`, this.echo); // sda1
+    // Partizione EFI: inizia a 1MiB e ha una dimensione di circa 256MiB
+    // Finisce a 257MiB per avere uno spazio netto di 256MiB
+    await exec(`parted --script ${installDevice} mkpart efi fat32 1MiB 257MiB`, this.echo);
+    await exec(`parted --script ${installDevice} mkpart swap linux-swap 257MiB ${this.swapSize + 257}MiB`, this.echo);
+    await exec(`parted --script ${installDevice} mkpart root ext4 ${this.swapSize + 257}MiB 100%`, this.echo);
+    await exec(`parted --script ${installDevice} set 1 boot on`, this.echo);
+    await exec(`parted --script ${installDevice} set 1 esp on`, this.echo);
     this.devices.efi.name = `${installDevice}${p}1`;
     this.devices.efi.fsType = 'F 32 -I';
     this.devices.efi.mountPoint = '/boot/efi';

package/dist/krill/classes/sequence.js

@@ -140,7 +140,7 @@ export default class Sequence {
         this.devices.data = {};
         this.devices.swap = {};
         this.distro = new Distro();
-        this.efi = fs.existsSync('/efivars');
+        this.efi = fs.existsSync('/sys/firmware/efi/efivars');
         this.luksFile = `${this.distro.liveMediumPath}live/${this.luksName}`;
     }
     /**
@@ -162,12 +162,7 @@ export default class Sequence {
         // Setup (unchanged)
         await this.setupInstallation(domain, unattended, nointeractive, chroot, halt, verbose);
         // Installation sequence - each step clearly visible
-        await this.runInstallationSequence();
-        // Handle chroot if requested
-        if (chroot) {
-            const message = `You are in chroot mode under ${this.installTarget}, type "exit" to exit.`;
-            await this.emergencyShell(message);
-        }
+        await this.runInstallationSequence(chroot);
         // Completion
         await this.completeInstallation();
     }
@@ -211,7 +206,7 @@ export default class Sequence {
     /**
      * Main installation sequence - Linear and clear
      */
-    async runInstallationSequence() {
+    async runInstallationSequence(chroot = false) {
         // 1. Partitioning and formatting
         let isPartitioned = false;
         await this.executeStep("Creating partitions", 0, async () => {
@@ -316,7 +311,12 @@ export default class Sequence {
                 await this.executeStep(`running ${step}`, 90, () => this.execCalamaresModule(step));
             }
         }
-        // 14. Unmounting
+        // 14- Handle chroot if requested
+        if (chroot) {
+            const message = `You are in chroot mode under ${this.installTarget}, type "exit" to exit.`;
+            await this.emergencyShell(message);
+        }
+        // 15. Unmounting
         await this.executeStep("umount Virtual File System", 96, () => this.umountVfs());
         await this.executeStep("umount File system", 99, () => this.umountFs());
     }

package/dist/penguins-eggs_25.9.7-1_amd64.deb.sha256

@@ -0,0 +1 @@
+3930ad85d31d4d2446c15a710bc0263d2fdb86d17ab6632db42a07a5b60c7404  penguins-eggs_25.9.7-1_amd64.deb

package/dist/penguins-eggs_25.9.7-1_arm64.deb.sha256

@@ -0,0 +1 @@
+a6f9943c573d294c3d67e3c475cfd04fa80b4a97a5a25304ce93eaaae0251d0c  penguins-eggs_25.9.7-1_arm64.deb

package/dist/penguins-eggs_25.9.7-1_i386.deb.sha256

@@ -0,0 +1 @@
+590e0952befc90f777d12c52e8c7ce0ac5232637f0b61bfb5d7592038f5da3c3  penguins-eggs_25.9.7-1_i386.deb