penguins-eggs 25.11.12 → 25.11.21

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/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/pacman.js

@@ -417,21 +417,21 @@ export default class Pacman {
              * Ubuntu
              **********************************************************************************/
             /**
-             * Ubuntu focal: eredita da noble
+             * Ubuntu focal: eredita da focal
              */
         }
         else if (distroUniqueId === 'focal') {
             const dest = '/etc/penguins-eggs.d/distros/focal';
-            const noble = `${rootPen}/conf/distros/noble`;
-            await exec(`cp -r ${noble}/* ${dest}`, echo);
+            const focal = `${rootPen}/conf/distros/focal`;
+            await exec(`cp -r ${focal}/* ${dest}`, echo);
             /**
-             * Ubuntu 22.04 jammy: eredita da noble
+             * Ubuntu 22.04 jammy: eredita da focal
              */
         }
         else if (distroUniqueId === 'jammy') {
             const dest = '/etc/penguins-eggs.d/distros/jammy';
-            const noble = `${rootPen}/conf/distros/noble`;
-            await exec(`cp -r ${noble}/* ${dest}`, echo);
+            const focal = `${rootPen}/conf/distros/focal`;
+            await exec(`cp -r ${focal}/* ${dest}`, echo);
             /**
              * Ubuntu noble: e la nuova baseline per ubuntu
              *
@@ -592,13 +592,12 @@ export default class Pacman {
      * Installa manPage
      */
     static async manPageInstall(verbose = false) {
-        const manPageSrc = path.resolve(__dirname, '../../manpages/doc/man/eggs.roll.gz');
+        const manPageSrc = path.resolve(__dirname, '../../manpages/doc/man/eggs.1.gz');
         if (fs.existsSync(manPageSrc)) {
-            const man1Dir = '/usr/share/man/man1/';
-            if (!fs.existsSync(man1Dir)) {
-                exec(`mkdir ${man1Dir} -p`);
+            const manPageDest = `/usr/share/man/man1`;
+            if (!fs.existsSync(manPageDest)) {
+                exec(`mkdir ${manPageDest} -p`);
             }
-            const manPageDest = man1Dir + 'eggs.1.gz';
             exec(`cp ${manPageSrc} ${manPageDest}`);
             if (shx.exec('which mandb', { silent: true }).stdout.trim() !== '') {
                 await exec('mandb > /dev/null');

package/dist/classes/utils.d.ts

@@ -41,6 +41,10 @@ export default class Utils {
      * @param codenameId
      */
     static snapshotPrefix(distroId: string, codenameId: string): string;
+    /**
+     * isAppImage
+     */
+    static isAppImage(): boolean;
     /**
      * Detect if running inside a container (Docker or LXC)
      */

package/dist/classes/utils.js

@@ -91,6 +91,14 @@ export default class Utils {
         }
         return result;
     }
+    /**
+     * isAppImage
+     */
+    static isAppImage() {
+        return !!process.env.APPIMAGE ||
+            process.execPath.includes('.AppImage') ||
+            process.execPath.includes('/tmp/.mount_');
+    }
     /**
      * Detect if running inside a container (Docker or LXC)
      */
@@ -868,9 +876,17 @@ export default class Utils {
      * @returns flag
      */
     static flag() {
-        return chalk.bgGreen.whiteBright('      ' + pjson.name + '      ') +
-            chalk.bgWhite.blue(" Perri's Brewery edition ") +
-            chalk.bgRed.whiteBright('       ver. ' + pjson.version + '       ');
+        let type = '';
+        if (Utils.isAppImage()) {
+            type = 'AppImage:';
+        }
+        let title = `${pjson.name}`;
+        let green = ` ${type} ${title}`.padEnd(25, " ");
+        let white = ` Perri's brewery edition `.padEnd(25, " ");
+        let red = ` v${pjson.version} `.padStart(25, " ");
+        return chalk.bgGreen.whiteBright(green) +
+            chalk.bgWhite.blue(white) +
+            chalk.bgRed.whiteBright(red);
     }
     /**
      *

package/dist/commands/calamares.js

@@ -13,7 +13,7 @@ import Pacman from '../classes/pacman.js';
 import Settings from '../classes/settings.js';
 import Utils from '../classes/utils.js';
 export default class Calamares extends Command {
-    static description = 'configure calamares or install or configure it';
+    static description = 'a GUI system installer - install and configure calamares';
     static examples = ['sudo eggs calamares', 'sudo eggs calamares --install', 'sudo eggs calamares --install --theme=/path/to/theme', 'sudo eggs calamares --remove'];
     static flags = {
         help: Flags.help({ char: 'h' }),

package/dist/commands/config.js

@@ -99,10 +99,10 @@ export default class Config extends Command {
                 await exec('rm /etc/penguins-eggs.d -rf');
             }
             /**
-             * Se stiamo utilizzando eggs da sorgenti
+             * Se stiamo utilizzando eggs da source/appimage
              * Aggiungo autocomplete e manPage
              */
-            if (Utils.isSources()) {
+            if (Utils.isSources() || Utils.isAppImage()) {
                 Utils.warning('creating autocomplete...');
                 await Pacman.autocompleteInstall(verbose);
                 Utils.warning('creating eggs man page...');

package/dist/commands/{analyze.d.ts → export/appimage.d.ts}

@@ -1,26 +1,27 @@
 /**
- * ./src/commands/analyze.ts
+ * ./src/commands/export/appimage.ts
  * penguins-eggs v.25.7.x / ecmascript 2020
  * author: Piero Proietti
  * email: piero.proietti@gmail.com
  * license: MIT
  */
 import { Command } from '@oclif/core';
-import Users from '../classes/users.js';
-import { IWorkDir } from '../interfaces/i-workdir.js';
-export default class Analyze extends Command {
+import Tools from '../../classes/tools.js';
+export default class ExportAppimage extends Command {
     static description: string;
     static examples: string[];
     static flags: {
+        clean: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         help: import("@oclif/core/interfaces").BooleanFlag<void>;
         verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
-    config_file: string;
-    snapshot_dir: string;
-    work_dir: IWorkDir;
+    user: string;
+    clean: boolean;
+    verbose: boolean;
+    echo: {};
+    Tu: Tools;
     /**
-     * fill
+     *
      */
-    fill(): Promise<Users[]>;
     run(): Promise<void>;
 }