penguins-eggs 10.0.53 → 10.0.54

package/dist/krill/modules/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 update -y ${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 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} dnf 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);
+}

package/dist/krill/modules/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 '../sequence.js';
+/**
+ *
+ * @param this
+ */
+export default function bootloader(this: Sequence): Promise<void>;

package/dist/krill/modules/bootloader.js

@@ -0,0 +1,157 @@
+/**
+ * ./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() {
+    /**
+     * GRUB
+     */
+    let grubName = Diversion.grubName(this.distro.familyId);
+    let cmd = `chroot ${this.installTarget} ${grubName}-install ${this.partitions.installationDevice} ${this.toNull}`;
+    try {
+        await exec(cmd, this.echo);
+    }
+    catch (error) {
+        await showError(cmd, error);
+    }
+    cmd = `chroot ${this.installTarget} ${grubName}-mkconfig -o /boot/${grubName}/grub.cfg ${this.toNull}`;
+    try {
+        await exec(cmd, this.echo);
+    }
+    catch (error) {
+        await showError(cmd, error);
+    }
+    /**
+     * create entries in /boot/efi/loader/entries
+     * cp vmlinuz initrams in /boot/efi
+     */
+    // update boot/loader/entries/
+    const pathEntries = path.join(this.installTarget, '/boot/loader/entries/');
+    if (fs.existsSync(pathEntries)) {
+        const uuid = Utils.uuid(this.devices.root.name);
+        const machineId = fs.readFileSync(path.join(this.installTarget, '/etc/machine-id'), 'utf-8').trim();
+        await renameLoaderEntries(pathEntries, machineId);
+        await updateLoaderEntries(pathEntries, machineId, uuid);
+    }
+    /**
+     * SYSTEMD-BOOT
+     */
+    if (Diversion.isSystemDBoot(this.distro.familyId, this.efi)) {
+        // bootctl install
+        await exec(`chroot ${this.installTarget} bootctl --path /boot/efi/ install`, this.echo);
+        let vmlinuz = path.basename(Utils.vmlinuz());
+        let initrdImg = path.basename(Utils.initrdImg());
+        await exec(`cp /boot/${vmlinuz} ${this.installTarget}/boot/efi`, this.echo);
+        await exec(`cp /boot/${initrdImg} ${this.installTarget}/boot/efi`, this.echo);
+        // create entries
+        let content = ``;
+        content += `title   Linux\n`;
+        content += `linux   /${vmlinuz}\n`;
+        content += `initrd  /${initrdImg}\n`;
+        content += `options root=${this.devices.root.name} rw\n`;
+        await exec(`mkdir ${this.installTarget}/boot/efi/loader/entries/ -p`);
+        fs.writeFileSync(`${this.installTarget}/boot/efi/loader/entries/linux.conf`, content);
+        // bootctl update
+        await exec(`chroot ${this.installTarget} bootctl update`, this.echo);
+    }
+}
+/**
+ *
+ * @param directoryPath
+ * @param machineId
+ */
+async function renameLoaderEntries(directoryPath, machineId) {
+    const files = fs.readdirSync(directoryPath);
+    if (files.length > 0) {
+        for (const file of files) {
+            if (file.length > 32) {
+                const oldEntry = path.join(directoryPath, file);
+                let current = file.substring(32);
+                current = machineId + current;
+                const newEntry = path.join(directoryPath, current);
+                const cmd = `mv ${oldEntry} ${newEntry}`;
+                try {
+                    await exec(cmd);
+                }
+                catch (error) {
+                    await showError(cmd, error);
+                }
+            }
+        }
+    }
+}
+/**
+ *
+ * @param directoryPath
+ * @param newUUID
+ */
+async function updateLoaderEntries(directoryPath, machineId, newUUID) {
+    const files = fs.readdirSync(directoryPath);
+    if (files.length > 0) {
+        for (const file of files) {
+            const filePath = path.join(directoryPath, file);
+            let source = fs.readFileSync(filePath, 'utf8');
+            let lines = source.split('\n');
+            let content = '';
+            for (let line of lines) {
+                /**
+                 * REPLACE root=UUID=
+                 */
+                if (line.includes('root=UUID=')) {
+                    const at = line.indexOf('root=UUID=');
+                    const start = line.substring(0, at + 10);
+                    const stop = line.substring(at + 10 + 36);
+                    line = start + newUUID + stop;
+                }
+                /**
+                 * REMOVE resume=UUID=
+                 */
+                if (line.includes('resume=UUID=')) {
+                    const at = line.indexOf('resume=UUID=');
+                    const start = line.substring(0, at - 1);
+                    line = start;
+                }
+                /**
+                 * REPLACE machineId
+                 */
+                // version 0-rescue-
+                if (line.includes('version 0-rescue-')) {
+                    line = `version 0-rescue-${machineId}`;
+                }
+                // linux /boot/vmlinuz-0-rescue-
+                if (line.includes('vmlinuz-0-rescue-')) {
+                    line = `vmlinuz-0-rescue-${machineId}`;
+                }
+                // initrd /boot/initramfs-0-rescue-
+                if (line.includes('initrd /boot/initramfs-0-rescue-')) {
+                    line = `initrd /boot/initramfs-0-rescue-${machineId}.img`;
+                }
+                content += line + '\n';
+            }
+            fs.writeFileSync(filePath, content);
+        }
+    }
+}
+/**
+ *
+ * @param cmd
+ * @param error
+ */
+async function showError(cmd, error) {
+    console.log('error:', error);
+    console.log(cmd);
+    await Utils.pressKeyToExit(cmd, true);
+}

package/dist/krill/modules/change-password.d.ts

@@ -0,0 +1,15 @@
+/**
+ * ./src/krill/modules/change-password.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';
+/**
+ * changePassword
+ * @param name
+ * @param newPassword
+ */
+export default function changePassword(this: Sequence, name?: string, newPassword?: string): Promise<void>;

package/dist/krill/modules/change-password.js

@@ -0,0 +1,18 @@
+/**
+ * ./src/krill/modules/change-password.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 { exec } from '../../lib/utils.js';
+/**
+ * changePassword
+ * @param name
+ * @param newPassword
+ */
+export default async function changePassword(name = 'live', newPassword = 'evolution') {
+    const cmd = `echo ${name}:${newPassword} | chroot ${this.installTarget} chpasswd ${this.toNull}`;
+    await exec(cmd, this.echo);
+}

package/dist/krill/modules/del-live-user.d.ts

@@ -0,0 +1,14 @@
+/**
+ * ./src/krill/modules/del-live-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';
+/**
+ * delUser
+ * va corretto con users.conf di calamares
+ */
+export default function delLiveUser(this: Sequence): Promise<void>;

package/dist/krill/modules/del-live-user.js

@@ -0,0 +1,39 @@
+/**
+ * ./src/krill/modules/del-live-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 Utils from '../../classes/utils.js';
+import { exec } from '../../lib/utils.js';
+/**
+ * delUser
+ * va corretto con users.conf di calamares
+ */
+export default async function delLiveUser() {
+    if (Utils.isLive()) {
+        const user = this.settings.config.user_opt;
+        let userExists = false;
+        try {
+            const cmd = `#!/bin/sh\ngetent passwd "${user}"  > /dev/null`;
+            await exec(cmd, Utils.setEcho(this.verbose));
+            userExists = true;
+        }
+        catch (error) {
+            console.log(error);
+        }
+        finally {
+            if (userExists) {
+                let cmd = `chroot ${this.installTarget} deluser --remove-home ${user} ${this.toNull}`;
+                if (this.distro.familyId === 'archlinux' ||
+                    this.distro.familyId === 'fedora' ||
+                    this.distro.familyId === 'opensuse') {
+                    cmd = `chroot ${this.installTarget} sudo userdel -r ${user} ${this.toNull}`;
+                }
+                await exec(cmd, this.echo);
+            }
+        }
+    }
+}

package/dist/krill/modules/fstab.d.ts

@@ -0,0 +1,14 @@
+/**
+ * ./src/krill/modules/fstab.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';
+/**
+ * fstab()
+ * @param devices
+ */
+export default function fstab(this: Sequence, installDevice: string, crypted?: boolean): Promise<void>;

package/dist/krill/modules/fstab.js

@@ -0,0 +1,123 @@
+/**
+ * ./src/krill/modules/fstab.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 shx from 'shelljs';
+import Pacman from '../../classes/pacman.js';
+import Utils from '../../classes/utils.js';
+/**
+ * fstab()
+ * @param devices
+ */
+export default async function fstab(installDevice, crypted = false) {
+    let text = '';
+    /**
+     * crypttab
+     */
+    if (this.partitions.installationMode === 'full-encrypted') {
+        const crypttab = this.installTarget + '/etc/crypttab';
+        text += '# /etc/crypttab: mappings for encrypted partitions.\n';
+        text += '#\n';
+        text += '# Each mapped device will be created in /dev/mapper, so your /etc/fstab\n';
+        text += '# should use the /dev/mapper/<name> paths for encrypted devices.\n';
+        text += '#\n';
+        text += '# See crypttab(5) for the supported syntax.\n';
+        text += '#\n';
+        text += '# NOTE: You need not list your root (/) partition here, but it must be set up\n';
+        text += '#       beforehand by the initramfs (/etc/mkinitcpio.conf). The same applies\n';
+        text += '#       to encrypted swap, which should be set up with mkinitcpio-openswap\n';
+        text += '#       for resume support.\n';
+        text += '#\n';
+        text += '# <name>               <device>                         <password> <options>\n';
+        text += `#swap_crypted was ${this.devices.swap.cryptedFrom}\n`;
+        text += `swap_crypted UUID=${Utils.uuid(this.devices.swap.cryptedFrom)} none luks,discard\n`;
+        text += `#root_crypted was ${this.devices.root.cryptedFrom}\n`;
+        text += `root_crypted UUID=${Utils.uuid(this.devices.root.cryptedFrom)} none luks,swap\n`;
+        Utils.write(crypttab, text);
+    }
+    /**
+     * fstab
+     */
+    if (!Pacman.packageIsInstalled('btrfs-progs')) {
+        this.partitions.filesystemType === 'ext4';
+    }
+    const fstab = this.installTarget + '/etc/fstab';
+    let mountOptsRoot = '';
+    let mountOptsBoot = '';
+    let mountOptsData = '';
+    let mountOptsEfi = '';
+    let mountOptsSwap = '';
+    if (this.partitions.filesystemType === 'ext4') {
+        if (await isRotational(installDevice)) {
+            mountOptsRoot = 'defaults,relatime 0 1';
+            mountOptsBoot = 'defaults,relatime 0 1';
+            mountOptsData = 'defaults,relatime 0 1';
+            mountOptsEfi = 'defaults,relatime 0 2';
+            mountOptsSwap = 'defaults,relatime 0 2';
+        }
+        else {
+            mountOptsRoot = 'defaults,noatime 0 1';
+            mountOptsBoot = 'defaults,noatime 0 1';
+            mountOptsData = 'defaults,noatime 0 1';
+            mountOptsEfi = 'defaults,noatime 0 2';
+            mountOptsSwap = 'defaults,noatime 0 2';
+        }
+        text = '';
+        text += `# ${this.devices.root.name} ${this.devices.root.mountPoint} ${this.devices.root.fsType} ${mountOptsRoot}\n`;
+        text += `UUID=${Utils.uuid(this.devices.root.name)} ${this.devices.root.mountPoint} ${this.devices.root.fsType} ${mountOptsRoot}\n`;
+        if (this.devices.boot.name !== 'none') {
+            text += `# ${this.devices.boot.name} ${this.devices.boot.mountPoint} ${this.devices.boot.fsType} ${mountOptsBoot}\n`;
+            text += `UUID=${Utils.uuid(this.devices.boot.name)} ${this.devices.boot.mountPoint} ${this.devices.root.fsType} ${mountOptsBoot}\n`;
+        }
+        if (this.devices.data.name !== 'none') {
+            text += `# ${this.devices.data.name} ${this.devices.data.mountPoint} ${this.devices.data.fsType} ${mountOptsData}\n`;
+            text += `UUID=${Utils.uuid(this.devices.data.name)} ${this.devices.data.mountPoint} ${this.devices.data.fsType} ${mountOptsData}\n`;
+        }
+        if (this.efi) {
+            text += `# ${this.devices.efi.name} ${this.devices.efi.mountPoint} vfat ${mountOptsEfi}\n`;
+            text += `UUID=${Utils.uuid(this.devices.efi.name)} ${this.devices.efi.mountPoint} vfat ${mountOptsEfi}\n`;
+        }
+        text += `# ${this.devices.swap.name} ${this.devices.swap.mountPoint} ${this.devices.swap.fsType} ${mountOptsSwap}\n`;
+        text += `UUID=${Utils.uuid(this.devices.swap.name)} ${this.devices.swap.mountPoint} ${this.devices.swap.fsType} ${mountOptsSwap}\n`;
+    }
+    else if (this.partitions.filesystemType === 'btrfs') {
+        const base = '/        btrfs  subvol=/@,defaults 0 0';
+        const snapshots = '/.snapshots               btrfs  subvol=/@snapshots,defaults 0 0';
+        const home = '/home                     btrfs  subvol=/@home,defaults 0 0';
+        const root = '/root                     btrfs  subvol=/@root,defaults 0 0';
+        const var_log = '/var/log                  btrfs  subvol=/@var@log,defaults 0 0';
+        const var_lib_AccountsService = '/var/lib/AccountsService  btrfs  subvol=/@var@lib@AccountsService,defaults 0 0';
+        const var_lib_blueman = '/var/lib/blueman          btrfs  subvol=/@var@lib@blueman,defaults 0 0';
+        const tmp = '/tmp                      btrfs  subvol=/@tmp,defaults 0 0';
+        text += `# ${this.devices.root.name}  btrfs ${this.devices.root.mountPoint} subvol\n`;
+        text += `UUID=${Utils.uuid(this.devices.root.name)} ${base}\n`;
+        text += `# UUID=${Utils.uuid(this.devices.root.name)} ${snapshots}\n`;
+        text += `# UUID=${Utils.uuid(this.devices.root.name)} ${home}\n`;
+        text += `# UUID=${Utils.uuid(this.devices.root.name)} ${root}\n`;
+        text += `# UUID=${Utils.uuid(this.devices.root.name)} ${var_log}\n`;
+        text += `# UUID=${Utils.uuid(this.devices.root.name)} ${var_lib_AccountsService}\n`;
+        text += `# UUID=${Utils.uuid(this.devices.root.name)} ${var_lib_blueman}\n`;
+        text += `# UUID=${Utils.uuid(this.devices.root.name)} ${tmp}\n`;
+    }
+    //console.log(text)
+    //Utils.pressKeyToExit()
+    Utils.write(fstab, text);
+}
+/**
+ * isRotational
+ * @param device
+ */
+async function isRotational(device) {
+    device = device.slice(4);
+    let response;
+    let retVal = false;
+    response = shx.exec(`cat /sys/block/${device}/queue/rotational`, { silent: true }).stdout.trim();
+    if (response === '1') {
+        retVal = true;
+    }
+    return retVal;
+}

package/dist/krill/modules/grubcfg.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ./src/krill/modules/grubcfg.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';
+/**
+ * grubcfg
+ * - open /etc/default/grub
+ * - find GRUB_CMDLINE_LINUX_DEFAULT=
+ * - replace with GRUB_CMDLINE_LINUX_DEFAULT=
+ * 's/GRUB_CMDLINE_LINUX_DEFAULT=.*$/GRUB_CMDLINE_LINUX_DEFAULT=/g'
+ */
+export default function grubcfg(this: Sequence): Promise<void>;

package/dist/krill/modules/grubcfg.js

@@ -0,0 +1,29 @@
+/**
+ * ./src/krill/modules/grubcfg.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 'node:fs';
+import Utils from '../../classes/utils.js';
+/**
+ * grubcfg
+ * - open /etc/default/grub
+ * - find GRUB_CMDLINE_LINUX_DEFAULT=
+ * - replace with GRUB_CMDLINE_LINUX_DEFAULT=
+ * 's/GRUB_CMDLINE_LINUX_DEFAULT=.*$/GRUB_CMDLINE_LINUX_DEFAULT=/g'
+ */
+export default async function grubcfg() {
+    const file = `${this.installTarget}/etc/default/grub`;
+    let content = '';
+    const grubs = fs.readFileSync(file, 'utf8').split('\n');
+    for (let i = 0; i < grubs.length; i++) {
+        if (grubs[i].includes('GRUB_CMDLINE_LINUX_DEFAULT=')) {
+            grubs[i] = this.partitions.installationMode === 'full-encrypted' ? `GRUB_CMDLINE_LINUX_DEFAULT="resume=UUID=${Utils.uuid(this.devices.swap.name)}"` : `GRUB_CMDLINE_LINUX_DEFAULT="quiet splash resume=UUID=${Utils.uuid(this.devices.swap.name)}"`;
+        }
+        content += grubs[i] + '\n';
+    }
+    fs.writeFileSync(file, content, 'utf-8');
+}

package/dist/krill/modules/hostname.d.ts

@@ -0,0 +1,13 @@
+/**
+ * ./src/krill/modules/hostnames.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';
+/**
+ * hostname
+ */
+export default function hostname(this: Sequence, domain?: string): Promise<void>;

package/dist/krill/modules/hostname.js

@@ -0,0 +1,50 @@
+/**
+ * ./src/krill/modules/hostnames.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 'node:fs';
+/**
+ * hostname
+ */
+export default async function hostname(domain = '') {
+    const { hostname } = this.users;
+    /**
+     * hostname
+     */
+    {
+        const file = this.installTarget + '/etc/hostname';
+        const text = hostname;
+        fs.writeFileSync(file, text);
+    }
+    /**
+     * hosts
+     */
+    {
+        const file = this.installTarget + '/etc/hosts';
+        if (domain === '(none)') {
+            domain = '';
+        }
+        let text = '127.0.0.1 localhost localhost.localdomain\n';
+        if (this.network.addressType === 'static') {
+            text += `${this.network.address} ${hostname} ${hostname}${domain} pvelocalhost pvelocalhost.pvelocaldomain\n`;
+        }
+        else if (domain === '') {
+            text += `127.0.1.1 ${hostname}\n`;
+        }
+        else {
+            text += `127.0.1.1 ${hostname} ${hostname}${domain}\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';
+        fs.writeFileSync(file, text);
+    }
+}