penguins-eggs 10.1.0 → 10.1.1

package/dist/krill/classes/prepare.js

@@ -0,0 +1,314 @@
+/**
+ * Krill Installer - Simplified Refactoring
+ * ./src/krill/prepare.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import os from 'os';
+import fs from 'fs';
+import shx from 'shelljs';
+import axios from 'axios';
+import { SwapChoice, InstallationMode, FsType } from './krill_enums.js';
+import Keyboards from '../../classes/keyboards.js';
+import Locales from '../../classes/locales.js';
+import Systemctl from '../../classes/systemctl.js';
+import Utils from '../../classes/utils.js';
+import { exec } from '../../lib/utils.js';
+import Sequence from './sequence.js';
+// UI Components
+import { welcome } from './prepare.d/welcome.js';
+import { location } from './prepare.d/location.js';
+import { keyboard } from './prepare.d/keyboard.js';
+import { partitions } from './prepare.d/partitions.js';
+import { users } from './prepare.d/users.js';
+import { network } from './prepare.d/network.js';
+import { summary } from './prepare.d/summary.js';
+const config_file = '/etc/penguins-eggs.d/krill.yaml';
+/**
+ * Main Krill installer class - Simplified refactoring
+ */
+export default class Krill {
+    // UI Components
+    welcome = welcome;
+    location = location;
+    keyboard = keyboard;
+    partitions = partitions;
+    users = users;
+    network = network;
+    summary = summary;
+    // Configuration
+    krillConfig = {};
+    locales = new Locales();
+    keyboards = new Keyboards();
+    // Installation flags
+    unattended = false;
+    nointeractive = false;
+    chroot = false;
+    halt = false;
+    /**
+     * Constructor
+     */
+    constructor(unattended = false, nointeractive = false, halt = false, chroot = false) {
+        this.unattended = unattended;
+        this.nointeractive = nointeractive;
+        this.chroot = chroot;
+        this.halt = halt;
+    }
+    /**
+     * Main prepare method - Simplified and cleaner
+     */
+    async prepare(krillConfig = {}, ip = false, random = false, domain = '', suspend = false, small = false, none = false, crypted = false, pve = false, btrfs = false, testing = false, verbose = false) {
+        try {
+            // System validation
+            await this.checkSystemRequirements();
+            // Configuration setup
+            this.krillConfig = krillConfig;
+            await this.setupConfiguration();
+            // Stop services
+            await this.stopSystemServices(verbose, testing);
+            // Build configurations
+            const configs = await this.buildConfigurations(ip, random, suspend, small, none);
+            // Interactive or unattended mode
+            const finalConfigs = this.unattended
+                ? this.applyUnattendedOptions(configs, crypted, pve, btrfs)
+                : await this.runInteractiveMode(crypted, pve, btrfs);
+            // Install
+            await this.performInstallation(finalConfigs, domain, testing, verbose);
+        }
+        catch (error) {
+            await Utils.pressKeyToExit(`${error.message}\nkrill installer refuses to continue`);
+            process.exit();
+        }
+    }
+    /**
+     * Check system requirements (disks, LVM)
+     */
+    async checkSystemRequirements() {
+        // Check disk presence
+        const drives = shx.exec('lsblk |grep disk|cut -f 1 "-d "', { silent: true }).stdout.trim().split('\n');
+        if (drives[0] === '') {
+            throw new Error('No disk to install the system in this machine.');
+        }
+        // Check LVM presence
+        if (await this.pvExist()) {
+            await this.createLvmRemovalScript();
+            throw new Error('There is a lvm2 volume in the system, remove it manually before installation.');
+        }
+    }
+    /**
+     * Setup configuration files and auto-configure timezone
+     */
+    async setupConfiguration() {
+        // Check config file
+        if (!fs.existsSync(config_file)) {
+            throw new Error(`Cannot find configuration file ${config_file}`);
+        }
+        // Check calamares/krill configuration
+        let configRoot = '/etc/penguins-eggs.d/krill/';
+        if (fs.existsSync('/etc/calamares/settings.conf')) {
+            configRoot = '/etc/calamares/';
+        }
+        if (!fs.existsSync(configRoot + 'settings.conf')) {
+            throw new Error('Cannot find calamares/krill configuration file, please create it running: sudo eggs calamares');
+        }
+        // Auto-configure timezone
+        await this.autoConfigureTimezone();
+    }
+    /**
+     * Auto-configure timezone from internet
+     */
+    async autoConfigureTimezone() {
+        try {
+            const response = await axios.get('https://geoip.kde.org/v1/calamares');
+            if (response.statusText === 'OK') {
+                const timeZone = response.data.time_zone;
+                this.krillConfig.region = timeZone.substring(0, timeZone.indexOf('/'));
+                this.krillConfig.zone = timeZone.substring(timeZone.indexOf('/') + 1);
+            }
+        }
+        catch (error) {
+            console.error('Error auto-configuring timezone:', error);
+        }
+    }
+    /**
+     * Stop system services
+     */
+    async stopSystemServices(verbose, testing) {
+        const systemdCtl = new Systemctl(verbose);
+        if (await systemdCtl.isActive('udisks2.service') && !testing) {
+            await systemdCtl.stop('udisks2.service');
+        }
+    }
+    /**
+     * Build default configurations
+     */
+    async buildConfigurations(ip, random, suspend, small, none) {
+        // Generate hostname
+        const hostname = this.generateHostname(ip, random);
+        // Build configuration objects
+        const oWelcome = { language: this.krillConfig.language };
+        const oLocation = {
+            language: this.krillConfig.language,
+            region: this.krillConfig.region,
+            zone: this.krillConfig.zone
+        };
+        const oKeyboard = {
+            keyboardModel: this.krillConfig.keyboardModel,
+            keyboardLayout: this.krillConfig.keyboardLayout,
+            keyboardVariant: this.krillConfig.keyboardVariant,
+            keyboardOption: this.krillConfig.keyboardOption
+        };
+        let userSwapChoice = this.krillConfig.userSwapChoice;
+        if (suspend)
+            userSwapChoice = SwapChoice.Suspend;
+        else if (small)
+            userSwapChoice = SwapChoice.Small;
+        else if (none)
+            userSwapChoice = SwapChoice.None;
+        const oPartitions = {
+            installationDevice: this.krillConfig.installationDevice,
+            installationMode: this.krillConfig.installationMode,
+            filesystemType: this.krillConfig.filesystemType,
+            userSwapChoice,
+            replacedPartition: this.krillConfig.replacedPartition
+        };
+        const oUsers = {
+            username: this.krillConfig.name,
+            fullname: this.krillConfig.fullname,
+            password: this.krillConfig.password,
+            rootPassword: this.krillConfig.rootPassword,
+            autologin: this.krillConfig.autologin,
+            hostname
+        };
+        const oNetwork = {
+            iface: await Utils.iface(),
+            addressType: this.krillConfig.addressType,
+            address: Utils.address(),
+            netmask: Utils.netmask(),
+            gateway: Utils.gateway(),
+            dns: Utils.getDns(),
+            domain: Utils.getDomain()
+        };
+        return { oWelcome, oLocation, oKeyboard, oPartitions, oUsers, oNetwork };
+    }
+    /**
+     * Generate hostname based on options
+     */
+    generateHostname(ip, random) {
+        let hostname = this.krillConfig.hostname;
+        if (hostname === '') {
+            hostname = shx.exec('cat /etc/hostname', { silent: true }).trim();
+        }
+        if (ip) {
+            hostname = 'ip-' + Utils.address().replaceAll('.', '-');
+        }
+        if (random) {
+            const fl = shx.exec(`tr -dc a-z </dev/urandom | head -c 2 ; echo ''`, { silent: true }).trim();
+            const n = shx.exec(`tr -dc 0-9 </dev/urandom | head -c 3 ; echo ''`, { silent: true }).trim();
+            const sl = shx.exec(`tr -dc a-z </dev/urandom | head -c 2 ; echo ''`, { silent: true }).trim();
+            hostname = `${os.hostname()}-${fl}${n}${sl}`;
+        }
+        return hostname;
+    }
+    /**
+     * Apply options for unattended installation
+     */
+    applyUnattendedOptions(configs, crypted, pve, btrfs) {
+        const { oPartitions, oUsers } = configs;
+        // Set defaults for unattended
+        oPartitions.installationMode = InstallationMode.EraseDisk;
+        // Apply options
+        if (btrfs)
+            oPartitions.filesystemType = FsType.btrfs;
+        if (crypted || pve)
+            oPartitions.installationMode = InstallationMode.Luks;
+        // Set default installation device if empty
+        if (oPartitions.installationDevice === '') {
+            const drives = shx.exec('lsblk |grep disk|cut -f 1 "-d "', { silent: true }).stdout.trim().split('\n');
+            if (drives.length > 0) {
+                oPartitions.installationDevice = `/dev/` + drives[0];
+            }
+            else {
+                throw new Error("Unable to find installation drive");
+            }
+        }
+        return configs;
+    }
+    /**
+     * Run interactive mode with UI
+     */
+    async runInteractiveMode(crypted, pve, btrfs) {
+        const oWelcome = await this.welcome();
+        const oLocation = await this.location(oWelcome.language);
+        const oKeyboard = await this.keyboard();
+        const oPartitions = await this.partitions(this.krillConfig.installationDevice, crypted, pve, btrfs);
+        const oUsers = await this.users();
+        const oNetwork = await this.network();
+        return { oWelcome, oLocation, oKeyboard, oPartitions, oUsers, oNetwork };
+    }
+    /**
+     * Perform installation or testing
+     */
+    async performInstallation(configs, domain, testing, verbose) {
+        const { oLocation, oKeyboard, oPartitions, oUsers, oNetwork } = configs;
+        await this.summary(oLocation, oKeyboard, oPartitions, oUsers);
+        if (testing) {
+            console.log();
+            Utils.titles("install --testing");
+            console.log("Just testing krill, the process will end!");
+            console.log("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
+            console.log(oPartitions);
+            process.exit();
+        }
+        else {
+            const sequence = new Sequence(oLocation, oKeyboard, oPartitions, oUsers, oNetwork);
+            await sequence.start(domain, this.unattended, this.nointeractive, this.chroot, this.halt, verbose);
+        }
+    }
+    /**
+     * Create script to remove LVM partitions
+     */
+    async createLvmRemovalScript() {
+        const scriptName = "removeLvmPartitions";
+        let cmds = "#!/bin/bash\n";
+        cmds += `# remove LV (Logical Volumes)\n`;
+        cmds += `vg=$(vgs --noheadings -o vg_name| awk '{$1=$1};1')\n`;
+        cmds += `lvs -o lv_name --noheadings | awk '{$1=$1};1' | while read -r lv; do\n`;
+        cmds += ` lvremove -y /dev/mapper/$vg-$lv\n`;
+        cmds += `done\n`;
+        cmds += `\n`;
+        cmds += `# remove VG (Volume groups)\n`;
+        cmds += `vgremove --force $(vgs --noheadings -o vg_name $vg)\n`;
+        cmds += `\n`;
+        cmds += `# remove PV (Physical Volumes) \n`;
+        cmds += `pv=$(pvs --noheading -o pv_name | awk '{$1=$1};1')\n`;
+        cmds += `pvremove --force --force $pv\n`;
+        cmds += `# wipe PV (Physical Volumes) \n`;
+        cmds += `wipefs -a $pv\n`;
+        cmds += `# clean device\n`;
+        cmds += `sgdisk --zap-all $pv\n`;
+        cmds += `dd if=/dev/zero of=$pv bs=1M count=10\n`;
+        fs.writeFileSync(scriptName, cmds);
+        await exec(`chmod +x ${scriptName}`);
+    }
+    /**
+     * Check if Physical Volumes exist
+     */
+    async pvExist() {
+        const check = `#!/bin/sh\npvdisplay |grep "PV Name" >/dev/null && echo 1|| echo 0`;
+        return shx.exec(check, { silent: true }).stdout.trim() === '1';
+    }
+}
+/**
+ * Utility function for netmask conversion
+ */
+function netmask2CIDR(mask) {
+    const countCharOccurences = (string, char) => string.split(char).length - 1;
+    const decimalToBinary = (dec) => (dec >>> 0).toString(2);
+    const getNetMaskParts = (nmask) => nmask.split('.').map(Number);
+    return countCharOccurences(getNetMaskParts(mask)
+        .map(part => decimalToBinary(part))
+        .join(''), '1');
+}

package/dist/krill/classes/sequence.d/add_user.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ./src/krill/modules/add-user.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ * https://stackoverflow.com/questions/23876782/how-do-i-split-a-typescript-class-into-multiple-files
+ */
+import Sequence from '../sequence.js';
+/**
+ *
+ * @param this
+ * @param name
+ * @param password
+ * @param fullName
+ * @param roomNumber
+ * @param workPhone
+ * @param homePhone
+ */
+export default function addUser(this: Sequence, name?: string, password?: string, fullName?: string, roomNumber?: string, workPhone?: string, homePhone?: string): Promise<void>;

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

@@ -0,0 +1,66 @@
+/**
+ * ./src/krill/modules/add-user.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ * https://stackoverflow.com/questions/23876782/how-do-i-split-a-typescript-class-into-multiple-files
+ */
+import fs from 'fs';
+import yaml from 'js-yaml';
+import { exec } from '../../../lib/utils.js';
+/**
+ *
+ * @param this
+ * @param name
+ * @param password
+ * @param fullName
+ * @param roomNumber
+ * @param workPhone
+ * @param homePhone
+ */
+export default async function addUser(name = 'live', password = 'evolution', fullName = '', roomNumber = '', workPhone = '', homePhone = '') {
+    // adduser user
+    let cmd = `chroot ${this.installTarget} adduser ${name} --home /home/${name} --shell /bin/bash --disabled-password --gecos "${fullName},${roomNumber},${workPhone},${homePhone}" ${this.toNull}`;
+    if (this.distro.familyId === 'archlinux') {
+        cmd = `chroot ${this.installTarget} useradd --create-home --shell /bin/bash ${name} ${this.toNull}`;
+    }
+    else if (this.distro.familyId === 'fedora') {
+        cmd = `chroot ${this.installTarget} adduser ${name} --create-home --shell /bin/bash --comment "${fullName},${roomNumber},${workPhone},${homePhone}" ${this.toNull}`;
+    }
+    else if (this.distro.familyId === 'opensuse') {
+        cmd = `chroot ${this.installTarget} useradd ${name} --create-home --shell /bin/bash --comment "${fullName},${roomNumber},${workPhone},${homePhone}" ${this.toNull}`;
+    }
+    await exec(cmd, this.echo);
+    // chpasswd user
+    cmd = `echo ${name}:${password} | chroot ${this.installTarget} chpasswd ${this.toNull}`;
+    await exec(cmd, this.echo);
+    let group = 'wheel';
+    if (this.distro.familyId === 'debian') {
+        /**
+         * look to calamares/modules/users.yml for groups
+         */
+        let usersConf = '/etc/calamares/modules/users.conf';
+        if (!fs.existsSync(usersConf)) {
+            usersConf = '/etc/penguins-eggs.d/krill/modules/users.conf';
+        }
+        if (fs.existsSync(usersConf)) {
+            const o = yaml.load(fs.readFileSync(usersConf, 'utf8'));
+            for (const group of o.defaultGroups) {
+                cmd = `chroot ${this.installTarget} usermod -aG ${group} ${name} ${this.toNull}`;
+                await exec(cmd, this.echo);
+            }
+        }
+        else {
+            group = 'sudo';
+        }
+        cmd = `chroot ${this.installTarget} usermod -aG ${group} ${name} ${this.toNull}`;
+        await exec(cmd, this.echo);
+    }
+    // add autologin group in archlinux
+    await exec(cmd, this.echo);
+    if (this.distro.familyId === 'archlinux') {
+        await exec(`chroot ${this.installTarget} getent group autologin || groupadd autologin`);
+        await exec(`chroot ${this.installTarget} gpasswd -a ${this.settings.config.user_opt} autologin`);
+    }
+}

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

@@ -0,0 +1,14 @@
+/**
+ * ./src/krill/modules/bootloader.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ * https://stackoverflow.com/questions/23876782/how-do-i-split-a-typescript-class-into-multiple-files
+ */
+import Sequence from '../../classes/sequence.js';
+/**
+ *
+ * @param this
+ */
+export default function bootloader(this: Sequence): Promise<void>;

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

@@ -0,0 +1,95 @@
+/**
+ * ./src/krill/modules/bootloader.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ * https://stackoverflow.com/questions/23876782/how-do-i-split-a-typescript-class-into-multiple-files
+ */
+import Diversion from '../../../classes/diversions.js';
+import Utils from '../../../classes/utils.js';
+import { exec } from '../../../lib/utils.js';
+import fs from 'node:fs';
+import path from 'node:path';
+/**
+ *
+ * @param this
+ */
+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
+     */
+    let cmd = `chroot ${this.installTarget} ${grubName}-install ${this.partitions.installationDevice} ${grubForce} ${this.toNull}`;
+    await exec(cmd, this.echo);
+    /**
+     * grub-mkconfig
+     */
+    cmd = `chroot ${this.installTarget} ${grubName}-mkconfig -o /boot/${grubName}/grub.cfg ${this.toNull}`;
+    await exec(cmd, this.echo);
+    /**
+     * In fedora family, we need to call kernel-install to force entry creation
+     */
+    if (this.distro.familyId === "fedora") {
+        /**
+         * create grub2 entries
+         *
+         */
+        cmd = `chroot ${this.installTarget} kernel-install add $(uname -r) /boot/vmlinuz-$(uname -r)`;
+        await exec(cmd, this.echo);
+        /**
+         * and not only: on RHEL, Almalinux, Rocky it take UUID from janitor
+         */
+        if (this.distro.distroId === "Almalinux" || this.distro.distroId === "Rocky") {
+            /**
+             * grub2: adapt entries at new system
+             */
+            const rootUUID = Utils.uuid(this.devices.root.name);
+            const resumeUUID = Utils.uuid(this.devices.swap.name);
+            await updateEntries(this.installTarget, rootUUID, resumeUUID);
+        }
+    }
+}
+/**
+ *
+ * @param installTarget
+ * @param rootUUID
+ * @param resumeUUID
+ */
+async function updateEntries(installTarget, rootUUID, resumeUUID) {
+    const entriesPath = path.join(installTarget, `/boot/loader/entries/`);
+    const entries = fs.readdirSync(entriesPath);
+    if (entries.length > 0) {
+        for (const entry of entries) {
+            const currentEntry = path.join(entriesPath, entry);
+            let source = fs.readFileSync(currentEntry, 'utf8');
+            let lines = source.split('\n');
+            let content = '';
+            for (let line of lines) {
+                line = searchAndReplace(line, 'root=UUID=', rootUUID);
+                line = searchAndReplace(line, 'resume=UUID=', resumeUUID);
+                content += line + '\n';
+            }
+            fs.writeFileSync(`${currentEntry}`, content, 'utf-8');
+        }
+    }
+}
+/**
+ *
+ * @param line
+ * @param search
+ * @param replace
+ * @returns
+ */
+function searchAndReplace(line, search, replace) {
+    if (line.includes(search)) {
+        const lenSearch = search.length;
+        const lenReplace = replace.length;
+        const at = line.indexOf(search);
+        const first = line.substring(0, at + lenSearch);
+        const last = line.substring(at + lenSearch + lenReplace);
+        line = first + replace + last;
+    }
+    return line;
+}

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

@@ -0,0 +1,14 @@
+/**
+ * ./src/krill/modules/bootloader-config.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ * https://stackoverflow.com/questions/23876782/how-do-i-split-a-typescript-class-into-multiple-files
+ */
+import Sequence from '../sequence.js';
+/**
+ *
+ * @param this
+ */
+export default function bootloaderConfig(this: Sequence): Promise<void>;

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

@@ -0,0 +1,165 @@
+/**
+ * ./src/krill/modules/bootloader-config.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ * https://stackoverflow.com/questions/23876782/how-do-i-split-a-typescript-class-into-multiple-files
+ */
+import Utils from '../../../classes/utils.js';
+import { exec } from '../../../lib/utils.js';
+/**
+ *
+ * @param this
+ */
+export default async function bootloaderConfig() {
+    let cmd = '';
+    /**
+       * aldos
+       */
+    if (this.distro.familyId === 'aldos') {
+        if (this.efi) {
+            try {
+                cmd = `chroot ${this.installTarget} yum install grub2 grub2-efi-x64 efibootmgr} ${this.toNull}`;
+                await exec(cmd, this.echo);
+            }
+            catch (error) {
+                await showError(cmd, error);
+            }
+        }
+        else {
+            try {
+                cmd = `chroot ${this.installTarget} yum install grub2 grub2-pc ${this.toNull}`;
+                await exec(cmd, this.echo);
+            }
+            catch (error) {
+                await showError(cmd, error);
+            }
+        }
+        /**
+       * alpine
+       */
+    }
+    else if (this.distro.familyId === 'alpine') {
+        if (this.efi) {
+            try {
+                cmd = `chroot ${this.installTarget} apk add grub grub-efi efibootmgr} ${this.toNull}`;
+                await exec(cmd, this.echo);
+            }
+            catch (error) {
+                await showError(cmd, error);
+            }
+        }
+        else {
+            try {
+                cmd = `chroot ${this.installTarget} apk add grub grub-bios ${this.toNull}`;
+                await exec(cmd, this.echo);
+            }
+            catch (error) {
+                await showError(cmd, error);
+            }
+        }
+        /**
+         * archlinux
+         */
+    }
+    else if (this.distro.familyId === 'archlinux') {
+        if (this.efi) {
+            try {
+                cmd = `chroot ${this.installTarget} pacman -Sy grub efibootmgr} ${this.toNull}`;
+                await exec(cmd, this.echo);
+            }
+            catch (error) {
+                await showError(cmd, error);
+            }
+        }
+        else {
+            try {
+                cmd = `chroot ${this.installTarget} pacman -Sy grub ${this.toNull}`;
+                await exec(cmd, this.echo);
+            }
+            catch (error) {
+                await showError(cmd, error);
+            }
+        }
+        /**
+         * debian
+         */
+    }
+    else if (this.distro.familyId === 'debian') {
+        try {
+            cmd = `chroot ${this.installTarget} apt-get -y update ${this.toNull}`;
+            await exec(cmd, this.echo);
+        }
+        catch (error) {
+            await showError(cmd, error);
+        }
+        await exec('sleep 1', this.echo);
+        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}`;
+                await exec(cmd, this.echo);
+            }
+            catch (error) {
+                await showError(cmd, error);
+            }
+        }
+        else {
+            try {
+                cmd = `chroot ${this.installTarget} ${aptInstallOptions} grub-pc ${this.toNull}`;
+                await exec(cmd, this.echo);
+            }
+            catch (error) {
+                await showError(cmd, error);
+            }
+        }
+        /**
+         * fedora/openmamba
+         */
+    }
+    else if (this.distro.familyId === 'fedora' || this.distro.familyId === 'openmamba') {
+        if (this.efi) {
+            try {
+                cmd = `chroot ${this.installTarget} dnf -y install grub2 grub2-efi-x64 efibootmgr shim ${this.toNull}`;
+                await exec(cmd, this.echo);
+            }
+            catch (error) {
+                await showError(cmd, error);
+            }
+        }
+        else {
+            try {
+                cmd = `chroot ${this.installTarget} dnf -y install grub2 grub2-pc ${this.toNull}`;
+                await exec(cmd, this.echo);
+            }
+            catch (error) {
+                await showError(cmd, error);
+            }
+        }
+        /**
+         * opensuse
+         */
+    }
+    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}`;
+                await exec(cmd, this.echo);
+            }
+            catch (error) {
+                await showError(cmd, error);
+            }
+        }
+    }
+}
+/**
+ *
+ * @param cmd
+ * @param error
+ */
+async function showError(cmd, error) {
+    console.log('error:', error);
+    console.log(cmd);
+    await Utils.pressKeyToExit(cmd, true);
+}