penguins-eggs 25.11.8 → 25.11.21

package/dist/appimage/first-run-check.d.ts

@@ -0,0 +1,8 @@
+/**
+ * ./src/appimage/first-run-check.ts
+ * penguins-eggs v.25.11.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+export {};

package/dist/appimage/first-run-check.js

@@ -0,0 +1,13 @@
+/**
+ * ./src/appimage/first-run-check.ts
+ * penguins-eggs v.25.11.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import { Prerequisites } from './prerequisites.js';
+const prerequisites = new Prerequisites();
+if (!prerequisites.check()) {
+    console.log('WARNING: You need to setup penguins-eggs for full functionality.');
+    console.log('Run: sudo eggs setup');
+}

package/dist/appimage/prerequisites.d.ts

@@ -0,0 +1,34 @@
+/**
+ *
+ */
+export declare class Prerequisites {
+    private distro;
+    constructor();
+    /**
+     * install
+     * @returns
+     */
+    install(force?: boolean): Promise<boolean>;
+    /**
+     *
+     * @returns
+     */
+    check(): boolean;
+    /**
+     *
+     * @param packages
+     * @returns
+     */
+    private getInstallCommand;
+    /**
+     *
+     * @param pkg
+     * @returns
+     */
+    private isPackageInstalled;
+    /**
+     *
+     * @returns
+     */
+    private getPackagesForDistro;
+}

package/dist/appimage/prerequisites.js

@@ -0,0 +1,350 @@
+/**
+ * ./src/appimage/prerequisites.ts
+ * penguins-eggs v.25.11.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import { execSync } from 'node:child_process';
+import Utils from '../classes/utils.js';
+import Distro from '../classes/distro.js';
+import Diversions from '../classes/diversions.js';
+/**
+ *
+ */
+export class Prerequisites {
+    distro;
+    constructor() {
+        this.distro = new Distro();
+    }
+    /**
+     * install
+     * @returns
+     */
+    async install(force = false) {
+        const packages = this.getPackagesForDistro();
+        if (packages.length === 0) {
+            console.log('ERROR: Unsupported distribution for automatic setup');
+            return false;
+        }
+        let missing = packages.filter(pkg => !this.isPackageInstalled(pkg));
+        if (force) {
+            missing = packages;
+        }
+        console.log('');
+        console.log('The following packages will be installed/reinstalled:');
+        console.log(`${missing.join(', ')}`);
+        console.log('');
+        if (await Utils.customConfirm('Select yes to continue...')) {
+            const installCmd = this.getInstallCommand(missing, force);
+            Utils.titles(installCmd);
+            try {
+                console.log('Installing packages (this may take a few minutes)...');
+                //execSync(installCmd, { stdio: 'inherit' })
+                execSync(installCmd, { stdio: 'ignore' });
+                console.log('');
+                console.log('SUCCESS: Prerequisites installed successfully!');
+                return true;
+            }
+            catch (error) {
+                console.log('');
+                console.log('ERROR: Failed to install prerequisites');
+                console.log('Error details:', error instanceof Error ? error.message : 'Unknown error');
+                console.log('');
+                console.log('Please check your system and try again.');
+                console.log('You can also install prerequisites manually using your package manager.');
+                return false;
+            }
+        }
+        return false;
+    }
+    /**
+     *
+     * @returns
+     */
+    check() {
+        try {
+            const packages = this.getPackagesForDistro();
+            if (packages.length === 0) {
+                console.log('WARNING: Unsupported distribution - cannot check prerequisites');
+                return false;
+            }
+            const missing = packages.filter(pkg => !this.isPackageInstalled(pkg));
+            if (missing.length > 0) {
+                console.log(`MISSING: ${missing.length} of ${packages.length} packages`);
+                console.log(`${missing.join(', ')}`);
+                return false;
+            }
+            console.log(`SUCCESS: All ${packages.length} packages are installed`);
+            return true;
+        }
+        catch (error) {
+            console.log('ERROR: Failed to check prerequisites');
+            console.log('Error details:', error instanceof Error ? error.message : 'Unknown error');
+            return false;
+        }
+    }
+    /**
+     *
+     * @param packages
+     * @returns
+     */
+    getInstallCommand(packages, forceReinstall = false) {
+        const packagesStr = packages.join(' ');
+        switch (this.distro.familyId) {
+            case 'debian':
+                // apt richiede il flag --reinstall per forzare la sovrascrittura
+                const aptCmd = forceReinstall ? 'install --reinstall' : 'install';
+                return `sudo apt-get update && sudo apt-get ${aptCmd} -y ${packagesStr}`;
+            case 'archlinux':
+                // Pacman -S reinstalla di default. 
+                // (Se volessimo evitare reinstallazioni su Arch useremmo --needed, ma qui va bene così)
+                return `sudo pacman -S --noconfirm ${packagesStr}`;
+            case 'fedora':
+                // dnf ha un comando specifico 'reinstall'
+                const dnfCmd = forceReinstall ? 'reinstall' : 'install';
+                return `sudo dnf ${dnfCmd} -y ${packagesStr}`;
+            default:
+                return `echo "Unsupported distribution: ${this.distro.familyId}"`;
+        }
+    }
+    /**
+     *
+     * @param pkg
+     * @returns
+     */
+    isPackageInstalled(pkg) {
+        try {
+            switch (this.distro.familyId) {
+                case 'debian':
+                    // Verifica se il pacchetto è installato
+                    execSync(`dpkg -s ${pkg}`, { stdio: 'ignore' });
+                    return true;
+                case 'archlinux':
+                    // Verifica se il pacchetto è installato su Arch
+                    execSync(`pacman -Q ${pkg}`, { stdio: 'ignore' });
+                    return true;
+                case 'fedora':
+                    // Verifica se il pacchetto è installato su fedora/Fedora
+                    execSync(`rpm -q ${pkg}`, { stdio: 'ignore' });
+                    return true;
+                default:
+                    return false;
+            }
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     *
+     * @returns
+     */
+    getPackagesForDistro() {
+        /**
+         * normalize as packageList
+         */
+        let packagesList = this.distro.familyId;
+        if (this.distro.familyId === 'el9') {
+            packagesList = 'fedora';
+        }
+        if (this.distro.familyId === 'archlinux' && Diversions.isManjaroBased(this.distro.distroLike)) {
+            packagesList = 'manjaro';
+        }
+        /**
+         * we select from packageList
+         */
+        if (packagesList === 'alpine') {
+            return [
+                'alpine-conf',
+                'apk-tools',
+                'bash',
+                'bash-completion',
+                'cryptsetup',
+                'curl',
+                'device-mapper-libs',
+                'dosfstools',
+                // 'fuse', 
+                'git',
+                'grub-bios',
+                'grub-efi',
+                'jq',
+                'lsblk',
+                'lvm2',
+                'mkinitfs',
+                'musl-locales',
+                // 'nodejs', 
+                'parted',
+                'polkit',
+                'rsync',
+                'shadow',
+                'squashfs-tools',
+                'sshfs',
+                'xorriso',
+                'zstd',
+                'libc6-compat',
+            ];
+        }
+        else if (packagesList === 'archlinux') {
+            return [
+                'arch-install-scripts',
+                'cryptsetup',
+                'curl',
+                'dosfstools',
+                'efibootmgr',
+                'erofs-utils',
+                'findutils',
+                // 'fuse2',
+                'git',
+                'gnupg',
+                'grub',
+                'jq',
+                'libarchive',
+                'libisoburn',
+                'lvm2',
+                'mkinitcpio-archiso',
+                'mkinitcpio-nfs-utils',
+                'mtools',
+                'nbd',
+                // 'nodejs',
+                'pacman-contrib',
+                'parted',
+                'polkit',
+                'procps-ng',
+                'pv',
+                'python',
+                'rsync',
+                'squashfs-tools',
+                'sshfs',
+                'syslinux',
+                'wget',
+                'xdg-utils',
+            ];
+        }
+        else if (packagesList === 'debian') {
+            let debianPackages = [
+                'cryptsetup',
+                'curl',
+                'dosfstools',
+                'dpkg-dev',
+                'git',
+                'gnupg',
+                'grub-efi-amd64-bin',
+                'grub-pc-bin',
+                'grub2-common',
+                'ipxe',
+                'isolinux',
+                'jq',
+                'live-boot',
+                'live-boot-initramfs-tools',
+                'live-config',
+                'lvm2',
+                'parted',
+                'rsync',
+                'squashfs-tools',
+                'sshfs',
+                'syslinux-common',
+                'syslinux',
+                'xorriso',
+            ];
+            if (Utils.isSystemd()) {
+                debianPackages.push('live-config-systemd');
+            }
+            else {
+                debianPackages.push('live-config-sysvinit');
+            }
+            debianPackages.sort();
+            return debianPackages;
+        }
+        else if (packagesList === 'fedora') {
+            return [
+                'cryptsetup',
+                'curl',
+                'device-mapper',
+                'dosfstools',
+                'dracut-live',
+                'dracut',
+                'efibootmgr',
+                // 'fuse',
+                'git',
+                'jq',
+                'lvm2',
+                // 'nodejs',
+                'nvme-cli',
+                'parted',
+                'polkit',
+                'rsync',
+                'squashfs-tools',
+                'sshfs',
+                'wget',
+                'xdg-utils',
+                'xorriso',
+                'zstd',
+            ];
+        }
+        else if (packagesList === 'manjaro') {
+            return [
+                'arch-install-scripts',
+                'curl',
+                'dosfstools',
+                'efibootmgr',
+                'erofs-utils',
+                'findutils',
+                // 'fuse2',
+                'git',
+                'gnupg',
+                'grub',
+                'jq',
+                'libarchive',
+                'libisoburn',
+                'lvm2',
+                'manjaro-tools-iso',
+                'mkinitcpio-nfs-utils',
+                'mtools',
+                'nbd',
+                // 'nodejs',
+                'pacman-contrib',
+                'parted',
+                'polkit',
+                'procps-ng',
+                'pv',
+                'python',
+                'rsync',
+                'squashfs-tools',
+                'sshfs',
+                'wget',
+                'xdg-utils',
+            ];
+        }
+        else if (packagesList === 'opensuse') {
+            return [
+                'cryptsetup',
+                'curl',
+                'device-mapper',
+                'dosfstools',
+                'dracut-kiwi-live',
+                'dracut',
+                'efibootmgr',
+                // 'fuse-sshfs',
+                // 'fuse',
+                'git',
+                'jq',
+                'lvm2',
+                // 'nodejs',
+                'nvme-cli',
+                'parted',
+                'polkit',
+                'rsync',
+                'squashfs-tools',
+                'wget',
+                'xdg-utils',
+                'xorriso',
+                'zstd',
+            ];
+        }
+        else {
+            console.log(`This distro ${this.distro.distroId}/${this.distro.codenameId} is not yet recognized!`);
+            return [];
+        }
+    }
+}

package/dist/bin/dev.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node --loader ts-node/esm --no-warnings=ExperimentalWarning "%~dp0\dev" %*

package/dist/bin/dev.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env -S node --loader ts-node/esm --no-warnings=ExperimentalWarning
+
+// eslint-disable-next-line n/shebang
+import {execute} from '@oclif/core'
+
+await execute({development: true, dir: import.meta.url})

package/dist/bin/run.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node "%~dp0\run" %*

package/dist/bin/run.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import {execute} from '@oclif/core'
+
+await execute({dir: import.meta.url})

package/dist/classes/cli-autologin.js

@@ -147,10 +147,10 @@ export default class CliAutologin {
         eggsMotd += startMessage + '\n';
         eggsMotd += Utils.flag() + '\n';
         eggsMotd += `You are logged as: ${chalk.bold(user)} your password is: ${chalk.bold(userPasswd)}, root password: ${chalk.bold(rootPasswd)}\n\n`;
-        eggsMotd += `install              : ${chalk.bold(installer)}\n`;
-        eggsMotd += ` --unattended        : ${chalk.bold('sudo eggs install --unattended')}\n`;
-        eggsMotd += ` --chroot            : ${chalk.bold('sudo eggs install --chroot')}\n`;
-        eggsMotd += ` --help              : ${chalk.bold('sudo eggs install --help')}\n\n`;
+        eggsMotd += `install system       : ${chalk.bold(installer)}\n`;
+        eggsMotd += ` --unattended        : ${chalk.bold('sudo eggs krill --unattended')}\n`;
+        eggsMotd += ` --chroot            : ${chalk.bold('sudo eggs krill --chroot')}\n`;
+        eggsMotd += ` --help              : ${chalk.bold('sudo eggs krill --help')}\n\n`;
         eggsMotd += stopMessage + '\n';
         // 🔧 [Change 9] - Same as above: safe write with error handling to improve reliability.
         try {

package/dist/classes/distro.js

@@ -67,10 +67,9 @@ class Distro {
             this.distroId = "Bigcommunity";
         }
         /**
-         * Alpine, Fedora, openmamba, opensuse, VoidLinux solo distroId.
+         * Alpine, Fedora, openmamba, opensuse analyze **distroId**
          *
-         * Debian, Devuan, Ubuntu e derivate ricadono in
-         * default e si analizza il codebaseId
+         * Arch, Debian, Devuan, Ubuntu and derivatives we analyze **codebaseId**
          *
          */
         if (this.distroId === 'Alpine') {
@@ -118,7 +117,7 @@ class Distro {
         }
         else {
             /**
-             * We must analize codenameId
+             * Debian/ARCH: we  analize **codenameId**
              */
             /**
              * Arch
@@ -177,13 +176,6 @@ class Distro {
                 this.distroLike = 'Debian';
                 this.distroUniqueId = 'trixie';
                 this.liveMediumPath = '/run/live/medium/'; //initramfs
-                // this.liveMediumPath = '/run/initramfs/live/'  // dracut
-                /**
-                 * dracut su trixie
-                 if (Pacman.packageIsInstalled('dracut')) {
-                   this.liveMediumPath = '/run/initramfs/live/'
-                 }
-                 */
                 /**
                  * Debian 14 forky
                  */
@@ -219,14 +211,6 @@ class Distro {
             else if (this.codenameId === 'excalibur') {
                 this.distroLike = 'Devuan';
                 this.distroUniqueId = 'excalibur';
-                /**
-                 * Ubuntu bionic
-                 */
-            }
-            else if (this.codenameId === 'bionic') {
-                this.distroLike = 'Ubuntu';
-                this.distroUniqueId = 'bionic';
-                this.liveMediumPath = '/lib/live/mount/medium/';
                 /**
                  * Ubuntu focal
                  */
@@ -264,11 +248,11 @@ class Distro {
                 /**
                  * derivatives: families archlinux, debian
                  */
-                let file = path.resolve(__dirname, '../../conf/derivatives.yaml');
+                let archDebianDerivatives = path.resolve(__dirname, '../../conf/derivatives.yaml');
                 if (fs.existsSync('/etc/penguins-eggs.d/derivatives.yaml')) {
-                    file = '/etc/penguins-eggs.d/derivatives.yaml';
+                    archDebianDerivatives = '/etc/penguins-eggs.d/derivatives.yaml';
                 }
-                const content = fs.readFileSync(file, 'utf8');
+                const content = fs.readFileSync(archDebianDerivatives, 'utf8');
                 const distros = yaml.load(content);
                 for (const distro of distros) {
                     if (distro.ids !== undefined) {
@@ -287,11 +271,11 @@ class Distro {
                  * derivatives: family fedora
                  */
                 if (!found) {
-                    let file = path.resolve(__dirname, '../../conf/derivatives_fedora.yaml');
+                    let fedoraDerivatives = path.resolve(__dirname, '../../conf/derivatives_fedora.yaml');
                     if (fs.existsSync('/etc/penguins-eggs.d/derivatives_fedora.yaml')) {
-                        file = '/etc/penguins-eggs.d/derivatives_fedora.yaml';
+                        fedoraDerivatives = '/etc/penguins-eggs.d/derivatives_fedora.yaml';
                     }
-                    const content = fs.readFileSync(file, 'utf8');
+                    const content = fs.readFileSync(fedoraDerivatives, 'utf8');
                     const elem = yaml.load(content);
                     if (elem.includes(this.distroId)) {
                         this.familyId = 'fedora';
@@ -327,7 +311,7 @@ class Distro {
             this.usrLibPath = '/usr/lib64/';
         }
         /**
-         * Manjarolinux e derivate (biglinux)
+         * Manjarolinux anf derivatives (biglinux)
          */
         if (Diversions.isManjaroBased(this.distroId)) {
             this.liveMediumPath = '/run/miso/bootmnt/';
@@ -345,7 +329,7 @@ class Distro {
                 const data = fs.readFileSync(os_release, 'utf8');
                 lines = data.split('\n');
             }
-            // per ogni riga
+            // read every line
             for (const line of lines) {
                 if (line.startsWith('HOME_URL=')) {
                     this.homeUrl = line.slice('HOME_URL='.length).replaceAll('"', '');

package/dist/classes/diversions.d.ts

@@ -15,5 +15,10 @@ export default class Diversions {
     static kernelParameters(familyId: string, volid: string, fullCrypt?: boolean): string;
     static distro(): IDistro;
     static isManjaroBased(distro: string): boolean;
+    /**
+     *
+     * @param familyId
+     * @returns
+     */
     static bootloaders(familyId: string): string;
 }

package/dist/classes/diversions.js

@@ -7,6 +7,10 @@
  * NEW VERSION: Improved and cleaned with detailed comments and new changes
  */
 import Distro from './distro.js';
+import path from 'path';
+import Utils from './utils.js';
+// _dirname
+const __dirname = path.dirname(new URL(import.meta.url).pathname);
 export default class Diversions {
     // NEW CHANGE [1]
     // Made isSystemDBoot more readable by using direct return without extra variable.
@@ -18,21 +22,21 @@ export default class Diversions {
     // Simplified deluser function using array.includes and default value.
     // This makes adding new families easier and avoids long OR chains.
     static deluser(familyId) {
-        const userdelFamilies = ['aldos', 'archlinux', 'fedora', 'openmamba', 'opensuse', 'voidlinux'];
+        const userdelFamilies = ['archlinux', 'fedora', 'openmamba', 'opensuse', 'voidlinux'];
         return userdelFamilies.includes(familyId) ? 'userdel' : 'deluser';
     }
     // NEW CHANGE [3]
     // Improved grubName using array.includes and direct return
     // Cleaner, easier to maintain if new families are added
     static grubName(familyId) {
-        const grub2Families = ['aldos', 'fedora', 'opensuse'];
+        const grub2Families = [, 'fedora', 'opensuse'];
         return grub2Families.includes(familyId) ? 'grub2' : 'grub';
     }
     // NEW CHANGE [4]
     // Simplified grubForce function with array.includes
     // Provides explicit "--force" only for specific families
     static grubForce(familyId) {
-        const forceFamilies = ['aldos', 'fedora'];
+        const forceFamilies = [, 'fedora'];
         return forceFamilies.includes(familyId) ? '--force' : '';
     }
     // NEW CHANGE [5]
@@ -91,10 +95,22 @@ export default class Diversions {
         const manjaroFamilies = ['Manjaro', 'Biglinux', 'Bigcommunity'];
         return manjaroFamilies.includes(distro);
     }
-    // NEW CHANGE [8]
-    // bootloaders path handling improved
-    // Default path for debian, custom path for all other families
+    /**
+     *
+     * @param familyId
+     * @returns
+     */
     static bootloaders(familyId) {
-        return familyId === 'debian' ? '/usr/lib/' : '/usr/lib/penguins-eggs/bootloaders/';
+        let pathBootloaders = '/usr/lib/';
+        if (familyId !== "debian") {
+            if (Utils.isAppImage()) {
+                const appImagePath = path.join(__dirname, '..', '..', 'bootloaders');
+                pathBootloaders = appImagePath;
+            }
+            else {
+                pathBootloaders = '/usr/lib/penguins-eggs/bootloaders/';
+            }
+        }
+        return pathBootloaders;
     }
 }

package/dist/classes/incubation/customize/customize-partitions.js

@@ -24,7 +24,8 @@ export async function customizePartitions() {
      */
     partition.availableFileSystemTypes = ['ext4'];
     if (Pacman.packageIsInstalled('progs') ||
-        Pacman.packageIsInstalled('btrfsprogs')) {
+        Pacman.packageIsInstalled('btrfsprogs') ||
+        Pacman.packageIsInstalled('btrfs-progs')) {
         partition.availableFileSystemTypes.push('btrfs');
     }
     if (Pacman.packageIsInstalled('xfsprogs')) {
@@ -33,5 +34,11 @@ export async function customizePartitions() {
     if (Pacman.packageIsInstalled('f2fs-tools')) {
         partition.availableFileSystemTypes.push('f2fs');
     }
+    // Cannot work here
+    // if (!fs.existsSync('/sys/firmware/efi')) {
+    //   if (partition.efi) {
+    //     delete partition.efi
+    //   }
+    // }
     fs.writeFileSync(filePartition, yaml.dump(partition), 'utf-8');
 }

package/dist/classes/incubation/fisherman-helper/packages.js

@@ -12,7 +12,7 @@ import Pacman from '../../pacman.js';
  * @returns yaml-string
  */
 export function remove(distro) {
-    const packages = ['calamares-eggs', 'calamares'];
+    const packages = ['calamares'];
     if (distro.familyId === 'archlinux') {
         packages.push('penguins-eggs');
     }