penguins-eggs 10.0.53 → 10.0.54

package/dist/classes/compressors.js

@@ -0,0 +1,109 @@
+/**
+ * ./src/classes/compressors.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import shx from 'shelljs';
+export default class Compressors {
+    dest = '/tmp/eggs-mksquash-dest';
+    isEnabled = {
+        error: false,
+        gzip: true,
+        lz4: false,
+        lzma: false,
+        lzo: false,
+        xz: false,
+        zstd: false
+    };
+    source = '/tmp/eggs-mksquash-test';
+    /**
+     * fast compression
+     * @returns
+     */
+    fast() {
+        let comp = 'gzip';
+        if (this.isEnabled.zstd) {
+            comp = 'zstd -b 1M -Xcompression-level 3';
+        }
+        else if (this.isEnabled.lz4) {
+            comp = 'lz4';
+        }
+        return comp;
+    }
+    /**
+     * max
+     * @returns
+     */
+    max() {
+        let filter = 'x86';
+        if (process.arch === 'arm64') {
+            filter = 'arm';
+        }
+        const options = '-b 1M -no-duplicates -no-recovery -always-use-fragments';
+        if (process.arch === 'ia32') {
+            // options = '-b 1M'
+        }
+        const comp = `xz -Xbcj ${filter} ${options}`;
+        return comp;
+    }
+    pendrive(level = '15') {
+        let comp = 'gzip';
+        if (this.isEnabled.zstd) {
+            comp = `zstd -b 1M -Xcompression-level ${level}`;
+        }
+        else if (this.isEnabled.lz4) {
+            comp = 'lz4';
+        }
+        return comp;
+    }
+    /**
+     * populate
+     */
+    async populate() {
+        await this.prepareCheck();
+        this.isEnabled.error = await this.check('error');
+        this.isEnabled.lzma = await this.check('lzma');
+        this.isEnabled.lzo = await this.check('lzo');
+        this.isEnabled.lz4 = await this.check('lz4');
+        this.isEnabled.xz = await this.check('xz');
+        this.isEnabled.zstd = await this.check('zstd');
+        await this.removeCheck();
+    }
+    /**
+     * standard
+     * @returns
+     */
+    standard() {
+        const comp = 'xz -b 1M';
+        return comp;
+    }
+    /**
+     * check mksquashfs exists
+     * @param compressor
+     * @returns
+     */
+    async check(compressor) {
+        let result = false;
+        const { stderr } = shx.exec('mksquashfs ' + this.source + ' ' + this.dest + ' -comp ' + compressor + ' -ef ' + this.dest, { silent: true });
+        if (stderr === '') {
+            result = true;
+        }
+        return result;
+    }
+    /**
+     * prepareCheck
+     */
+    async prepareCheck() {
+        shx.exec('rm -rf ' + this.source, { silent: true });
+        shx.exec('mkdir ' + this.source, { silent: true });
+    }
+    /**
+     * removeCheck
+     */
+    async removeCheck() {
+        shx.exec('rm -rf ' + this.source, { silent: true });
+        shx.exec('rm -f  ' + this.dest, { silent: true });
+    }
+}

package/dist/classes/daddy.d.ts

@@ -0,0 +1,26 @@
+/**
+ * ./src/classes/daddy.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import Settings from '../classes/settings.js';
+import { IEggsConfig } from '../interfaces/i-eggs-config.js';
+export default class Daddy {
+    settings: Settings;
+    /**
+     * editConfif
+     * @param c
+     * @returns
+     */
+    editConfig(c: IEggsConfig): Promise<string>;
+    /**
+     *
+     * @param reset
+     * @param isCustom
+     * @param fileCustom
+     * @param verbose
+     */
+    helpMe(reset?: boolean, isCustom?: boolean, fileCustom?: string, verbose?: boolean): Promise<void>;
+}

package/dist/classes/daddy.js

@@ -0,0 +1,167 @@
+/**
+ * ./src/classes/daddy.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import yaml from 'js-yaml';
+import fs from 'node:fs';
+// _dirname
+import path from 'node:path';
+// We need to remove .js extension from import
+import Pacman from '../classes/pacman.js';
+import Settings from '../classes/settings.js';
+import Utils from '../classes/utils.js';
+const __dirname = path.dirname(new URL(import.meta.url).pathname);
+export default class Daddy {
+    settings = {};
+    /**
+     * editConfif
+     * @param c
+     * @returns
+     */
+    async editConfig(c) {
+        // Utils.titles('dad')
+        console.log(chalk.cyan('Edit and save Live system parameters'));
+        console.log();
+        let compressionOpt = 0;
+        if (c.compression === 'xz') {
+            compressionOpt = 1;
+        }
+        else if (c.compression === 'xz -Xbcj x86') {
+            compressionOpt = 2;
+        }
+        if (c.snapshot_prefix === '') {
+            c.snapshot_prefix = Utils.snapshotPrefix(this.settings.distro.distroId, this.settings.distro.codenameId);
+        }
+        return new Promise((resolve) => {
+            const questions = [
+                {
+                    default: c.snapshot_prefix,
+                    message: 'LiveCD iso prefix: ',
+                    name: 'snapshot_prefix',
+                    type: 'input'
+                },
+                {
+                    default: c.snapshot_basename,
+                    message: 'LiveCD iso basename: ',
+                    name: 'snapshot_basename',
+                    type: 'input'
+                },
+                {
+                    default: c.user_opt,
+                    message: 'LiveCD user:',
+                    name: 'user_opt',
+                    type: 'input'
+                },
+                {
+                    default: c.user_opt_passwd,
+                    message: 'LiveCD user password: ',
+                    name: 'user_opt_passwd',
+                    type: 'input'
+                },
+                {
+                    default: c.root_passwd,
+                    message: 'LiveCD root password: ',
+                    name: 'root_passwd',
+                    type: 'input'
+                },
+                {
+                    choices: ['fast', 'max'],
+                    default: compressionOpt,
+                    message: 'LiveCD compression: ',
+                    name: 'compression',
+                    type: 'list'
+                }
+            ];
+            inquirer.prompt(questions).then((options) => {
+                resolve(JSON.stringify(options));
+            });
+        });
+    }
+    /**
+     *
+     * @param reset
+     * @param isCustom
+     * @param fileCustom
+     * @param verbose
+     */
+    async helpMe(reset = false, isCustom = false, fileCustom = '', verbose = false) {
+        if (isCustom) {
+            console.log('using custom file:', fileCustom);
+        }
+        // Controllo configurazione
+        if (!Pacman.configurationCheck()) {
+            console.log('- creating configuration dir...');
+            await Pacman.configurationInstall(verbose);
+        }
+        // Templates
+        if (!Pacman.distroTemplateCheck()) {
+            console.log('- distro template install...');
+            await Pacman.distroTemplateInstall(verbose);
+        }
+        //Calamares 
+        if (!Pacman.calamaresExists() &&
+            Pacman.isInstalledGui() &&
+            Pacman.isCalamaresAvailable()) {
+            console.log('- this is a GUI system, calamares is available, but NOT installed');
+        }
+        // show and edit configuration
+        this.settings = new Settings();
+        let config = {};
+        let jsonConf = '';
+        if (await this.settings.load()) {
+            config = this.settings.config;
+            config.compression = 'fast';
+            if (reset || isCustom) {
+                if (config.snapshot_prefix === '') {
+                    config.snapshot_prefix = Utils.snapshotPrefix(this.settings.distro.distroId, this.settings.distro.codenameId);
+                }
+                jsonConf = JSON.stringify(config);
+            }
+            else {
+                jsonConf = await this.editConfig(config);
+            }
+            // Custom configuration
+            if (isCustom) {
+                const conf = fs.readFileSync(fileCustom, 'utf8');
+                const confCustom = yaml.load(conf);
+                config.snapshot_basename = confCustom.snapshot_basename;
+                config.snapshot_prefix = confCustom.snapshot_prefix;
+                config.user_opt = confCustom.user_opt;
+                config.user_opt_passwd = confCustom.user_opt_passwd;
+                config.root_passwd = confCustom.root_passwd;
+                config.theme = confCustom.theme;
+                jsonConf = JSON.stringify(config);
+            }
+            // Save new configuration
+            const confNew = JSON.parse(jsonConf);
+            config.snapshot_basename = confNew.snapshot_basename;
+            config.snapshot_prefix = confNew.snapshot_prefix;
+            config.user_opt = confNew.user_opt;
+            config.user_opt_passwd = confNew.user_opt_passwd;
+            config.root_passwd = confNew.root_passwd;
+            config.theme = confNew.theme;
+            await this.settings.save(config);
+        }
+        console.log();
+        console.log(chalk.cyan('Your configuration was saved on: /etc/penguins-eggs.d'));
+        console.log();
+        console.log(chalk.cyan(`You can create a clean ISO with: `) + chalk.white(`sudo eggs produce`));
+        console.log(chalk.cyan(`or a full personal clone: `) + chalk.white(`sudo eggs produce --clone`));
+        console.log();
+        console.log(chalk.cyan(`If you don't have enough space to remaster, you can mount`));
+        console.log(chalk.cyan(`some remote or local space. Follow the samples:`));
+        console.log(chalk.cyan(`- first, create an hidden mountpoint under the nest:`));
+        console.log(chalk.white(`sudo mkdir /home/eggs/.mnt -p`));
+        console.log(chalk.cyan(`- then, mount remote space:`));
+        console.log(chalk.white(`sudo sshfs -o allow_other root@192.168.1.2:/zfs/iso /home/eggs/.mnt`));
+        console.log(chalk.cyan('- or, mount a local partition:'));
+        console.log(chalk.white(`sudo mount /dev/sdx1 /home/eggs/.mnt`));
+        console.log();
+        console.log(chalk.cyan('More help? ') + chalk.white('eggs mom'));
+    }
+}

package/dist/classes/distro.d.ts

@@ -0,0 +1,32 @@
+/**
+ * penguins-eggs
+ * class: distro.ts
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import { IDistro } from '../interfaces/index.js';
+/**
+ * Classe
+ */
+declare class Distro implements IDistro {
+    bugReportUrl: string;
+    codenameId: string;
+    codenameLikeId: string;
+    distroId: string;
+    distroLike: string;
+    familyId: string;
+    homeUrl: string;
+    isCalamaresAvailable: boolean;
+    liveMediumPath: string;
+    releaseId: string;
+    squashfs: string;
+    supportUrl: string;
+    syslinuxPath: string;
+    usrLibPath: string;
+    /**
+     * Costruttore
+     */
+    constructor();
+}
+export default Distro;

package/dist/classes/distro.js

@@ -0,0 +1,341 @@
+/**
+ * penguins-eggs
+ * class: distro.ts
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import yaml from 'js-yaml';
+import fs from 'node:fs';
+import path from 'node:path';
+import shell from 'shelljs';
+import Utils from './utils.js';
+import Diversions from './diversions.js';
+// _dirname
+const __dirname = path.dirname(new URL(import.meta.url).pathname);
+/**
+ * Classe
+ */
+class Distro {
+    bugReportUrl;
+    codenameId;
+    codenameLikeId;
+    distroId;
+    distroLike;
+    familyId;
+    homeUrl;
+    isCalamaresAvailable;
+    liveMediumPath;
+    releaseId;
+    squashfs;
+    supportUrl;
+    syslinuxPath;
+    usrLibPath;
+    /**
+     * Costruttore
+     */
+    constructor() {
+        let found = false;
+        // Tutti i default sono per Debian
+        this.bugReportUrl = 'https://github.com-pieroproietti/penguins-eggs/issue';
+        this.codenameId = '';
+        this.codenameLikeId = '';
+        this.distroId = '';
+        this.distroLike = '';
+        this.familyId = 'debian';
+        this.homeUrl = 'https://penguins-eggs.net';
+        this.isCalamaresAvailable = true;
+        this.liveMediumPath = '/run/live/medium/';
+        this.releaseId = '';
+        this.squashfs = 'live/filesystem.squashfs';
+        this.supportUrl = 'https://penguins-eggs.net';
+        this.syslinuxPath = path.resolve(__dirname, `../../syslinux`);
+        this.usrLibPath = '/usr/lib';
+        /**
+         * lsb_release -cs per codename (version)
+         * lsb_release -is per distribuzione
+         * lsb_release -rs per release
+         */
+        this.codenameId = shell.exec(`lsb_release -cs`, { silent: true }).stdout.toString().trim();
+        this.releaseId = shell.exec(`lsb_release -rs`, { silent: true }).stdout.toString().trim();
+        this.distroId = shell.exec(`lsb_release -is`, { silent: true }).stdout.toString().trim();
+        if (this.distroId === 'Debian' && this.codenameId === 'sid') {
+            this.codenameId = 'trixie';
+        }
+        if (this.distroId.includes('BigLinux')) {
+            this.distroId = "BigLinux";
+        }
+        if (this.distroId.includes('BigCommunity')) {
+            this.distroId = "BigCommunity";
+        }
+        /**
+         * Alpine, Fedora, openmamba, opensuse, VoidLinux solo distroId.
+         *
+         * Debian, Devuan, Ubuntu e derivate ricadono in
+         * default e si analizza il codebaseId
+         *
+         */
+        if (this.distroId === 'ALDOS') {
+            this.familyId = 'aldos';
+            this.distroLike = 'ALDOS';
+            this.codenameId = 'rolling'; // viene rimosso dal nome
+            this.codenameLikeId = this.familyId; // per krill
+            this.liveMediumPath = '/run/initramfs/live/';
+            /**
+             * Alpine compatible
+             */
+        }
+        else if (this.distroId === 'Alpine') {
+            this.familyId = 'alpine';
+            this.distroLike = this.distroId;
+            this.codenameId = 'rolling'; // viene rimosso dal nome
+            this.codenameLikeId = this.familyId; // per krill
+            this.liveMediumPath = '/mnt/'; // Qua è deciso da noi
+            /**
+             * Fedora/RHEL compatible
+             */
+        }
+        else if (this.distroId === 'AlmaLinux' ||
+            this.distroId === 'Fedora' ||
+            this.distroId === 'NobaraLinux' ||
+            this.distroId === 'RockyLinux') {
+            this.familyId = 'fedora';
+            this.distroLike = 'Fedora';
+            this.codenameId = 'rolling'; // viene rimosso dal nome
+            this.codenameLikeId = this.familyId; // per krill
+            this.liveMediumPath = '/run/initramfs/live/';
+            /**
+             * openmamba
+             */
+        }
+        else if (this.distroId === 'openmamba') {
+            this.familyId = 'openmamba';
+            this.distroLike = 'openmamba';
+            this.codenameId = 'rolling'; // viene rimosso dal nome
+            this.codenameLikeId = this.familyId; // per krill
+            this.liveMediumPath = '/run/initramfs/live/';
+            /**
+             * opensuse compatible
+             */
+        }
+        else if (this.distroId === 'openSUSE') {
+            this.familyId = 'opensuse';
+            this.distroLike = this.distroId;
+            this.codenameId = 'rolling'; // viene rimosso dal nome
+            this.codenameLikeId = this.familyId; // per krill
+            this.liveMediumPath = '/run/initramfs/live/'; // check
+            /**
+             * voidlinux compatible
+             */
+        }
+        else if (this.distroId === 'VoidLinux') {
+            this.familyId = 'voidlinux';
+            this.distroLike = this.distroId;
+            this.codenameId = 'rolling';
+            this.codenameLikeId = this.familyId; // per krill
+            this.liveMediumPath = '/run/initramfs/live/'; // we must discover
+        }
+        else {
+            /**
+             * We must analize codenameId
+             */
+            /**
+             * Arch
+             */
+            if (this.codenameId === 'rolling' || this.codenameId === 'n/a') {
+                this.familyId = 'archlinux';
+                this.distroLike = 'Arch';
+                this.codenameId = 'rolling';
+                this.codenameLikeId = 'rolling';
+                this.liveMediumPath = '/run/archiso/bootmnt/';
+                this.squashfs = `arch/x86_64/airootfs.sfs`;
+                /**
+                 * Debian jessie
+                 */
+            }
+            else if (this.codenameId === 'jessie') {
+                this.distroLike = 'Debian';
+                this.codenameLikeId = 'jessie';
+                this.liveMediumPath = '/lib/live/mount/medium/';
+                this.isCalamaresAvailable = false;
+                /**
+                 * Debian stretch
+                 */
+            }
+            else if (this.codenameId === 'stretch') {
+                this.distroLike = 'Debian';
+                this.codenameLikeId = 'stretch';
+                this.liveMediumPath = '/lib/live/mount/medium/';
+                this.isCalamaresAvailable = false;
+                /**
+                 * Debian buster
+                 */
+            }
+            else if (this.codenameId === 'buster') {
+                this.distroLike = 'Debian';
+                this.codenameLikeId = 'buster';
+                /**
+                 * Debian bullseye
+                 */
+            }
+            else if (this.codenameId === 'bullseye') {
+                this.distroLike = 'Debian';
+                this.codenameLikeId = 'bullseye';
+                /**
+                 * Debian bookworm
+                 */
+            }
+            else if (this.codenameId === 'bookworm') {
+                this.distroLike = 'Debian';
+                this.codenameLikeId = 'bookworm';
+                /**
+                 * Debian trixie
+                 */
+            }
+            else if (this.codenameId === 'trixie') {
+                this.distroLike = 'Debian';
+                this.codenameLikeId = 'trixie';
+                /**
+                 * Devuan beowulf
+                 */
+            }
+            else if (this.codenameId === 'beowulf') {
+                this.distroLike = 'Devuan';
+                this.codenameLikeId = 'beowulf';
+                /**
+                 * Devuan chimaera
+                 */
+            }
+            else if (this.codenameId === 'chimaera') {
+                this.distroLike = 'Devuan';
+                this.codenameLikeId = 'chimaera';
+                /**
+                 * Devuan daedalus
+                 */
+            }
+            else if (this.codenameId === 'daedalus') {
+                this.distroLike = 'Devuan';
+                this.codenameLikeId = 'daedalus';
+                /**
+                 * Devuan excalibur
+                 */
+            }
+            else if (this.codenameId === 'excalibur') {
+                this.distroLike = 'Devuan';
+                this.codenameLikeId = 'excalibur';
+                /**
+                 * Ubuntu bionic
+                 */
+            }
+            else if (this.codenameId === 'bionic') {
+                this.distroLike = 'Ubuntu';
+                this.codenameLikeId = 'bionic';
+                this.liveMediumPath = '/lib/live/mount/medium/';
+                /**
+                 * Ubuntu focal
+                 */
+            }
+            else if (this.codenameId === 'focal') {
+                this.distroLike = 'Ubuntu';
+                this.codenameLikeId = 'focal';
+                /**
+                 * Ubuntu jammy
+                 */
+            }
+            else if (this.codenameId === 'jammy') {
+                this.distroLike = 'Ubuntu';
+                this.codenameLikeId = 'jammy';
+                /**
+                 * Ubuntu noble
+                 */
+            }
+            else if (this.codenameId === 'noble') {
+                this.distroLike = 'Ubuntu';
+                this.codenameLikeId = 'noble';
+                /**
+                 * Ubuntu devel
+                 */
+            }
+            else if (this.codenameId === 'devel') {
+                this.distroLike = 'Ubuntu';
+                this.codenameLikeId = 'devel';
+            }
+            else {
+                /**
+                 * patch per Roy VERIFICARE
+                 */
+                let file = path.resolve(__dirname, '../../conf/derivatives.yaml');
+                if (fs.existsSync('/etc/penguins-eggs.d/derivatives.yaml')) {
+                    file = '/etc/penguins-eggs.d/derivatives.yaml';
+                }
+                const content = fs.readFileSync(file, 'utf8');
+                const distros = yaml.load(content);
+                for (const distro of distros) {
+                    if (distro.ids !== undefined) {
+                        for (let n = 0; n < distro.ids.length; n++) {
+                            if (this.codenameId === distro.ids[n]) {
+                                found = true;
+                                this.distroLike = distro.distroLike;
+                                this.codenameLikeId = distro.id;
+                                this.familyId = distro.family;
+                            }
+                        }
+                    }
+                }
+                if (!found) {
+                    console.log(`This distro ${this.distroId}/${this.codenameId} is not yet recognized!`);
+                    console.log('');
+                    console.log('You can edit /usr/lib/penguins-eggs/conf/derivatives.yaml to add it -');
+                    console.log('after that - run: sudo eggs dad -d to re-configure eggs.');
+                    console.log('If you can create your new iso, you can contribute to the project');
+                    console.log('by suggesting your modification.');
+                    process.exit(0);
+                }
+            }
+        }
+        /**
+         * Ultimi ritocchi
+         */
+        /**
+         * Debian: /usr/lib/x86_64-linux-gnu
+         *         /usr/lib/aarch64-linux-gnu
+         */
+        if (this.familyId === "debian") {
+            this.usrLibPath = '/usr/lib/' + Utils.usrLibPath();
+        }
+        else if (this.familyId === "opensuse") {
+            this.usrLibPath = '/usr/lib64/';
+        }
+        /**
+         * ManjaroLinux e derivate
+         */
+        if (Diversions.isManjaroBased(this.distroId)) {
+            this.liveMediumPath = '/run/miso/bootmnt/';
+            this.squashfs = 'manjaro/x86_64/livefs.sfs';
+        }
+        /**
+         * lettura os_release per i pulsanti
+         */
+        const os_release = '/etc/os-release';
+        if (fs.existsSync(os_release)) {
+            let lines = [];
+            if (fs.existsSync(os_release)) {
+                const data = fs.readFileSync(os_release, 'utf8');
+                lines = data.split('\n');
+            }
+            // per ogni riga
+            for (const line of lines) {
+                if (line.startsWith('HOME_URL=')) {
+                    this.homeUrl = line.slice('HOME_URL='.length).replaceAll('"', '');
+                }
+                else if (line.startsWith('SUPPORT_URL=')) {
+                    this.supportUrl = line.slice('SUPPORT_URL='.length).replaceAll('"', '');
+                }
+                else if (line.startsWith('BUG_REPORT_URL=')) {
+                    this.bugReportUrl = line.slice('BUG_REPORT_URL='.length).replaceAll('"', '');
+                }
+            }
+        }
+    }
+}
+export default Distro;