penguins-eggs 9.6.34 → 10.0.0

package/dist/krill/sequence.js

@@ -0,0 +1,640 @@
+/**
+ * ./src/krill/sequence.tsx
+ * 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 Settings from '../classes/settings.js';
+import React from 'react';
+import { render } from 'ink';
+import Install from '../components/install.js';
+import Finished from '../components/finished.js';
+import fs from 'fs';
+import yaml from 'js-yaml';
+import Utils from '../classes/utils.js';
+import CliAutologin from '../lib/cli-autologin.js';
+import Pacman from '../classes/pacman.js';
+import { installer } from '../classes/incubation/installer.js';
+import Xdg from '../classes/xdg.js';
+import Distro from '../classes/distro.js';
+import { exec } from '../lib/utils.js';
+// import krill modules
+import partition from './modules/partition.js';
+import { mountFs, umountFs } from './modules/mount-fs.js';
+import { mountVfs, umountVfs } from './modules/mount-vfs.js';
+import unpackfs from './modules/unpackfs.js';
+import machineId from './modules/machine-id.js';
+import fstab from './modules/fstab.js';
+import locale from './modules/locale.js';
+import mKeyboard from './modules/m-keyboard.js';
+import localeCfg from './modules/locale-cfg.js';
+// users
+import addUser from './modules/add-user.js';
+import changePassword from './modules/change-password.js';
+// displaymanager: autologin
+import networkCfg from './modules/network-cfg.js';
+// hwclock:
+// services-systemd:
+// bootloader-config
+import bootloaderConfig from './modules/bootloader-config.js';
+import bootloaderConfigArch from './modules/bootloader-config-arch.js';
+import bootloaderConfigDebian from './modules/bootloader-config-debian.js';
+import grubcfg from './modules/grubcfg.js';
+import bootloader from './modules/bootloader.js';
+import packages from './modules/packages.js';
+import removeInstallerLink from './modules/remove-installer-link.js';
+import initramfsCfg from './modules/initramfs-cfg.js';
+import initramfs from './modules/initramfs.js';
+import delLiveUser from './modules/del-live-user.js';
+// umount already imported
+// to order in same wat
+import mTimezone from './modules/m-timezone.js';
+import umount from './modules/umount.js';
+import mkfs from './modules/mkfs.js';
+import hostname from './modules/hostname.js';
+import CFS from '../classes/cfs.js';
+/**
+ * hatching: installazione o cova!!!
+ */
+export default class Sequence {
+    partition = partition;
+    // mount
+    mountFs = mountFs;
+    mountVfs = mountVfs;
+    //
+    unpackfs = unpackfs;
+    machineId = machineId;
+    fstab = fstab;
+    locale = locale;
+    keyboard = mKeyboard;
+    localeCfg = localeCfg;
+    // users
+    addUser = addUser;
+    changePassword = changePassword;
+    // displaumanager: autologin
+    networkCfg = networkCfg;
+    // hwclock:
+    // services-systemd:
+    // bootloader-config
+    bootloaderConfig = bootloaderConfig;
+    bootloaderConfigArch = bootloaderConfigArch;
+    bootloaderConfigDebian = bootloaderConfigDebian;
+    //
+    grubcfg = grubcfg;
+    bootloader = bootloader;
+    packages = packages;
+    removeInstallerLink = removeInstallerLink;
+    // luksbootkeyfile:
+    // plymouthcfg;
+    initramfsCfg = initramfsCfg;
+    initramfs = initramfs;
+    delLiveUser = delLiveUser;
+    umountFs = umountFs;
+    umountVfs = umountVfs;
+    // to order in same way
+    timezone = mTimezone;
+    umount = umount;
+    mkfs = mkfs;
+    hostname = hostname;
+    installer = {};
+    installTarget = '/tmp/calamares-krill-root';
+    verbose = false;
+    echo = {};
+    efi = false;
+    devices = {};
+    users = {};
+    network = {};
+    partitions = {};
+    language = '';
+    region = '';
+    zone = '';
+    keyboardModel = '';
+    keyboardLayout = '';
+    keyboardVariant = '';
+    toNull = ' > /dev/null 2>&1';
+    settings = {};
+    remix = {};
+    distro = {};
+    // Crypted Clone
+    luksName = 'luks-volume';
+    luksFile = ``;
+    luksDevice = `/dev/mapper/${this.luksName}`;
+    luksMountpoint = `/mnt`;
+    // Clone (Uncrypted)
+    is_clone = fs.existsSync('penguins-eggs.d/is_clone');
+    is_crypted_clone = fs.existsSync('/etc/penguins-eggs.d/is_crypted_clone');
+    unattended = false;
+    nointeractive = false;
+    halt = false;
+    cliAutologin = new CliAutologin();
+    /**
+     * constructor
+     */
+    constructor(location, keyboard, partitions, users, network) {
+        this.installer = installer();
+        this.settings = new Settings();
+        this.language = location.language;
+        this.region = location.region;
+        this.zone = location.zone;
+        this.keyboardModel = keyboard.keyboardModel;
+        this.keyboardLayout = keyboard.keyboardLayout;
+        this.keyboardVariant = keyboard.keyboardVariant;
+        this.network = network;
+        this.partitions = partitions;
+        this.users = users;
+        this.devices.efi = {};
+        this.devices.boot = {};
+        this.devices.root = {};
+        this.devices.data = {};
+        this.devices.swap = {};
+        this.distro = new Distro(this.remix);
+        this.efi = fs.existsSync('/sys/firmware/efi/efivars');
+        this.luksFile = `${this.distro.liveMediumPath}live/${this.luksName}`;
+    }
+    /**
+     * install
+     * @param verbose
+     * @param umount
+     * @returns
+     */
+    async start(domain = '', unattended = false, nointeractive = false, halt = false, verbose = false) {
+        // Imposta il domain per flag
+        if (domain !== '') {
+            if (domain.at(0) !== '.') {
+                domain = '.' + domain;
+            }
+            this.network.domain = domain;
+        }
+        /**
+         * To let krill to work with Arch we need:
+         */
+        if (this.distro.familyId === 'archlinux') {
+            if (this.distro.distroId === 'ManjaroLinux') {
+                await exec(`sudo ln -s /run/miso/bootmnt/live/ /live`);
+            }
+            else {
+                await exec(`sudo ln -s /run/archiso/bootmnt/live/ /live`);
+            }
+        }
+        this.unattended = unattended;
+        this.nointeractive = nointeractive;
+        this.halt = halt;
+        this.verbose = verbose;
+        this.echo = Utils.setEcho(this.verbose);
+        if (this.verbose) {
+            this.toNull = '';
+        }
+        // start
+        await this.settings.load();
+        // partition
+        let percent = 0.0;
+        let message = "";
+        let isPartitioned = false;
+        message = "Creating partitions";
+        percent = 0.03;
+        try {
+            await redraw(React.createElement(Install, { message: message, percent: percent }));
+            isPartitioned = await this.partition();
+        }
+        catch (error) {
+            await Utils.pressKeyToExit(JSON.stringify(error));
+        }
+        if (isPartitioned) {
+            // formatting
+            message = "Formatting file system ";
+            percent = 0.06;
+            try {
+                await redraw(React.createElement(Install, { message: message, percent: percent }));
+                await this.mkfs();
+            }
+            catch (error) {
+                await Utils.pressKeyToExit(JSON.stringify(error));
+            }
+            // mountFs
+            message = "Mounting target file system ";
+            percent = 0.09;
+            try {
+                redraw(React.createElement(Install, { message: message, percent: percent }));
+                await this.mountFs();
+            }
+            catch (error) {
+                await Utils.pressKeyToExit(JSON.stringify(error));
+            }
+            // mountVfs
+            message = "Mounting on target VFS ";
+            percent = 0.12;
+            try {
+                await redraw(React.createElement(Install, { message: message, percent: percent }));
+                await this.mountVfs();
+            }
+            catch (error) {
+                await Utils.pressKeyToExit(JSON.stringify(error));
+            }
+            // unpackfs
+            message = "Unpacking filesystem ";
+            percent = 0.15;
+            try {
+                await redraw(React.createElement(Install, { message: message, percent: percent }));
+                await this.unpackfs();
+            }
+            catch (error) {
+                await Utils.pressKeyToExit(JSON.stringify(error));
+            }
+            // dpkg-unsafe-io
+            if (this.distro.familyId === 'debian') {
+                message = "dpkg-unsafe-io";
+                percent = 0.40;
+                try {
+                    await redraw(React.createElement(Install, { message: message, percent: percent }));
+                    await this.execCalamaresModule('dpkg-unsafe-io');
+                }
+                catch (error) {
+                    await Utils.pressKeyToExit(JSON.stringify(error));
+                }
+            }
+            // sources-yolk
+            if (this.distro.familyId === 'debian') {
+                message = 'sources-yolk';
+                percent = 0.43;
+                try {
+                    await redraw(React.createElement(Install, { message: message, percent: percent, spinner: true }));
+                    await this.execCalamaresModule('sources-yolk');
+                }
+                catch (error) {
+                    await Utils.pressKeyToExit(JSON.stringify(error));
+                }
+            }
+            // machineid
+            message = 'machineid';
+            percent = 0.46;
+            try {
+                await redraw(React.createElement(Install, { message: message, percent: percent, spinner: true }));
+                await this.machineId();
+            }
+            catch (error) {
+                await Utils.pressKeyToExit(JSON.stringify(error));
+            }
+            // fstab
+            message = "Creating fstab ";
+            percent = 0.49;
+            try {
+                await redraw(React.createElement(Install, { message: message, percent: percent }));
+                await this.fstab(this.partitions.installationDevice);
+            }
+            catch (error) {
+                await Utils.pressKeyToExit(JSON.stringify(error));
+            }
+            /**
+             * CryptedClone exec eggs syncfrom
+             */
+            if (this.is_crypted_clone) {
+                message = "Restore private data from crypted clone ";
+                if (fs.existsSync(this.luksFile)) {
+                    percent = 0.55;
+                    let cmd = `eggs syncfrom --rootdir /tmp/calamares-krill-root/ --file ${this.luksFile}`;
+                    try {
+                        await redraw(React.createElement(Install, { message: message, percent: percent, spinner: true }));
+                        await exec(cmd, Utils.setEcho(true));
+                        this.is_clone = true; // Adesso è un clone
+                    }
+                    catch (error) {
+                        await Utils.pressKeyToExit(cmd);
+                    }
+                }
+                else {
+                    await Utils.pressKeyToExit(`Cannot find luks-volume file ${this.luksFile}`);
+                }
+            }
+            // networkcfg
+            message = "networkcfg";
+            percent = 0.61;
+            try {
+                await this.networkCfg();
+            }
+            catch (error) {
+                await Utils.pressKeyToExit(JSON.stringify(error));
+            }
+            // hostname
+            message = "Create hostname ";
+            percent = 0.64;
+            try {
+                await redraw(React.createElement(Install, { message: message, percent: percent }));
+                await this.hostname(this.network.domain);
+            }
+            catch (error) {
+                await Utils.pressKeyToExit(JSON.stringify(error));
+            }
+            // initramfsCfg
+            message = "initramfs configure";
+            percent = 0.67;
+            try {
+                await redraw(React.createElement(Install, { message: message, percent: percent }));
+                await this.initramfsCfg(this.partitions.installationDevice);
+            }
+            catch (error) {
+                await Utils.pressKeyToExit(JSON.stringify(error));
+            }
+            // initramfs
+            message = "initramfs ";
+            percent = 0.70;
+            try {
+                await redraw(React.createElement(Install, { message: message, percent: percent }));
+                await this.initramfs();
+            }
+            catch (error) {
+                await Utils.pressKeyToExit(JSON.stringify(error));
+            }
+            // dpkg-unsafe-io-undo
+            if (this.distro.familyId === 'debian') {
+                message = "dpkg-unsafe-io-undo";
+                percent = 0.72;
+                try {
+                    await redraw(React.createElement(Install, { message: message, percent: percent }));
+                    await this.execCalamaresModule('dpkg-unsafe-io-undo');
+                }
+                catch (error) {
+                    await Utils.pressKeyToExit(JSON.stringify(error));
+                }
+            }
+            /**
+             * IF NOT CLONE:
+             * - locale
+             * - keyboard
+             * - localeCfg
+             * - delLiveUser
+             * - adduser
+             * - autologin
+             */
+            if (!this.is_clone) {
+                // locale
+                message = "Locale";
+                percent = 0.74;
+                try {
+                    redraw(React.createElement(Install, { message: message, percent: percent }));
+                    await this.locale();
+                }
+                catch (error) {
+                    await Utils.pressKeyToExit(JSON.stringify(error));
+                }
+                // keyboard
+                message = "settings keyboard";
+                percent = 0.75;
+                try {
+                    await this.keyboard();
+                }
+                catch (error) {
+                    await Utils.pressKeyToExit(JSON.stringify(error));
+                }
+                // localeCfg
+                message = "Locale Configuration";
+                percent = 0.76;
+                try {
+                    await this.localeCfg();
+                    await exec("chroot " + this.installTarget + " locale-gen");
+                }
+                catch (error) {
+                    await Utils.pressKeyToExit(JSON.stringify(error));
+                }
+                // delLiveUser
+                message = "Remove user LIVE";
+                percent = 0.75;
+                try {
+                    await redraw(React.createElement(Install, { message: message, percent: percent }));
+                    await this.delLiveUser();
+                }
+                catch (error) {
+                    await Utils.pressKeyToExit(JSON.stringify(error));
+                }
+                // addUser
+                message = "Add user";
+                percent = 0.76;
+                try {
+                    await redraw(React.createElement(Install, { message: message, percent: percent }));
+                    await this.addUser(this.users.username, this.users.password, this.users.fullname, '', '', '');
+                }
+                catch (error) {
+                    await Utils.pressKeyToExit(JSON.stringify(error));
+                }
+                // changePassword root
+                message = "Add root password";
+                percent = 0.77;
+                try {
+                    await redraw(React.createElement(Install, { message: message, percent: percent }));
+                    await this.changePassword('root', this.users.rootPassword);
+                }
+                catch (error) {
+                    await Utils.pressKeyToExit(JSON.stringify(error));
+                }
+                // autologin
+                if (Pacman.isInstalledGui()) {
+                    try {
+                        message = "Autologin GUI";
+                        percent = 0.78;
+                        if (this.users.autologin) {
+                            await Xdg.autologin(await Utils.getPrimaryUser(), this.users.username, this.installTarget);
+                            if (this.distro.distroLike === 'Arch') {
+                                await exec(`chroot ${this.installTarget} groupadd autologin`);
+                                await exec(`chroot ${this.installTarget} gpasswd -a ${this.users.username} autologin`);
+                            }
+                        }
+                        await redraw(React.createElement(Install, { message: message, percent: percent }));
+                    }
+                    catch (error) {
+                        await Utils.pressKeyToExit(JSON.stringify(error));
+                    }
+                }
+            } // IF NOT CLONE END
+            // Remove ALWAYS autologin CLI
+            message = "Remove autologin CLI";
+            percent = 0.80;
+            try {
+                await redraw(React.createElement(Install, { message: message, percent: percent }));
+                await this.cliAutologin.remove(this.installTarget);
+            }
+            catch (error) {
+                await Utils.pressKeyToExit(JSON.stringify(error));
+            }
+            // bootloader-config
+            message = "bootloader-config ";
+            percent = 0.82;
+            try {
+                await redraw(React.createElement(Install, { message: message, percent: percent }));
+                await this.bootloaderConfig();
+            }
+            catch (error) {
+                await Utils.pressKeyToExit(JSON.stringify(error));
+            }
+            // grubcfg
+            message = "grubcfg ";
+            percent = 0.84;
+            try {
+                await redraw(React.createElement(Install, { message: message, percent: percent }));
+                await this.grubcfg();
+            }
+            catch (error) {
+                await Utils.pressKeyToExit(JSON.stringify(error));
+            }
+            // bootloader (grub-install)
+            message = "bootloader ";
+            percent = 0.86;
+            try {
+                await redraw(React.createElement(Install, { message: message, percent: percent }));
+                await this.bootloader();
+            }
+            catch (error) {
+                await Utils.pressKeyToExit(JSON.stringify(error));
+            }
+            // sources-yolk-undo
+            if (this.distro.familyId === 'debian') {
+                message = "sources-yolk-undo";
+                percent = 0.88;
+                try {
+                    await redraw(React.createElement(Install, { message: message, percent: percent }));
+                    await this.execCalamaresModule('sources-yolk-undo');
+                }
+                catch (error) {
+                    await Utils.pressKeyToExit(JSON.stringify(error));
+                }
+            }
+            // packages
+            message = "add/remove packages";
+            percent = 0.90;
+            try {
+                await redraw(React.createElement(Install, { message: message, percent: percent }));
+                await this.packages();
+            }
+            catch (error) {
+                console.log(JSON.stringify(error));
+            }
+            /**
+             *
+             * remove CLI/GUI installer link
+             */
+            message = "remove GUI installer link";
+            percent = 0.92;
+            try {
+                await redraw(React.createElement(Install, { message: message, percent: percent }));
+                await this.removeInstallerLink();
+            }
+            catch (error) {
+                await Utils.pressKeyToExit(JSON.stringify(error));
+            }
+            // remove /etc/penguins_eggs.d/is_clone*
+            message = "Cleanup";
+            percent = 0.94;
+            try {
+                await redraw(React.createElement(Install, { message: message, percent: percent }));
+                await exec(`rm -f ${this.installTarget}/etc/penguins-eggs.d/is_clone`);
+                await exec(`rm -f ${this.installTarget}/etc/penguins-eggs.d/is_crypted_clone`);
+            }
+            catch (error) {
+                await Utils.pressKeyToExit(JSON.stringify(error));
+            }
+            /**
+             * custom final steps
+             */
+            const cfs = new CFS();
+            const steps = await cfs.steps();
+            if (steps.length > 0) {
+                for (const step of steps) {
+                    message = `running ${step}`;
+                    percent = 0.97;
+                    try {
+                        await redraw(React.createElement(Install, { message: message, percent: percent }));
+                        await this.execCalamaresModule(step);
+                    }
+                    catch (error) {
+                        await Utils.pressKeyToExit(JSON.stringify(error));
+                    }
+                }
+            }
+            // umountVfs
+            message = "umount VFS";
+            percent = 0.96;
+            try {
+                await redraw(React.createElement(Install, { message: message, percent: percent }));
+                await this.umountVfs();
+            }
+            catch (error) {
+                await Utils.pressKeyToExit(JSON.stringify(error));
+            }
+            message = "umount";
+            percent = 0.98;
+            try {
+                await redraw(React.createElement(Install, { message: message, percent: percent }));
+                await this.umountFs();
+            }
+            catch (error) {
+                await Utils.pressKeyToExit(JSON.stringify(error));
+            }
+            // finished
+            message = "finished";
+            percent = 100.0;
+            try {
+                await redraw(React.createElement(Install, { message: message, percent: percent }));
+                await this.finished();
+            }
+            catch (error) {
+                await Utils.pressKeyToExit(JSON.stringify(error));
+            }
+        }
+    }
+    /**
+     *
+     */
+    async execCalamaresModule(name) {
+        const moduleName = this.installer.multiarchModules + name + '/module.desc';
+        if (fs.existsSync(moduleName)) {
+            const calamaresModule = yaml.load(fs.readFileSync(moduleName, 'utf8'));
+            let command = calamaresModule.command;
+            if (command !== '' || command !== undefined) {
+                command += this.toNull;
+                await exec(command, this.echo);
+            }
+        }
+    }
+    /**
+     * only show the result
+     */
+    async finished() {
+        await redraw(React.createElement(Finished, { installationDevice: this.partitions.installationDevice, hostName: this.users.hostname, userName: this.users.username }));
+        let cmd = "reboot";
+        if (this.halt) {
+            cmd = "poweroff";
+        }
+        if (this.unattended && this.nointeractive) {
+            console.log(`System will ${cmd} in 5 seconds...`);
+            await sleep(5000);
+            await exec(cmd, { echo: true });
+        }
+        else {
+            Utils.pressKeyToExit(`Press a key to ${cmd}`);
+            await exec(cmd, { echo: true });
+        }
+    }
+}
+// const ifaces: string[] = fs.readdirSync('/sys/class/net/')
+/**
+ *
+ * @param elem
+ */
+async function redraw(elem) {
+    let opt = {};
+    opt.patchConsole = false;
+    opt.debug = false;
+    console.clear();
+    // await exec('clear', Utils.setEcho(false))
+    render(elem, opt);
+}
+/**
+ *
+ * @param ms
+ * @returns
+ */
+function sleep(ms = 0) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}

package/dist/lib/cli-autologin.d.ts

@@ -0,0 +1,43 @@
+/**
+ * ./src/lib/cli-autologin.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+/**
+ * CliAutologin
+ */
+export default class CliAutologin {
+    addAutologin(distro: string, version: string, user: string, userPasswd: string, rootPasswd: string, chroot?: string): Promise<void>;
+    /**
+     *
+     * @param distro
+     * @param version
+     * @param user
+     * @param userPasswd
+     * @param rootPasswd
+     * @param chroot
+     */
+    addIssue(distro: string, version: string, user: string, userPasswd: string, rootPasswd: string, chroot?: string): Promise<void>;
+    /**
+     *
+     * @param distro
+     * @param version
+     * @param user
+     * @param userPasswd
+     * @param rootPasswd
+     * @param chroot
+     */
+    addMotd(distro: string, version: string, user: string, userPasswd: string, rootPasswd: string, chroot?: string): Promise<void>;
+    /**
+     *
+     * @param path
+     */
+    msgRemove(path: string): Promise<void>;
+    /**
+     *
+     * @param chroot
+     */
+    remove(chroot?: string): Promise<void>;
+}