penguins-eggs 9.0.25 → 9.0.48

package/lib/classes/tailor.js

@@ -0,0 +1,460 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const utils_1 = tslib_1.__importDefault(require("./utils"));
+const utils_2 = require("../lib/utils");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const js_yaml_1 = tslib_1.__importDefault(require("js-yaml"));
+const pacman_1 = tslib_1.__importDefault(require("./pacman"));
+/**
+ *
+ */
+class Tailor {
+    constructor(wardrobe, costume, verbose = false) {
+        this.verbose = false;
+        this.echo = {};
+        this.costume = '';
+        this.wardrobe = '';
+        this.materials = {};
+        this.costume = costume;
+        this.wardrobe = wardrobe;
+    }
+    /**
+     *
+     */
+    async prepare(verbose = false) {
+        this.verbose = verbose;
+        this.echo = utils_1.default.setEcho(verbose);
+        utils_1.default.warning(`preparing ${this.costume}`);
+        /**
+         * check curl presence
+         */
+        if (!pacman_1.default.packageIsInstalled('curl')) {
+            utils_1.default.pressKeyToExit('In this tailoring shop we use curl. sudo apt update | apt install curl');
+            process.exit();
+        }
+        const tailorList = `${this.wardrobe}/${this.costume}/index.yml`;
+        if (fs_1.default.existsSync(tailorList)) {
+            this.materials = js_yaml_1.default.load(fs_1.default.readFileSync(tailorList, 'utf-8'));
+        }
+        else {
+            console.log('costume ' + chalk_1.default.cyan(this.costume) + ' not found in wardrobe: ' + chalk_1.default.green(this.wardrobe));
+        }
+        /**
+         * Repositories
+         */
+        if (this.materials.sequence.repositories === undefined) {
+            console.log('repositiories, and repositories.update MUST be defined on sequence ');
+            process.exit();
+        }
+        utils_1.default.warning(`analyzing repositories`);
+        /**
+        * sources.list
+        */
+        if (this.materials.sequence.repositories.sourcesList !== undefined) {
+            let step = '/etc/apt/sources.list';
+            utils_1.default.warning(step);
+            let components = '';
+            if (this.materials.sequence.repositories.sourcesList.main) {
+                components += ' main';
+            }
+            if (this.materials.sequence.repositories.sourcesList.contrib) {
+                components += ' contrib';
+            }
+            if (this.materials.sequence.repositories.sourcesList.nonFree) {
+                components += ' non-free';
+            }
+            console.log(`using: ${components}`);
+        }
+        /**
+         * sources.list.d
+         */
+        if (this.materials.sequence.repositories.sourcesListD !== undefined) {
+            if (this.materials.sequence.repositories.sourcesListD[0] !== null) {
+                let step = `adding repositories to /etc/apt/sources.list.d`;
+                utils_1.default.warning(step);
+                for (const cmd of this.materials.sequence.repositories.sourcesListD) {
+                    try {
+                        await (0, utils_2.exec)(cmd, this.echo);
+                    }
+                    catch (error) {
+                        await utils_1.default.pressKeyToExit(JSON.stringify(error));
+                    }
+                }
+            }
+        }
+        /**
+         * apt-get update
+         */
+        if (this.materials.sequence.repositories.update === undefined) {
+            console.log('repositiories, and repositories.update MUDE be defined on sequence ');
+            process.exit();
+        }
+        let step = `updating repositories`;
+        utils_1.default.warning(step);
+        if (this.materials.sequence.repositories.update) {
+            await (0, utils_2.exec)('apt-get update', utils_1.default.setEcho(false));
+        }
+        /**
+         * apt-get full-upgrade
+         */
+        if (this.materials.sequence.repositories.fullUpgrade !== undefined) {
+            let step = `apt-get full-upgrade`;
+            utils_1.default.warning(step);
+            if (this.materials.sequence.repositories.fullUpgrade) {
+                await (0, utils_2.exec)('apt-get full-upgrade -y', utils_1.default.setEcho(false));
+            }
+        }
+        /**
+         * checking dependencies
+         */
+        if (this.materials.sequence.dependencies !== undefined) {
+            if (this.materials.sequence.dependencies[0] !== null) {
+                let cmd = 'apt-get install -y ';
+                let dependencies = '';
+                for (const dependence of this.materials.sequence.dependencies) {
+                    cmd += ` ${dependence}`;
+                    dependencies += `, ${dependence}`;
+                }
+                let step = `installing dependencies: ${dependencies.substring(2)}`;
+                utils_1.default.warning(step);
+                if (verbose) {
+                    utils_1.default.titles();
+                    utils_1.default.pressKeyToExit(cmd, true);
+                }
+                await (0, utils_2.exec)(cmd, this.echo);
+            }
+        }
+        /**
+         * apt-get install packages
+         */
+        if (this.materials.sequence.packages !== undefined) {
+            if (this.materials.sequence.packages[0] !== null) {
+                let packages = '';
+                let cmd = 'apt-get install -y ';
+                for (const elem of this.materials.sequence.packages) {
+                    cmd += ` ${elem}`;
+                    packages += `, ${elem}`;
+                }
+                let step = `installing packages: ${packages.substring(2)}`;
+                utils_1.default.warning(step);
+                if (verbose) {
+                    utils_1.default.titles();
+                    utils_1.default.pressKeyToExit(cmd, true);
+                }
+                await (0, utils_2.exec)(cmd, this.echo);
+            }
+        }
+        /**
+        * apt-get install --no-install-recommends --no-install-suggests
+        */
+        if (this.materials.sequence.noInstallRecommends !== undefined) {
+            if (this.materials.sequence.noInstallRecommends[0] !== null) {
+                let cmd = 'apt-get install --no-install-recommends --no-install-suggests -y ';
+                let noInstallRecommends = '';
+                for (const elem of this.materials.sequence.noInstallRecommends) {
+                    cmd += ` ${elem}`;
+                    noInstallRecommends += `, ${elem}`;
+                }
+                let step = `installing packages --no-install-recommends --no-install-suggests ${noInstallRecommends.substring(2)}`;
+                utils_1.default.warning(step);
+                if (verbose) {
+                    utils_1.default.titles();
+                    utils_1.default.pressKeyToExit(cmd, true);
+                }
+                await (0, utils_2.exec)(cmd, this.echo);
+            }
+        }
+        /**
+        * pip packages
+        */
+        if (this.materials.sequence.packagesPip !== undefined) {
+            if (this.materials.sequence.packagesPip[0] !== null) {
+                let cmd = 'pip install ';
+                let pip = '';
+                for (const elem of this.materials.sequence.packagesPip) {
+                    cmd += ` ${elem}`;
+                    pip += `, ${elem}`;
+                }
+                let step = `installing python packages pip ${pip.substring(2)}`;
+                utils_1.default.warning(step);
+                if (verbose) {
+                    utils_1.default.titles();
+                    utils_1.default.pressKeyToExit(cmd, true);
+                }
+                await (0, utils_2.exec)(cmd, this.echo);
+            }
+        }
+        /**
+         * firmwares
+         */
+        if (this.materials.sequence.firmwares !== undefined) {
+            /**
+             * codecs
+             */
+            if (this.materials.sequence.firmwares.codecs !== undefined) {
+                if (this.materials.sequence.firmwares.codecs[0] !== null) {
+                    let cmd = 'apt-get install -y ';
+                    let codecs = '';
+                    for (const elem of this.materials.sequence.firmwares.codecs) {
+                        cmd += ` ${elem}`;
+                        codecs += `, ${elem}`;
+                    }
+                    let step = `installing packages firmware codecs ${codecs.substring(2)}`;
+                    utils_1.default.warning(step);
+                    if (verbose) {
+                        utils_1.default.titles();
+                        utils_1.default.pressKeyToExit(cmd, true);
+                    }
+                    await (0, utils_2.exec)(cmd, this.echo);
+                }
+            }
+            /**
+             * drivers_graphics_tablet
+             */
+            if (this.materials.sequence.firmwares.drivers_graphics_tablet !== undefined) {
+                if (this.materials.sequence.firmwares.drivers_graphics_tablet[0] !== null) {
+                    let cmd = 'apt-get install -y ';
+                    let drivers_graphics_tablet = '';
+                    for (const elem of this.materials.sequence.firmwares.drivers_graphics_tablet) {
+                        cmd += ` ${elem}`;
+                        drivers_graphics_tablet += `, ${elem}`;
+                    }
+                    let step = `installing packages firmware drivers_graphics_tablet ${drivers_graphics_tablet.substring(2)}`;
+                    utils_1.default.warning(step);
+                    if (verbose) {
+                        utils_1.default.titles();
+                        utils_1.default.pressKeyToExit(cmd, true);
+                    }
+                    await (0, utils_2.exec)(cmd, this.echo);
+                }
+            }
+            /**
+             * drivers_network
+             */
+            if (this.materials.sequence.firmwares.drivers_network !== undefined) {
+                if (this.materials.sequence.firmwares.drivers_network[0] !== null) {
+                    let cmd = 'apt-get install -y ';
+                    let drivers_network = '';
+                    for (const elem of this.materials.sequence.firmwares.drivers_network) {
+                        cmd += ` ${elem}`;
+                        drivers_network += `, ${elem}`;
+                    }
+                    let step = `installing packages firmware drivers_network ${drivers_network.substring(2)}`;
+                    utils_1.default.warning(step);
+                    if (verbose) {
+                        utils_1.default.titles();
+                        utils_1.default.pressKeyToExit(cmd, true);
+                    }
+                    await (0, utils_2.exec)(cmd, this.echo);
+                }
+                /**
+                 * drivers_various
+                 */
+                if (this.materials.sequence.firmwares.drivers_various !== undefined) {
+                    if (this.materials.sequence.firmwares.drivers_various[0] !== null) {
+                        let cmd = 'apt-get install -y ';
+                        let drivers_various = '';
+                        for (const elem of this.materials.sequence.firmwares.drivers_various) {
+                            cmd += ` ${elem}`;
+                            drivers_various += `, ${elem}`;
+                        }
+                        let step = `installing packages firmware drivers_network ${drivers_various.substring(2)}`;
+                        utils_1.default.warning(step);
+                        if (verbose) {
+                            utils_1.default.titles();
+                            utils_1.default.pressKeyToExit(cmd, true);
+                        }
+                        await (0, utils_2.exec)(cmd, this.echo);
+                    }
+                }
+            }
+            /**
+             * drivers_video_amd
+             */
+            if (this.materials.sequence.firmwares.drivers_video_amd !== undefined) {
+                if (this.materials.sequence.firmwares.drivers_video_amd[0] !== null) {
+                    let cmd = 'apt-get install -y ';
+                    let drivers_video_amd = '';
+                    for (const elem of this.materials.sequence.firmwares.drivers_video_amd) {
+                        cmd += ` ${elem}`;
+                        drivers_video_amd += `, ${elem}`;
+                    }
+                    let step = `installing packages firmware drivers_network ${drivers_video_amd.substring(2)}`;
+                    utils_1.default.warning(step);
+                    if (verbose) {
+                        utils_1.default.titles();
+                        utils_1.default.pressKeyToExit(cmd, true);
+                    }
+                    await (0, utils_2.exec)(cmd, this.echo);
+                }
+            }
+            /**
+             * drivers_video_nvidia
+             */
+            if (this.materials.sequence.firmwares.drivers_video_nvidia !== undefined) {
+                if (this.materials.sequence.firmwares.drivers_video_nvidia[0] !== null) {
+                    let cmd = 'apt-get install -y ';
+                    let drivers_video_nvidia = '';
+                    for (const elem of this.materials.sequence.firmwares.drivers_video_nvidia) {
+                        cmd += ` ${elem}`;
+                        drivers_video_nvidia += `, ${elem}`;
+                    }
+                    let step = `installing packages firmware drivers_network ${drivers_video_nvidia.substring(2)}`;
+                    utils_1.default.warning(step);
+                    if (verbose) {
+                        utils_1.default.titles();
+                        utils_1.default.pressKeyToExit(cmd, true);
+                    }
+                    await (0, utils_2.exec)(cmd, this.echo);
+                }
+            }
+            /**
+             * drivers_wifi
+             */
+            if (this.materials.sequence.firmwares.drivers_wifi !== undefined) {
+                if (this.materials.sequence.firmwares.drivers_wifi[0] !== null) {
+                    let cmd = 'apt-get install -y ';
+                    let drivers_wifi = '';
+                    for (const elem of this.materials.sequence.firmwares.drivers_wifi) {
+                        cmd += ` ${elem}`;
+                        drivers_wifi += `, ${elem}`;
+                    }
+                    let step = `installing packages firmware drivers_network ${drivers_wifi.substring(2)}`;
+                    utils_1.default.warning(step);
+                    if (verbose) {
+                        utils_1.default.titles();
+                        utils_1.default.pressKeyToExit(cmd, true);
+                    }
+                    await (0, utils_2.exec)(cmd, this.echo);
+                }
+            }
+            /**
+             * drivers_printer
+             */
+            if (this.materials.sequence.firmwares.drivers_printer !== undefined) {
+                if (this.materials.sequence.firmwares.drivers_printer[0] !== null) {
+                    let cmd = 'apt-get install -y ';
+                    let drivers_printer = '';
+                    for (const elem of this.materials.sequence.firmwares.drivers_printer) {
+                        cmd += ` ${elem}`;
+                        drivers_printer += `, ${elem}`;
+                    }
+                    let step = `installing packages firmware drivers_network ${drivers_printer.substring(2)}`;
+                    utils_1.default.warning(step);
+                    if (verbose) {
+                        utils_1.default.titles();
+                        utils_1.default.pressKeyToExit(cmd, true);
+                    }
+                    await (0, utils_2.exec)(cmd, this.echo);
+                }
+            }
+        }
+        /**
+         * dpkg -i *.deb
+         */
+        if (this.materials.sequence.debs !== undefined) {
+            if (this.materials.sequence.debs) {
+                let step = `installing local packages`;
+                utils_1.default.warning(step);
+                let cmd = `dpkg -i ${this.wardrobe}\*.deb`;
+                if (verbose) {
+                    utils_1.default.titles();
+                    utils_1.default.pressKeyToExit(cmd, true);
+                }
+                await (0, utils_2.exec)(cmd);
+            }
+        }
+        /**
+         * dirs
+         */
+        if (this.materials.sequence.dirs !== undefined) {
+            if (this.materials.sequence.dirs) {
+                if (fs_1.default.existsSync(`${this.wardrobe}/${this.costume}/dirs`)) {
+                    let step = `copying dirs`;
+                    let cmd = `rsync -avx  ${this.wardrobe}/${this.costume}/dirs/* /`;
+                    if (verbose) {
+                        utils_1.default.titles();
+                        utils_1.default.pressKeyToExit(cmd, true);
+                    }
+                    await (0, utils_2.exec)(cmd, this.echo);
+                    /**
+                     * Copyng skel in /home/user
+                     */
+                    const user = utils_1.default.getPrimaryUser();
+                    cmd = `rsync -avx  ${this.wardrobe}/${this.costume}/dirs/etc/skel/.* /home/${user}/`;
+                    await (0, utils_2.exec)(cmd, this.echo);
+                    await (0, utils_2.exec)(`chown ${user}:${user} /home/${user}/ -R`);
+                }
+            }
+        }
+        /**
+         * hostname and hosts
+         */
+        if (this.materials.sequence.hostname !== undefined) {
+            if (this.materials.sequence.hostname) {
+                utils_1.default.warning(`changing hostname = ${this.materials.name}`);
+                await this.hostname();
+            }
+        }
+        /**
+         * customizations
+         */
+        if (this.materials.sequence.customizations !== undefined) {
+            /**
+             * customizations/scripts
+             */
+            if (this.materials.sequence.customizations.scripts !== undefined) {
+                if (this.materials.sequence.customizations.scripts[0] !== null) {
+                    let step = `customizations scripts`;
+                    utils_1.default.warning(step);
+                    for (const script of this.materials.sequence.customizations.scripts) {
+                        await (0, utils_2.exec)(`${this.wardrobe}/${this.costume}/${script}`, utils_1.default.setEcho(true));
+                    }
+                }
+            }
+        }
+        /**
+         * reboot
+         * mandatory
+         */
+        if (this.materials.sequence.reboot === undefined) {
+            this.materials.sequence.reboot = true;
+        }
+        if (this.materials.sequence.reboot) {
+            utils_1.default.warning(`Reboot`);
+            await utils_1.default.pressKeyToExit('system need to reboot', true);
+            await (0, utils_2.exec)('reboot');
+        }
+    }
+    /**
+    * hostname and hosts
+    */
+    async hostname() {
+        /**
+         * hostname
+         */
+        let file = '/etc/hostname';
+        let text = this.materials.name;
+        await (0, utils_2.exec)(`rm ${file} `, this.echo);
+        fs_1.default.writeFileSync(file, text);
+        /**
+         * hosts
+         */
+        file = '/etc/hosts';
+        text = '';
+        text += '127.0.0.1 localhost localhost.localdomain\n';
+        text += `127.0.1.1 ${this.materials.name} \n`;
+        text += `# The following lines are desirable for IPv6 capable hosts\n`;
+        text += `:: 1     ip6 - localhost ip6 - loopback\n`;
+        text += `fe00:: 0 ip6 - localnet\n`;
+        text += `ff00:: 0 ip6 - mcastprefix\n`;
+        text += `ff02:: 1 ip6 - allnodes\n`;
+        text += `ff02:: 2 ip6 - allrouters\n`;
+        text += `ff02:: 3 ip6 - allhosts\n`;
+        await (0, utils_2.exec)(`rm ${file} `, this.echo);
+        fs_1.default.writeFileSync(file, text);
+    }
+}
+exports.default = Tailor;

package/lib/classes/tools.js

@@ -7,10 +7,10 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-const node_fs_1 = (0, tslib_1.__importDefault)(require("node:fs"));
-const js_yaml_1 = (0, tslib_1.__importDefault)(require("js-yaml"));
-const settings_1 = (0, tslib_1.__importDefault)(require("./settings"));
-const utils_1 = (0, tslib_1.__importDefault)(require("./utils"));
+const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
+const js_yaml_1 = tslib_1.__importDefault(require("js-yaml"));
+const settings_1 = tslib_1.__importDefault(require("./settings"));
+const utils_1 = tslib_1.__importDefault(require("./utils"));
 /**
  * Utils: general porpourse utils
  * @remarks all the utilities

package/lib/classes/users.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-const fs_1 = (0, tslib_1.__importDefault)(require("fs"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
 const utils_1 = require("../lib/utils");
 /**
  *

package/lib/classes/utils.d.ts

@@ -12,19 +12,26 @@ export default class Utils {
     /**
      * Restituisce il prefisso della iso
      * @param distroId
-     * @param versionId
+     * @param codenameId
      */
-    static snapshotPrefix(distroId: string, versionId: string): string;
+    static snapshotPrefix(distroId: string, codenameId: string): string;
     /**
     * Controlla se il sistema è avviato con systemd
     * funziona anche in MX che utilizza systemd
     * ma viene avviato con init
     */
     static isSystemd(): boolean;
+    /**
+     *
+     * @returns
+     */
     static isSysvinit(): boolean;
     /**
      * ricava path per vmlinuz
-     * BOOT_IMAGE=(hd0,msdos1)/vmlinuz-5.15.6-200.fc35.x86_64 root=UUID=91cf614e-62a1-464c-904f-38d0a1ceb7a7 ro rootflags=subvol=root rhgb quiet
+     * Normalmente cerca BOOT_IMAGE
+     * BOOT_IMAGE=/boot/vmlinuz-5.16.0-3-amd64 root=UUID=13768873-d6ba-4ae5-9e14-b5011f5aa31c ro quiet splash resume=UUID=beafb9b4-c429-4e1f-a268-4270b63a14e6
+     * se non è presente, come nel caso di Franco, cerca initrd e ricostruisce vmlinuz
+     * ro root=UUID=3dc0f202-8ac8-4686-9316-dddcec060c48 initrd=boot\initrd.img-5.15.0-0.bpo.3-amd64 // Conidi
      */
     static vmlinuz(): string;
     /**
@@ -258,6 +265,10 @@ export default class Utils {
      * @param msg
      */
     static customConfirmAbort(msg?: string): Promise<any>;
+    /**
+     *
+     */
+    static pressKeyToExit(warming?: string, canContinue?: boolean): Promise<void>;
     /**
      * titles
      * Penguin's are gettings alive!

package/lib/classes/utils.js

@@ -8,15 +8,16 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-const shelljs_1 = (0, tslib_1.__importDefault)(require("shelljs"));
-const fs_1 = (0, tslib_1.__importDefault)(require("fs"));
-const dns_1 = (0, tslib_1.__importDefault)(require("dns"));
-const path_1 = (0, tslib_1.__importDefault)(require("path"));
-const os_1 = (0, tslib_1.__importDefault)(require("os"));
-const pjson_1 = (0, tslib_1.__importDefault)(require("pjson"));
-const inquirer_1 = (0, tslib_1.__importDefault)(require("inquirer"));
-const chalk_1 = (0, tslib_1.__importDefault)(require("chalk"));
-const pacman_1 = (0, tslib_1.__importDefault)(require("./pacman"));
+const shelljs_1 = tslib_1.__importDefault(require("shelljs"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const dns_1 = tslib_1.__importDefault(require("dns"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const os_1 = tslib_1.__importDefault(require("os"));
+const pjson_1 = tslib_1.__importDefault(require("pjson"));
+const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const pacman_1 = tslib_1.__importDefault(require("./pacman"));
+const child_process_1 = require("child_process");
 /**
  * Utils: general porpourse utils
  * @remarks all the utilities
@@ -25,10 +26,10 @@ class Utils {
     /**
      * Restituisce il prefisso della iso
      * @param distroId
-     * @param versionId
+     * @param codenameId
      */
-    static snapshotPrefix(distroId, versionId) {
-        let result = 'egg-of-' + distroId.toLowerCase() + '-' + versionId.toLowerCase() + '-';
+    static snapshotPrefix(distroId, codenameId) {
+        let result = 'egg-of-' + distroId.toLowerCase() + '-' + codenameId.toLowerCase() + '-';
         result = result.replace(`/`, '-');
         return result;
     }
@@ -38,31 +39,62 @@ class Utils {
     * ma viene avviato con init
     */
     static isSystemd() {
-        // return (shx.exec(`pidof systemd`).stdout.trim() === '1')
-        return (shelljs_1.default.exec(`ps -p 1 -o comm=`).stdout.trim() === 'systemd');
+        const checkFile = '/tmp/checksystemd';
+        shelljs_1.default.exec(`ps -p 1 -o comm= >${checkFile}`);
+        const isSystemd = fs_1.default.readFileSync(checkFile).includes('systemd');
+        shelljs_1.default.exec(`rm ${checkFile}`);
+        return isSystemd;
     }
+    /**
+     *
+     * @returns
+     */
     static isSysvinit() {
-        // return (shx.exec(`pidof systemd`).stdout.trim() === '1')
-        return (shelljs_1.default.exec(`ps -p 1 -o comm=`).stdout.trim() === 'init');
+        const checkFile = '/tmp/checkinit';
+        shelljs_1.default.exec(`ps -p 1 -o comm= >${checkFile}`);
+        const isSysvinit = fs_1.default.readFileSync(checkFile).includes('init');
+        shelljs_1.default.exec(`rm ${checkFile}`);
+        return isSysvinit;
     }
     /**
      * ricava path per vmlinuz
-     * BOOT_IMAGE=(hd0,msdos1)/vmlinuz-5.15.6-200.fc35.x86_64 root=UUID=91cf614e-62a1-464c-904f-38d0a1ceb7a7 ro rootflags=subvol=root rhgb quiet
+     * Normalmente cerca BOOT_IMAGE
+     * BOOT_IMAGE=/boot/vmlinuz-5.16.0-3-amd64 root=UUID=13768873-d6ba-4ae5-9e14-b5011f5aa31c ro quiet splash resume=UUID=beafb9b4-c429-4e1f-a268-4270b63a14e6
+     * se non è presente, come nel caso di Franco, cerca initrd e ricostruisce vmlinuz
+     * ro root=UUID=3dc0f202-8ac8-4686-9316-dddcec060c48 initrd=boot\initrd.img-5.15.0-0.bpo.3-amd64 // Conidi
      */
     static vmlinuz() {
-        const results = fs_1.default.readFileSync('/proc/cmdline', 'utf8').split(' ');
-        let result = results[0];
-        // result = result.substring(result.indexOf('=') + 1)
-        result = result.substring(result.indexOf('/'));
-        if (result.indexOf('@') > 0) {
-            result = result.substring(result.indexOf('@') + 1);
-        }
-        if (!fs_1.default.existsSync(result)) {
-            if (fs_1.default.existsSync('/boot' + result)) {
-                result = '/boot' + result;
+        let vmlinuz = '';
+        // find vmlinuz in /proc/cmdline
+        const cmdline = fs_1.default.readFileSync('/proc/cmdline', 'utf8').split(" ");
+        cmdline.forEach(cmd => {
+            if (cmd.includes('BOOT_IMAGE')) {
+                vmlinuz = cmd.substring(cmd.indexOf('=') + 1);
             }
+        });
+        // If vmlinuz not found in /proc/cmdline, try to find version in initrd.img
+        if (vmlinuz === '') {
+            cmdline.forEach(cmd => {
+                if (cmd.includes('initrd.img')) {
+                    vmlinuz = '/boot/vmlinuz' + cmd.substring(cmd.indexOf('initrd.img') + 10);
+                }
+            });
         }
-        return result;
+        // if vmlinuz exist in /boot
+        if (!fs_1.default.existsSync(vmlinuz)) {
+            if (fs_1.default.existsSync('/boot' + vmlinuz)) {
+                vmlinuz = '/boot' + vmlinuz;
+            }
+        }
+        // if vmlinux don't exist
+        if (!fs_1.default.existsSync(vmlinuz)) {
+            vmlinuz = '/path/to/vmlinuz';
+        }
+        // btrfs
+        if (vmlinuz.indexOf('@') > 0) {
+            vmlinuz = vmlinuz.substring(vmlinuz.indexOf(' ') + 1);
+        }
+        return vmlinuz;
     }
     /**
      * ricava path per initrdImg
@@ -685,6 +717,21 @@ class Utils {
             });
         });
     }
+    /**
+     *
+     */
+    static async pressKeyToExit(warming = 'Process will end', canContinue = true) {
+        Utils.warning(warming);
+        let msg = 'Press a key to exit...';
+        if (canContinue) {
+            msg = 'Press a key to continue...';
+        }
+        console.log(msg);
+        const pressKeyToExit = (0, child_process_1.spawnSync)('read _ ', { shell: true, stdio: [0, 1, 2] });
+        if (!canContinue) {
+            process.exit(0);
+        }
+    }
     /**
      * titles
      * Penguin's are gettings alive!