penguins-eggs 10.1.0 → 10.1.1

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

@@ -0,0 +1,58 @@
+/**
+ * ./src/krill/modules/locale-cfg.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';
+/* localeCfg
+ * Enable the configured locales (those set by the user on the
+ * user page) in /etc/locale.gen, if they are available in the
+ * target system.
+ */
+export default async function localeCfg() {
+    /**
+     * influence: - locale-gen
+     */
+    let supporteds = [];
+    if (this.distro.familyId === 'debian') {
+        // Format: en_US.UTF-8 UTF-8
+        supporteds = fs.readFileSync('/usr/share/i18n/SUPPORTED', 'utf8').split('\n');
+    }
+    else if (this.distro.familyId === 'archlinux') {
+        const supportedsSource = fs.readFileSync('/etc/locale.gen', 'utf8').split('\n');
+        for (let line of supportedsSource) {
+            if (line.slice(0, 2) !== '# ') {
+                // se non è un commento
+                line = line.slice(1); // Rimuove #
+            }
+            supporteds.push(line);
+        }
+    }
+    const localeGenSource = fs.readFileSync(`${this.installTarget}/etc/locale.gen`, 'utf8').split('\n');
+    let localeGenDest = '';
+    const krillBookmark = '#   Locales enabled by krill\n';
+    for (const line of localeGenSource) {
+        if (line.includes(krillBookmark)) {
+            break;
+        }
+        localeGenDest += line + '\n';
+    }
+    localeGenDest += '\n';
+    localeGenDest += krillBookmark;
+    const locales = [];
+    if (this.language !== 'en_US.UTF-8') {
+        locales.push('en_US.UTF-8');
+    }
+    locales.push(this.language);
+    for (const supported of supporteds) {
+        for (const locale of locales) {
+            if (supported.includes(locale)) {
+                localeGenDest += `${supported}\n`;
+            }
+        }
+    }
+    fs.writeFileSync(`${this.installTarget}/etc/locale.gen`, localeGenDest);
+}

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

@@ -0,0 +1,14 @@
+/**
+ * ./src/krill/modules/m-keyboard.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 mKeyboard(this: Sequence): Promise<void>;

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

@@ -0,0 +1,58 @@
+/**
+ * ./src/krill/modules/m-keyboard.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';
+import { exec } from '../../../lib/utils.js';
+/**
+ *
+ * @param this
+ */
+export default async function mKeyboard() {
+    /**
+     * influence: - /etc/default/keyboard (console)
+     *            - /etc/X11/xorg.conf.d/00-keyboard.conf
+     *            - /ext/vconsole.conf (non systemd)
+     */
+    if (this.distro.familyId === 'archlinux' || this.distro.familyId === 'debian' || this.distro.familyId === 'fedora') {
+        let cmd = '';
+        let content = '';
+        if (Utils.isSystemd()) {
+            cmd = `chroot ${this.installTarget} localectl set-keymap ${this.keyboardLayout} ${this.toNull}`;
+            content = '# See penguins-eggs/src/krill/modules/set-keyboard.ts\n\n';
+            content += "# Read and parsed by systemd-localed. It's probably wise not to edit this file\n";
+            content += '# manually too freely.\n';
+            content += 'Section "InputClass"\n';
+            content += '        Identifier "system-keyboard"\n';
+            content += '        MatchIsKeyboard "on"\n';
+            content += '        Option "XkbLayout" "' + this.keyboardLayout + '"\n';
+            content += 'EndSection\n';
+            if (fs.existsSync(this.installTarget + '/etc/X11/xorg.conf.d')) {
+                Utils.write(this.installTarget + '/etc/X11/xorg.conf.d/00-keyboard.conf', content);
+            }
+        }
+        else {
+            /**
+             * configuro vconsole.conf
+             */
+            cmd = `chroot ${this.installTarget} setupcon ${this.toNull}`;
+            content = '# See penguins-eggs/src/krill/modules/set-keyboard.ts\n\n';
+            content += 'KEYMAP="' + this.keyboardLayout + '"\n';
+            content += 'FONT=\n';
+            content += 'FONT_MAP=\n';
+            Utils.write(this.installTarget + '/etc/vconsole.conf', content);
+        }
+        await exec(cmd, this.echo);
+    }
+    else if (this.distro.familyId === 'alpine') {
+        /**
+        * Alpine dovrebbe fare tutto con `setup-keymap us us`
+        */
+        await exec(`chroot ${this.installTarget} setup-keymap ${this.keyboardLayout} ${this.keyboardLayout}`);
+    }
+}

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

@@ -0,0 +1,15 @@
+/**
+ * penguins-eggs
+ * krill modules: machine-id.ts
+ * 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';
+/**
+ * On Ubuntu
+ * /etc/machine-id must exist to be re-created
+ * https://unix.stackexchange.com/questions/402999/is-it-ok-to-change-etc-machine-id
+ */
+export default function machineId(this: Sequence): Promise<void>;

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

@@ -0,0 +1,33 @@
+/**
+ * penguins-eggs
+ * krill modules: machine-id.ts
+ * 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 { exec } from '../../../lib/utils.js';
+import Utils from '../../../classes/utils.js';
+/**
+ * On Ubuntu
+ * /etc/machine-id must exist to be re-created
+ * https://unix.stackexchange.com/questions/402999/is-it-ok-to-change-etc-machine-id
+ */
+export default async function machineId() {
+    // We delete the machine-id file to force its recreation
+    const file = `${this.installTarget}/etc/machine-id`;
+    if (fs.existsSync(file)) {
+        await exec(`rm ${file} ${this.toNull}`, this.echo);
+    }
+    /**
+     * machine/id ALWAYS new
+     */
+    if (Utils.isSystemd()) {
+        await exec(`chroot ${this.installTarget} systemd-machine-id-setup`);
+    }
+    else {
+        await exec(`chroot ${this.installTarget} dbus-uuidgen --ensure=/var/lib/dbus/machine-id ${this.toNull}`);
+        await exec(`chroot ${this.installTarget} cp /var/lib/dbus/machine-id /etc/machine-id`);
+    }
+}

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

@@ -0,0 +1,15 @@
+/**
+ * ./src/krill/modules/mkfs.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';
+/**
+ * mkfs
+ *
+ * mke2fs - create an ext2/ext3/ext4 file system -F force, -t type
+ */
+export default function mkfs(this: Sequence): Promise<boolean>;

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

@@ -0,0 +1,72 @@
+/**
+ * ./src/krill/modules/mkfs.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';
+import { InstallationMode, SwapChoice } from '../krill_enums.js';
+/**
+ * mkfs
+ *
+ * mke2fs - create an ext2/ext3/ext4 file system -F force, -t type
+ */
+export default async function mkfs() {
+    const result = true;
+    if (this.partitions.installationMode === InstallationMode.Replace) {
+        /**
+         * we need to define this.devices
+         */
+        this.devices.root.name = this.partitions.replacedPartition;
+        this.devices.root.mountPoint = '/';
+        this.devices.root.fsType = this.partitions.filesystemType;
+        this.devices.boot.name = 'none'; // OK
+        this.devices.data.name = 'none'; // OK
+        this.partitions.userSwapChoice = SwapChoice.File;
+        this.devices.swap.name = 'file'; // OK
+        this.devices.efi.name = 'none'; // Trovare il modo
+    }
+    if (this.partitions.filesystemType === 'ext4') {
+        // efi
+        if (this.efi) {
+            await exec(`mkdosfs -F 32 -I ${this.devices.efi.name} ${this.toNull}`, this.echo);
+        }
+        // boot
+        if (this.devices.boot.name !== 'none') {
+            if (this.devices.boot.fsType === undefined) {
+                this.devices.boot.fsType = 'ext2';
+                this.devices.boot.mountPoint = '/boot';
+            }
+            await exec(`mke2fs -Ft ${this.devices.boot.fsType} ${this.devices.boot.name} ${this.toNull}`, this.echo);
+        }
+        // root 
+        if (this.devices.root.name !== 'none') {
+            await exec(`mke2fs -Ft ${this.devices.root.fsType} ${this.devices.root.name} ${this.toNull}`, this.echo);
+        }
+        // data
+        if (this.devices.data.name !== 'none') {
+            await exec(`mke2fs -Ft ${this.devices.data.fsType} ${this.devices.data.name} ${this.toNull}`, this.echo);
+        }
+        // swap
+        if (this.partitions.userSwapChoice === SwapChoice.File) {
+            // we'll create it on mount-fs
+        }
+        else if (this.devices.swap.name !== 'none') {
+            await exec(`mkswap ${this.devices.swap.name} ${this.toNull}`, this.echo);
+        }
+    }
+    else if (this.partitions.filesystemType === 'btrfs') {
+        await exec(`mkfs.btrfs -f ${this.devices.root.name} ${this.toNull}`, this.echo);
+        //  create subvolumes
+        // await exec(`btrfs subvolume create /.snapshots ${this.toNull}`, this.echo)
+        // await exec(`btrfs subvolume create /home ${this.toNull}`, this.echo)
+        // await exec(`btrfs subvolume create /root ${this.toNull}`, this.echo)
+        // await exec(`btrfs subvolume create /var/log ${this.toNull}`, this.echo)
+        // await exec(`btrfs subvolume create /var/lib/AccountsService ${this.toNull}`, this.echo)
+        // await exec(`btrfs subvolume create /var/lib/blueman ${this.toNull}`, this.echo)
+        // await exec(`btrfs subvolume create /tmp ${this.toNull}`, this.echo)
+    }
+    return result;
+}

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

@@ -0,0 +1,17 @@
+/**
+ * ./src/krill/modules/mount-fs.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';
+/**
+ * mountFs
+ */
+export declare function mountFs(this: Sequence): Promise<boolean>;
+/**
+ * umountFs
+ */
+export declare function umountFs(this: Sequence): Promise<boolean>;

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

@@ -0,0 +1,68 @@
+/**
+ * ./src/krill/modules/mount-fs.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 { exec } from '../../../lib/utils.js';
+import { SwapChoice } from '../krill_enums.js';
+/**
+ * mountFs
+ */
+export async function mountFs() {
+    if (!fs.existsSync(this.installTarget)) {
+        await exec(`mkdir ${this.installTarget} ${this.toNull}`, this.echo);
+    }
+    // root
+    await exec(`mount -t ${this.devices.root.fsType} ${this.devices.root.name} ${this.installTarget}${this.devices.root.mountPoint} ${this.toNull}`, this.echo);
+    await exec(`tune2fs -c 0 -i 0 ${this.devices.root.name} ${this.toNull}`, this.echo);
+    await exec(`rm -rf ${this.installTarget}/lost+found ${this.toNull}`, this.echo);
+    // boot
+    if (this.devices.boot.name !== 'none') {
+        await exec(`mkdir ${this.installTarget}/boot -p ${this.toNull}`, this.echo);
+        await exec(`mount -t ${this.devices.boot.fsType} ${this.devices.boot.name} ${this.installTarget}${this.devices.boot.mountPoint} ${this.toNull}`, this.echo);
+        await exec(`tune2fs -c 0 -i 0 ${this.devices.boot.name} ${this.toNull}`, this.echo);
+    }
+    // data
+    if (this.devices.data.name !== 'none') {
+        await exec(`mkdir ${this.installTarget}${this.devices.data.mountPoint} -p ${this.toNull}`, this.echo);
+        await exec(`mount -t ${this.devices.data.fsType} ${this.devices.data.name} ${this.installTarget}${this.devices.data.mountPoint} ${this.toNull}`, this.echo);
+        await exec(`tune2fs -c 0 -i 0 ${this.devices.data.name} ${this.toNull}`, this.echo);
+    }
+    // efi
+    if (this.efi && !fs.existsSync(this.installTarget + this.devices.efi.mountPoint)) {
+        await exec(`mkdir ${this.installTarget}${this.devices.efi.mountPoint} -p ${this.toNull}`, this.echo);
+        // utilizzare vfat per evitare errori
+        await exec(`mount -t vfat ${this.devices.efi.name} ${this.installTarget}${this.devices.efi.mountPoint} ${this.toNull}`, this.echo);
+    }
+    // swap file if we need
+    if (this.partitions.userSwapChoice === SwapChoice.File) {
+        await exec(`fallocate -l 8G ${this.installTarget}/swapfile`);
+        await exec(`chmod 600 ${this.devices.root.mountPoint}/swapfile`, this.echo);
+        await exec(`mkswap ${this.devices.root.mountPoint}/swapfile`, this.echo);
+    }
+    return true;
+}
+/**
+ * umountFs
+ */
+export async function umountFs() {
+    // efi
+    if (this.efi) {
+        await this.umount(this.devices.efi.name);
+    }
+    // data
+    if (this.devices.data.name !== 'none') {
+        await this.umount(this.devices.data.name);
+    }
+    // boot
+    if (this.devices.boot.name !== 'none') {
+        await this.umount(this.devices.boot.name);
+    }
+    // root
+    await this.umount(this.devices.root.name);
+    return true;
+}

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

@@ -0,0 +1,17 @@
+/**
+ * ./src/krill/modules/mount-vfs.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';
+/**
+ * mountvfs()
+ */
+export declare function mountVfs(this: Sequence): Promise<void>;
+/**
+ *
+ */
+export declare function umountVfs(this: Sequence): Promise<void>;

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

@@ -0,0 +1,40 @@
+/**
+ * ./src/krill/modules/mount-vfs.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';
+/**
+ * mountvfs()
+ */
+export async function mountVfs() {
+    await exec(`mkdir ${this.installTarget}/dev ${this.toNull}`, this.echo);
+    await exec(`mkdir ${this.installTarget}/dev/pts ${this.toNull}`, this.echo);
+    await exec(`mkdir ${this.installTarget}/proc ${this.toNull}`, this.echo);
+    await exec(`mkdir ${this.installTarget}/sys ${this.toNull}`, this.echo);
+    await exec(`mkdir ${this.installTarget}/run ${this.toNull}`, this.echo);
+    await exec(`mount -o bind /dev ${this.installTarget}/dev ${this.toNull}`, this.echo);
+    await exec(`mount -o bind /dev/pts ${this.installTarget}/dev/pts ${this.toNull}`, this.echo);
+    await exec(`mount -o bind /proc ${this.installTarget}/proc ${this.toNull}`, this.echo);
+    await exec(`mount -o bind /sys ${this.installTarget}/sys ${this.toNull}`, this.echo);
+    if (this.efi) {
+        await exec(`mount -o bind /sys/firmware/efi/efivars ${this.installTarget}/sys/firmware/efi/efivars ${this.toNull}`, this.echo);
+    }
+    await exec(`mount -o rbind /run ${this.installTarget}/run ${this.toNull}`, this.echo);
+}
+/**
+ *
+ */
+export async function umountVfs() {
+    await this.umount(`${this.installTarget}/dev/pts`);
+    await this.umount(`${this.installTarget}/dev`);
+    await this.umount(`${this.installTarget}/proc`);
+    await this.umount(`${this.installTarget}/run`);
+    if (this.efi) {
+        await this.umount(`${this.installTarget}/sys/firmware/efi/efivars`);
+    }
+    await this.umount(`${this.installTarget}/sys`);
+}

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

@@ -0,0 +1,19 @@
+/**
+ * ./src/krill/modules/network-cfg.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';
+/**
+ * networkcfg
+ *
+ * - debian: /etc/network/interface
+ * - ubuntu: netplan
+ * - arch:
+ *
+ * - all: /etc/resolv.conf
+ */
+export default function networkCfg(this: Sequence): Promise<void>;

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

@@ -0,0 +1,73 @@
+/**
+ * ./src/krill/modules/network-cfg.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 Pacman from '../../../classes/pacman.js';
+import Systemctl from '../../../classes/systemctl.js';
+import { exec } from '../../../lib/utils.js';
+/**
+ * networkcfg
+ *
+ * - debian: /etc/network/interface
+ * - ubuntu: netplan
+ * - arch:
+ *
+ * - all: /etc/resolv.conf
+ */
+export default async function networkCfg() {
+    const systemdCtl = new Systemctl();
+    /**
+     * debian: /etc/network/interfaces
+     */
+    if (this.distro.familyId === 'debian' && !Pacman.packageIsInstalled('netplan.io')) {
+        const file = this.installTarget + '/etc/network/interfaces';
+        let content = '# created by eggs\n\n';
+        content += 'auto lo\n';
+        content += 'iface lo inet loopback\n\n';
+        content += 'auto ' + this.network.iface + '\n';
+        content += 'iface ' + this.network.iface + ' inet ' + this.network.addressType + '\n';
+        if (this.network.addressType !== 'dhcp') {
+            content += '    address ' + this.network.address + '\n';
+            content += '    netmask ' + this.network.netmask + '\n';
+            content += '    gateway ' + this.network.gateway + '\n';
+        }
+        try {
+            fs.writeFileSync(file, content, 'utf8');
+        }
+        catch (e) {
+            console.log("error on write: " + file);
+        }
+    }
+    else if (this.distro.familyId === 'debian' && Pacman.packageIsInstalled('netplan.io')) {
+        // netplan: to do
+    }
+    else if (this.distro.familyId === 'arch') {
+        // arch: seem to work
+    }
+    /**
+     * resolv.conf
+     */
+    const resolvFile = this.installTarget + '/etc/resolv.conf';
+    await exec(`rm -f ${resolvFile}`);
+    if (fs.existsSync('/run/systemd/resolve/resolv.conf')) {
+        await exec(`ln -s /run/systemd/resolve/resolv.conf ${resolvFile}`);
+    }
+    else {
+        let content = '# created by eggs\n\n';
+        content += 'domain ' + this.network.domain + '\n';
+        for (const element of this.network.dns) {
+            content += 'nameserver ' + element + '\n';
+        }
+        try {
+            fs.writeFileSync(resolvFile, content, 'utf8');
+        }
+        catch (e) {
+            console.log("error on write: " + resolvFile);
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+/**
+ * ./src/krill/modules/packages.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 packages(this: Sequence): Promise<void>;

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

@@ -0,0 +1,111 @@
+/**
+ * ./src/krill/modules/packages.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 yaml from 'js-yaml';
+import fs from 'node:fs';
+import Pacman from '../../../classes/pacman.js';
+import Utils from '../../../classes/utils.js';
+import { exec } from '../../../lib/utils.js';
+/**
+ *
+ * @param this
+ */
+export default async function packages() {
+    const echoYes = Utils.setEcho(true);
+    let modulePath = '/etc/penguins-eggs.d/krill/';
+    if (Pacman.packageIsInstalled('calamares')) {
+        modulePath = '/etc/calamares/';
+    }
+    const config_file = `${modulePath}modules/packages.conf`;
+    if (fs.existsSync(config_file)) {
+        const packages = yaml.load(fs.readFileSync(config_file, 'utf8'));
+        let packagesToInstall = [];
+        let packagesToRemove = [];
+        if (packages.operations !== undefined) {
+            for (const operation of packages.operations) {
+                if ('try_remove' in operation) {
+                    packagesToRemove = operation.try_remove;
+                }
+                if ('try_install' in operation) {
+                    packagesToInstall = operation.try_install;
+                }
+            }
+        }
+        // Alpine
+        if (this.distro.familyId === 'alpine') {
+            packages.backend = 'apk';
+        }
+        switch (packages.backend) {
+            case 'apt': {
+                /**
+                 * apt
+                 */
+                if (packagesToRemove != undefined && packagesToRemove.length > 0) {
+                    let cmd = `chroot ${this.installTarget} apt-get purge -y `;
+                    for (const elem of packagesToRemove) {
+                        if (Pacman.packageIsInstalled(elem)) {
+                            cmd += elem + ' ';
+                        }
+                    }
+                    await exec(`${cmd} ${this.toNull}`, this.echo);
+                    const autoremove = `chroot ${this.installTarget} apt-get autoremove -y ${this.toNull}`;
+                    await exec(autoremove, this.echo);
+                }
+                if (packagesToInstall != undefined && packagesToInstall.length > 0) {
+                    let cmd = `chroot ${this.installTarget} apt-get install -y `;
+                    for (const elem of packagesToInstall) {
+                        cmd += elem + ' ';
+                    }
+                    const update = `chroot ${this.installTarget} apt-get update ${this.toNull}`;
+                    await exec(update, this.echo);
+                    await exec(`${cmd} ${this.toNull}`, this.echo);
+                }
+                break;
+            }
+            case 'pacman': {
+                /**
+                 * pacman
+                 */
+                if (packagesToRemove != undefined && packagesToRemove.length > 0) {
+                    let cmd = `chroot ${this.installTarget} pacman -R\n`;
+                    for (const elem of packagesToRemove) {
+                        cmd += elem + ' ';
+                    }
+                    await exec(`${cmd} ${echoYes}`, this.echo);
+                }
+                if (packagesToInstall != undefined && packagesToInstall.length > 0) {
+                    for (const elem of packagesToInstall) {
+                        await exec(`chroot ${this.installTarget} pacman -S ${elem}`, echoYes);
+                    }
+                }
+                break;
+            }
+            case 'apk': {
+                /**
+                 * apk
+                 */
+                if (packagesToRemove != undefined && packagesToRemove.length > 0) {
+                    let cmd = `chroot ${this.installTarget} apk del `;
+                    for (const elem of packagesToRemove) {
+                        cmd += elem + ' ';
+                    }
+                    await exec(`${cmd} ${this.toNull}`, this.echo);
+                }
+                if (packagesToInstall != undefined && packagesToInstall.length > 0) {
+                    let cmd = `chroot ${this.installTarget} apk add `;
+                    for (const elem of packagesToInstall) {
+                        cmd += elem + ' ';
+                    }
+                    await exec(`${cmd} ${this.toNull}`, this.echo);
+                }
+                break;
+            }
+            // No default
+        }
+    }
+}

package/dist/krill/classes/sequence.d/partition.d/bios_luks.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ./src/krill/modules/partition.d/bios-luks.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 installDevice
+ * @param p
+ * @returns
+ */
+export default function biosLuks(this: Sequence, installDevice?: string, p?: string): Promise<boolean>;