penguins-eggs 10.0.28 → 10.0.30

package/dist/classes/distro.js

@@ -0,0 +1,346 @@
+/**
+ * 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';
+// _dirname
+const __dirname = path.dirname(new URL(import.meta.url).pathname);
+/**
+ * Classe
+ */
+class Distro {
+    bugReportUrl;
+    codenameId;
+    codenameLikeId;
+    distroId;
+    distroLike;
+    familyId;
+    homeUrl;
+    isCalamaresAvailable;
+    isolinuxPath;
+    liveMediumPath;
+    memdiskPath;
+    pxelinuxPath;
+    releaseId;
+    releaseLike;
+    squashfs;
+    supportUrl;
+    syslinuxPath;
+    usrLibPath;
+    /**
+     * Costruttore
+     */
+    constructor() {
+        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.isolinuxPath = '';
+        this.liveMediumPath = '/run/live/medium/';
+        this.memdiskPath = '';
+        this.pxelinuxPath = '';
+        this.releaseId = '';
+        this.releaseLike = '';
+        this.squashfs = 'live/filesystem.squashfs';
+        this.supportUrl = 'https://penguins-eggs.net';
+        this.syslinuxPath = '';
+        this.usrLibPath = '/usr/lib';
+        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('"', '');
+                }
+            }
+        }
+        /**
+         * 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();
+        /**
+         * releaseLike = releaseId
+         */
+        this.releaseLike = this.releaseId;
+        /**
+         * Per casi equivoci conviene normalizzare codenameId
+         *  -i, --id           show distributor ID
+         *  -r, --release      show release number of this distribution
+         *  -c, --codename     show code name of this distribution
+         */
+        if (this.distroId === 'Debian' && this.releaseId === 'unstable' && this.codenameId === 'sid') {
+            this.codenameId = 'trixie';
+        }
+        else if (this.distroId === 'Debian' && this.releaseId === 'testing/unstable') {
+            this.codenameId = 'trixie';
+            this.releaseLike = 'unstable';
+        }
+        /**
+         * Analize distroId
+         */
+        switch (this.distroId) {
+            case 'Alpine': {
+                this.familyId = 'alpine';
+                this.distroLike = 'Alpine';
+                this.codenameId = 'rolling'; // questo viene rimosso dal nome
+                this.codenameLikeId = 'alpine'; // prende alpine come codenaneLikeId
+                this.liveMediumPath = '/mnt/'; // Qua è deciso da noi
+                this.squashfs = `live/filesystem.squashfs`;
+                this.syslinuxPath = '/usr/share/syslinux/'; // correct
+                this.pxelinuxPath = this.syslinuxPath;
+                this.usrLibPath = '/usr/lib/';
+                this.memdiskPath = this.syslinuxPath;
+                this.isolinuxPath = this.syslinuxPath;
+                // At the moment
+                this.isCalamaresAvailable = true;
+                break;
+            }
+            case 'Fedora': {
+                this.familyId = 'fedora';
+                this.distroLike = 'Fedora';
+                this.codenameId = 'rolling';
+                this.codenameLikeId = '40';
+                this.liveMediumPath = '/run/install/repo/'; // ? è il mount della root su cd di installatione
+                this.squashfs = `live/filesystem.squashfs`;
+                this.syslinuxPath = '/usr/share/syslinux/';
+                this.pxelinuxPath = this.syslinuxPath;
+                this.usrLibPath = '/usr/lib/';
+                this.memdiskPath = this.syslinuxPath;
+                this.isolinuxPath = this.syslinuxPath;
+                // At the moment
+                this.isCalamaresAvailable = false;
+                break;
+            }
+            case 'openSUSE': {
+                this.familyId = 'suse';
+                this.distroLike = 'openSUSE';
+                this.codenameId = 'rolling';
+                this.codenameLikeId = 'Tumbleweed';
+                this.liveMediumPath = '/run/install/repo/'; // ? è il mount della root su cd di installatione
+                this.squashfs = `live/filesystem.squashfs`;
+                this.syslinuxPath = '/usr/share/syslinux/';
+                this.pxelinuxPath = this.syslinuxPath;
+                this.usrLibPath = '/usr/lib/';
+                this.memdiskPath = this.syslinuxPath;
+                this.isolinuxPath = this.syslinuxPath;
+                // At the moment
+                this.isCalamaresAvailable = false;
+                break;
+            }
+            default: {
+                /**
+                 * Arch/Debian/Devuan/Manjaro and Ubuntu
+                 */
+                switch (this.codenameId) {
+                    case 'jessie': {
+                        // Debian 8 jessie
+                        this.distroLike = 'Debian';
+                        this.codenameLikeId = 'jessie';
+                        this.liveMediumPath = '/lib/live/mount/medium/';
+                        this.isCalamaresAvailable = false;
+                        break;
+                    }
+                    case 'stretch': {
+                        // Debian 9 stretch
+                        this.distroLike = 'Debian';
+                        this.codenameLikeId = 'stretch';
+                        this.liveMediumPath = '/lib/live/mount/medium/';
+                        this.isCalamaresAvailable = false;
+                        break;
+                    }
+                    case 'buster': {
+                        // Debian 10 buster
+                        this.distroLike = 'Debian';
+                        this.codenameLikeId = 'buster';
+                        break;
+                    }
+                    case 'bullseye': {
+                        // Debian 11 bullseye
+                        this.distroLike = 'Debian';
+                        this.codenameLikeId = 'bullseye';
+                        break;
+                    }
+                    case 'bookworm': {
+                        // Debian 12 bookworm
+                        this.distroLike = 'Debian';
+                        this.codenameLikeId = 'bookworm';
+                        break;
+                    }
+                    case 'trixie': {
+                        // Debian 13 trixie
+                        this.distroLike = 'Debian';
+                        this.codenameLikeId = 'trixie';
+                        break;
+                    }
+                    case 'beowulf': {
+                        // Devuab 3 beowulf
+                        this.distroLike = 'Devuan';
+                        this.codenameLikeId = 'beowulf';
+                        break;
+                    }
+                    case 'chimaera': {
+                        // Devuab 4 chimaera
+                        this.distroLike = 'Devuan';
+                        this.codenameLikeId = 'chimaera';
+                        break;
+                    }
+                    case 'daedalus': {
+                        // Devuan 5 daedalus
+                        this.distroLike = 'Devuan';
+                        this.codenameLikeId = 'daedalus';
+                        break;
+                    }
+                    /**
+                     * Ubuntu LTS + actual
+                     */
+                    case 'bionic': {
+                        // Ubuntu 18.04 bionic LTS eol aprile 2023
+                        this.distroLike = 'Ubuntu';
+                        this.codenameLikeId = 'bionic';
+                        this.liveMediumPath = '/lib/live/mount/medium/';
+                        break;
+                    }
+                    case 'focal': {
+                        // Ubuntu 20.04 focal LTS
+                        this.distroLike = 'Ubuntu';
+                        this.codenameLikeId = 'focal';
+                        break;
+                    }
+                    case 'jammy': {
+                        // Ubuntu 22.04 jammy LTS
+                        this.distroLike = 'Ubuntu';
+                        this.codenameLikeId = 'jammy';
+                        break;
+                    }
+                    case 'noble': {
+                        // Ubuntu 24.04 noble LTS
+                        this.distroLike = 'Ubuntu';
+                        this.codenameLikeId = 'noble';
+                        break;
+                    }
+                    case 'devel': {
+                        // Ubuntu rhino
+                        this.distroLike = 'Ubuntu';
+                        this.codenameLikeId = 'devel';
+                        break;
+                    }
+                    /**
+                     * Arch Linux/Garuda
+                     */
+                    case 'Spizaetus':
+                    case 'n/a':
+                    case 'rolling': {
+                        this.familyId = 'archlinux';
+                        this.distroLike = 'Arch';
+                        this.codenameId = 'rolling';
+                        this.codenameLikeId = 'rolling';
+                        this.liveMediumPath = '/run/archiso/bootmnt/';
+                        this.squashfs = `arch/x86_64/airootfs.sfs`;
+                        break;
+                    }
+                    default: {
+                        /**
+                         * patch per Roy VERIFICARE
+                         */
+                        let found = false;
+                        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);
+                        }
+                    }
+                }
+                /**
+                 * setting paths: syslinux, isolinux, usrLibPath
+                 */
+                switch (this.familyId) {
+                    case 'debian': {
+                        this.isolinuxPath = '/usr/lib/ISOLINUX/';
+                        this.syslinuxPath = '/usr/lib/syslinux/modules/bios/';
+                        this.pxelinuxPath = '/usr/lib/PXELINUX/';
+                        this.memdiskPath = '/usr/lib/syslinux/';
+                        this.usrLibPath = '/usr/lib/' + Utils.usrLibPath();
+                        break;
+                    }
+                    case 'archlinux': {
+                        this.syslinuxPath = '/usr/lib/syslinux/bios/';
+                        this.pxelinuxPath = this.syslinuxPath;
+                        this.usrLibPath = '/usr/lib/';
+                        this.memdiskPath = this.syslinuxPath;
+                        this.isolinuxPath = this.syslinuxPath;
+                        break;
+                    }
+                    // No default
+                } // Fine analisi codenameId
+            }
+        }
+        /**
+         * if lsb-release exists
+         */
+        const lsbConfig = '/etc/lsb-release';
+        if (fs.existsSync(lsbConfig)) {
+            this.distroId = Utils.searchOnFile(lsbConfig, `DISTRIB_ID`);
+            this.codenameId = Utils.searchOnFile(lsbConfig, `DISTRIB_CODENAME`);
+            // patch for BigLinux
+            if (this.distroId.toLowerCase().includes('biglinux')) {
+                this.distroId = 'biglinux';
+            }
+        }
+        /**
+         * ManjaroLinux and BigLinux
+         */
+        if (this.distroId === 'ManjaroLinux' || this.distroId.toLowerCase().includes('biglinux')) {
+            this.liveMediumPath = '/run/miso/bootmnt/';
+            this.squashfs = 'manjaro/x86_64/livefs.sfs';
+        }
+    }
+}
+export default Distro;

package/dist/classes/families/alpine.d.ts

@@ -0,0 +1,55 @@
+/**
+ * ./src/classes/families/alpine.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+/**
+ * Alpine
+ * @remarks all the utilities
+ */
+export default class Alpine {
+    static packs4calamares: string[];
+    /**
+     * Alpine: calamaresInstall
+     */
+    static calamaresInstall(verbose?: boolean): Promise<void>;
+    /**
+     * Alpine: calamaresPolicies
+     */
+    static calamaresPolicies(verbose?: boolean): Promise<void>;
+    /**
+     * Alpine: calamaresRemove
+     */
+    static calamaresRemove(verbose?: boolean): Promise<boolean>;
+    /**
+     * Alpine: isInstalledWayland
+     * @returns true if wayland is installed
+     */
+    static isInstalledWayland(): boolean;
+    /**
+     * Alpine: isInstalledXorg
+     * @returns true if xorg is installed
+     */
+    static isInstalledXorg(): boolean;
+    /**
+     * Alpine: packageInstall
+     * Install the package packageName
+     * @param packageName {string} Pacchetto Debian da installare
+     * @returns {boolean} True if success
+     */
+    static packageInstall(packageName: string): Promise<boolean>;
+    /**
+     * Alpine: packageIsInstalled OK
+     * restuisce VERO se il pacchetto è installato
+     * @param packageName
+     */
+    static packageIsInstalled(packageName: string): boolean;
+    /**
+     * Alpine: packagePacmanAvailable
+     * restuisce VERO se il pacchetto è installato
+     * @param packageName
+     */
+    static packagePacmanAvailable(packageName: string): Promise<boolean>;
+}

package/dist/classes/families/alpine.js

@@ -0,0 +1,163 @@
+/**
+ * ./src/classes/families/alpine.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import shx from 'shelljs';
+import { exec } from '../../lib/utils.js';
+import Utils from '../utils.js';
+/**
+ * Alpine
+ * @remarks all the utilities
+ */
+export default class Alpine {
+    static packs4calamares = [
+        'calamares',
+        'calamares-doc',
+        'calamares-extensions',
+        'calamares-lang',
+        'calamares-mod-bootloader',
+        'calamares-mod-displaymanager',
+        'calamares-mod-finished',
+        'calamares-mod-fsresizer',
+        'calamares-mod-fstab',
+        'calamares-mod-grubcfg',
+        'calamares-mod-hostinfo',
+        'calamares-mod-hwclock',
+        'calamares-mod-interactiveterminal',
+        'calamares-mod-keyboard',
+        'calamares-mod-keyboardq',
+        'calamares-mod-locale',
+        'calamares-mod-localeq',
+        'calamares-mod-luksbootkeyfile',
+        'calamares-mod-luksopenswaphookcfg',
+        'calamares-mod-machineid',
+        'calamares-mod-mkinitfs',
+        'calamares-mod-mount',
+        'calamares-mod-networkcfg',
+        'calamares-mod-packages',
+        'calamares-mod-partition',
+        'calamares-mod-plasmalnf',
+        'calamares-mod-plymouthcfg',
+        'calamares-mod-removeuser',
+        'calamares-mod-services-openrc',
+        'calamares-mod-shellprocess',
+        'calamares-mod-summary',
+        'calamares-mod-umount',
+        'calamares-mod-unpackfs',
+        'calamares-mod-users',
+        'calamares-mod-webview',
+        'calamares-mod-welcome',
+        'calamares-mod-welcomeq'
+    ];
+    /**
+     * Alpine: calamaresInstall
+     */
+    static async calamaresInstall(verbose = false) {
+        const echo = Utils.setEcho(verbose);
+        let installed = false;
+        try {
+            const cmd = 'apk update';
+            await exec(cmd, echo);
+            installed = true;
+        }
+        catch {
+            Utils.error(`Alpine.calamaresInstall(): apk update `);
+        }
+        try {
+            const cmd = `apk add ${this.packs4calamares.join(' ')}`;
+            await exec(cmd, echo);
+        }
+        catch {
+            Utils.error(`Alpine.calamaresInstall(): apk add calamares ...`);
+        }
+    }
+    /**
+     * Alpine: calamaresPolicies
+     */
+    static async calamaresPolicies(verbose = true) {
+        const echo = Utils.setEcho(verbose);
+        const policyFile = '/usr/share/polkit-1/actions/com.github.calamares.calamares.policy';
+        await exec(`sed -i 's/auth_admin/yes/' ${policyFile}`, echo);
+    }
+    /**
+     * Alpine: calamaresRemove
+     */
+    static async calamaresRemove(verbose = true) {
+        const echo = Utils.setEcho(verbose);
+        let removed = false;
+        try {
+            const cmd = `apk del ${this.packs4calamares.join(' ')}`;
+            await exec(cmd, echo);
+            removed = true;
+        }
+        catch {
+            Utils.error(`Alpine.calamaresRemove(): apk del calamares ...`);
+        }
+        try {
+            const cmd = `rm /etc/calamares -rf`;
+            await exec(cmd, echo);
+        }
+        catch {
+            Utils.error(`Alpine.calamaresRemove(): rm /etc/calamares -rf`);
+        }
+        return removed;
+    }
+    /**
+     * Alpine: isInstalledWayland
+     * @returns true if wayland is installed
+     */
+    static isInstalledWayland() {
+        return this.packageIsInstalled('xwayland');
+    }
+    /**
+     * Alpine: isInstalledXorg
+     * @returns true if xorg is installed
+     */
+    static isInstalledXorg() {
+        return this.packageIsInstalled('xorg-server-common');
+    }
+    /**
+     * Alpine: packageInstall
+     * Install the package packageName
+     * @param packageName {string} Pacchetto Debian da installare
+     * @returns {boolean} True if success
+     */
+    static async packageInstall(packageName) {
+        let retVal = false;
+        if (shx.exec(`/sbin/apk add ${packageName}`, { silent: true }) === '0') {
+            retVal = true;
+        }
+        return retVal;
+    }
+    /**
+     * Alpine: packageIsInstalled OK
+     * restuisce VERO se il pacchetto è installato
+     * @param packageName
+     */
+    static packageIsInstalled(packageName) {
+        let installed = false;
+        const cmd = `/sbin/apk info -e ${packageName}`;
+        const stdout = shx.exec(cmd, { silent: true }).stdout.trim();
+        if (stdout.includes(packageName)) {
+            installed = true;
+        }
+        return installed;
+    }
+    /**
+     * Alpine: packagePacmanAvailable
+     * restuisce VERO se il pacchetto è installato
+     * @param packageName
+     */
+    static async packagePacmanAvailable(packageName) {
+        let available = false;
+        const cmd = `/sbin/apk search ${packageName} | awk '{ print $1 }'`;
+        const stdout = shx.exec(cmd, { silent: true }).stdout.trim();
+        if (stdout == packageName) {
+            available = true;
+        }
+        return available;
+    }
+}

package/dist/classes/families/archlinux.d.ts

@@ -0,0 +1,61 @@
+/**
+ * ./src/classes/families/archlinux.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+/**
+ * Archlinux
+ * @remarks all the utilities
+ */
+export default class Archlinux {
+    static packs4calamares: string[];
+    /**
+     * Archlinux: calamaresInstall
+     */
+    static calamaresInstall(verbose?: boolean): Promise<void>;
+    /**
+     * Archlinux: calamaresPolicies
+     */
+    static calamaresPolicies(): Promise<void>;
+    /**
+     * Archlinux: calamaresRemove
+     */
+    static calamaresRemove(verbose?: boolean): Promise<boolean>;
+    /**
+     * Archlinux: isInstalledWayland
+     * @returns true if wayland is installed
+     */
+    static isInstalledWayland(): boolean;
+    /**
+     * Archlinux: isInstalledXorg
+     * @returns true if xorg is installed
+     */
+    static isInstalledXorg(): boolean;
+    /**
+     * Archlinux: packageInstall
+     * Install the package packageName
+     * @param packageName {string} Pacchetto Debian da installare
+     * @returns {boolean} True if success
+     */
+    static packageInstall(packageName: string): Promise<boolean>;
+    /**
+     * Archlinux: packageIsInstalled
+     * restuisce VERO se il pacchetto è installato
+     * @param packageName
+     */
+    static packageIsInstalled(packageName: string): boolean;
+    /**
+     * Archlinux: packagePacmanAvailable
+     * restuisce VERO se il pacchetto è installato
+     * @param packageName
+     */
+    static packagePacmanAvailable(packageName: string): Promise<boolean>;
+    /**
+     * Archlinux: packagePacmanLast
+     * @param packageName
+     * @returns
+     */
+    static packagePacmanLast(packageName: string): Promise<string>;
+}