penguins-eggs 25.10.3 → 25.10.19

package/dist/classes/diversions.js

@@ -0,0 +1,152 @@
+/**
+ * ./src/classes/diversions.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import Distro from './distro.js';
+import Pacman from './pacman.js';
+export default class Diversions {
+    /**
+     *
+     * @param familyId
+     * @returns
+     */
+    static isSystemDBoot(familyId, isEfi) {
+        let isSystemDBoot = false;
+        if (familyId === 'fedora' && isEfi) {
+            isSystemDBoot = true;
+        }
+        return isSystemDBoot;
+    }
+    /**
+     *
+     * @param familyId
+     * @returns deluser
+     */
+    static deluser(familyId) {
+        let deluser = 'deluser';
+        if (familyId === 'aldos' ||
+            familyId === 'archlinux' ||
+            familyId === 'fedora' ||
+            familyId === 'openmamba' ||
+            familyId === 'opensuse' ||
+            familyId === 'voidlinux') {
+            deluser = 'userdel';
+        }
+        return deluser;
+    }
+    /**
+     *
+     * @param familyId
+     * @returns
+     */
+    static grubName(familyId) {
+        let grubName = 'grub';
+        if (familyId === 'aldos' ||
+            familyId === 'fedora' ||
+            familyId === 'opensuse') {
+            grubName = 'grub2';
+        }
+        return grubName;
+    }
+    /**
+     * grubForce
+     */
+    static grubForce(familyId) {
+        let grubForce = '';
+        if (familyId === 'aldos' || familyId === 'fedora') {
+            grubForce = '--force';
+        }
+        return grubForce;
+    }
+    /**
+     *
+     * @param familyId
+     * @param volid
+     * @returns
+     */
+    static kernelParameters(familyId, volid, luksUuid = '') {
+        // GRUB_CMDLINE_LINUX='ipv6.disable=1'
+        let kp = "";
+        if (familyId === 'alpine') {
+            kp += `alpinelivelabel=${volid} alpinelivesquashfs=/mnt/live/filesystem.squashfs`;
+        }
+        else if (familyId === 'archlinux') {
+            kp += `boot=live components locales=${process.env.LANG}`;
+            const distroId = this.distro().distroId;
+            if (this.isManjaroBased(distroId)) {
+                kp += ` misobasedir=manjaro misolabel=${volid}`;
+            }
+            else {
+                kp += ` archisobasedir=arch archisolabel=${volid}`;
+            }
+        }
+        else if (familyId === 'debian') {
+            /**
+             * da rivedere dracut/initramfs
+             */
+            if (Pacman.packageIsInstalled('dracut')) {
+                if (luksUuid !== '') {
+                    let append = `boot=live \
+                  root=live:LABEL=${volid} \
+                  rd.luks.loop=/live/luks.img \
+                  eggs.luks.uuid=${luksUuid} \
+                  rd.live.squashimg=filesystem.squashfs \
+                  rd.live.overlay.overlayfs=1 \
+                  nomodeset \
+                  rd.break=pre-mount \
+                  rd.shell`;
+                    kp += append.replaceAll(/\s\s+/g, ' ');
+                }
+                else {
+                    // dracut: rd.live.squashimg
+                    kp += `root=live:CDLABEL=${volid} rd.live.image rd.live.dir=/live rd.live.squashimg=filesystem.squashfs`;
+                }
+            }
+            else {
+                kp += `boot=live components locales=${process.env.LANG} cow_spacesize=2G`;
+            }
+        }
+        else if (familyId === 'fedora') {
+            kp += `root=live:CDLABEL=${volid} rd.live.image rd.live.dir=/live rd.live.squashimg=filesystem.squashfs selinux=0`;
+        }
+        else if (familyId === 'openmamba') {
+            kp += `root=live:CDLABEL=${volid} rd.live.image rd.live.dir=/live rd.live.squashimg=filesystem.squashfs selinux=0`;
+        }
+        else if (familyId === 'opensuse') {
+            kp += `root=live:CDLABEL=${volid} rd.live.image rd.live.dir=/live rd.live.squashimg=filesystem.squashfs apparmor=0`;
+        }
+        else if (familyId === 'voidlinux') {
+            kp += `root=live:CDLABEL=${volid} rd.live.image rd.live.dir=/live rd.live.squashimg=filesystem.squashfs rd.debug`;
+        }
+        return kp;
+    }
+    /**
+       *
+       * @returns
+       */
+    static distro() {
+        return new Distro();
+    }
+    /**
+    * isManjaroBased
+    */
+    static isManjaroBased(distro) {
+        let found = false;
+        if (distro === 'Manjaro' ||
+            distro === `Biglinux` ||
+            distro === `Bigcommunity`) {
+            found = true;
+        }
+        return found;
+    }
+    static bootloaders(familyId) {
+        let bootloaders = '/usr/lib/';
+        if (familyId !== 'debian') {
+            bootloaders = '/usr/lib/penguins-eggs/bootloaders/';
+        }
+        return bootloaders;
+    }
+}

package/dist/classes/incubation/branding.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ./src/classes/incubation/branding.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import { IDistro, IRemix } from '../../interfaces/index.js';
+/**
+ *
+ * @param remix
+ * @param distro
+ * @param theme
+ * @param verbose
+ * @returns
+ */
+export declare function branding(remix: IRemix, distro: IDistro, theme?: string, verbose?: boolean): string;

package/dist/classes/incubation/branding.js

@@ -0,0 +1,85 @@
+/**
+ * ./src/classes/incubation/branding.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import yaml from 'js-yaml';
+/**
+ *
+ * @param remix
+ * @param distro
+ * @param theme
+ * @param verbose
+ * @returns
+ */
+export function branding(remix, distro, theme = '', verbose = false) {
+    const { bugReportUrl, homeUrl, supportUrl } = distro;
+    // Li ridenomino per calamares
+    const productUrl = homeUrl;
+    // const supportUrl= supportUrl
+    const releaseNotesUrl = bugReportUrl;
+    const knownIssuesUrl = 'https://github.com/pieroproietti/penguins-eggs/issues/';
+    const productName = remix.versionName; // Questa va nel titolo ed in basso
+    const shortProductName = remix.fullname;
+    const today = new Date();
+    const version = today.toISOString().split('T')[0]; // 2021-09-30
+    const shortVersion = version.split('-').join('.'); // 2021.09.30
+    const versionedName = remix.fullname + ' (' + shortVersion + ')';
+    const shortVersionedName = remix.versionName + ' ' + version;
+    /**
+     * some distros: Devuan, LMDE, syslinuxos
+     * must have: bootloaderEntryName=Debian
+     * to work on EFI
+     */
+    let bootloaderEntryName = '';
+    const distroId = distro.distroId.toLowerCase();
+    if (distroId === 'devuan' || distroId === 'lmde' || distroId === 'syslinuxos') {
+        bootloaderEntryName = 'Debian';
+    }
+    else {
+        bootloaderEntryName = distro.distroId;
+    }
+    const productLogo = `${remix.branding}-logo.png`;
+    const productIcon = `${remix.branding}-logo.png`;
+    const productWelcome = 'welcome.png';
+    const slideshow = 'show.qml';
+    const branding = {
+        componentName: remix.branding,
+        images: {
+            productIcon,
+            productLogo,
+            productWelcome
+        },
+        slideshow,
+        slideshowAPI: 1,
+        strings: {
+            bootloaderEntryName,
+            knownIssuesUrl,
+            productName,
+            productUrl,
+            releaseNotesUrl,
+            shortProductName,
+            shortVersion,
+            shortVersionedName,
+            supportUrl,
+            version,
+            versionedName
+        },
+        style: {
+            // 3.3.x
+            SidebarBackground: '#292F34',
+            SidebarBackgroundCurrent: '#D35400',
+            SidebarText: '#FFFFFF',
+            SidebarTextCurrent: '#292F34',
+            // 3.2.x
+            sidebarBackground: '#292F34',
+            sidebarBackgroundCurrent: '#D35400',
+            sidebarText: '#FFFFFF',
+            sidebarTextCurrent: '#292F34'
+        },
+        welcomeStyleCalamares: true
+    };
+    return yaml.dump(branding);
+}

package/dist/classes/incubation/customize/customize-partitions.d.ts

@@ -0,0 +1,4 @@
+/**
+ *
+ */
+export declare function customizePartitions(): Promise<void>;

package/dist/classes/incubation/customize/customize-partitions.js

@@ -0,0 +1,29 @@
+import fs from 'node:fs';
+import Pacman from '../../pacman.js';
+import yaml from 'js-yaml';
+import { exec } from '../../../lib/utils.js';
+/**
+ *
+ */
+export async function customizePartitions() {
+    const filePartition = '/etc/calamares/modules/partition.conf';
+    const partition = yaml.load(fs.readFileSync(filePartition, 'utf8'));
+    // detect filesystem type
+    let test = await exec(`df -T / | awk 'NR==2 {print $2}'`, { capture: true, echo: false });
+    partition.defaultFileSystemType = test.data.trim();
+    /**
+     * Determino i filesystem disponibili
+     */
+    partition.availableFileSystemTypes = ['ext4'];
+    if (Pacman.packageIsInstalled('btrfs-progs') ||
+        Pacman.packageIsInstalled('btrfsprogs')) {
+        partition.availableFileSystemTypes.push('btrfs');
+    }
+    if (Pacman.packageIsInstalled('xfsprogs')) {
+        partition.availableFileSystemTypes.push('xfs');
+    }
+    if (Pacman.packageIsInstalled('f2fs-tools')) {
+        partition.availableFileSystemTypes.push('f2fs');
+    }
+    fs.writeFileSync(filePartition, yaml.dump(partition), 'utf-8');
+}

package/dist/classes/incubation/fisherman-helper/initcpio.d.ts

@@ -0,0 +1 @@
+export declare function initcpio(): Promise<string>;

package/dist/classes/incubation/fisherman-helper/initcpio.js

@@ -0,0 +1,69 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { access } from 'fs/promises';
+const execAsync = promisify(exec);
+export async function initcpio() {
+    try {
+        const { stdout: kernelVersion } = await execAsync('uname -r');
+        const version = kernelVersion.trim();
+        // Manjaro
+        if (version.includes('MANJARO')) {
+            try {
+                // Estrai major e minor version. Es: da "6.12.48-1-MANJARO" -> ["6", "12", "48-1-MANJARO"]
+                const parts = version.split('.');
+                // Costruisci il nome del preset come "linux" + "6" + "12" -> "linux612"
+                const kernelName = `linux${parts[0]}${parts[1]}`;
+                const manjaroPreset = `/etc/mkinitcpio.d/${kernelName}.preset`;
+                await access(manjaroPreset); // Verifica se esiste /etc/mkinitcpio.d/linux612.preset
+                return manjaroPreset; // Se esiste, lo restituisce e la funzione termina
+            }
+            catch {
+                // Se anche questa logica fallisce, lascia che proceda al fallback per Arch
+                // console.warn('Logica Manjaro fallita, si tenta il fallback per Arch...');
+            }
+        }
+        else if (version.includes('cachyos')) {
+            try {
+                let kernelType = 'linux-cachyos'; // default
+                if (version.includes('lts')) {
+                    kernelType = 'linux-cachyos-lts';
+                }
+                else if (version.includes('zen')) {
+                    kernelType = 'linux-cachyos-zen';
+                }
+                else if (version.includes('hardened')) {
+                    kernelType = 'linux-hardened';
+                }
+                const cachyPreset = `/etc/mkinitcpio.d/${kernelType}.preset`;
+                await access(cachyPreset);
+                return cachyPreset;
+            }
+            catch {
+                // Se anche questa logica fallisce, lascia che proceda al fallback per Arch
+                // console.warn('Logica Manjaro fallita, si tenta il fallback per Arch...');
+            }
+        }
+        /**
+         * FALLBACK ARCH
+         */
+        // Determina il tipo di kernel
+        let kernelType = 'linux'; // default
+        if (version.includes('lts')) {
+            kernelType = 'linux-lts';
+        }
+        else if (version.includes('zen')) {
+            kernelType = 'linux-zen';
+        }
+        else if (version.includes('hardened')) {
+            kernelType = 'linux-hardened';
+        }
+        const archPreset = `/etc/mkinitcpio.d/${kernelType}.preset`;
+        // Verifica che esista
+        await access(archPreset);
+        return archPreset;
+    }
+    catch (error) {
+        // Rimuoviamo l'errore originale dalla stringa per un messaggio più pulito
+        throw new Error(`Impossibile trovare un file .preset valido in /etc/mkinitcpio.d/`);
+    }
+}

package/dist/classes/incubation/fisherman-helper/packages.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ./src/classes/incubation/fisherman-helper/packages.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import { IDistro } from '../../../interfaces/index.js';
+/**
+ *
+ * @param distro
+ * @returns yaml-string
+ */
+export declare function remove(distro: IDistro): string;
+/**
+ *
+ * @param distro
+ * @returns yaml-string
+ */
+export declare function tryInstall(distro: IDistro): string;

package/dist/classes/incubation/fisherman-helper/packages.js

@@ -0,0 +1,72 @@
+/**
+ * ./src/classes/incubation/fisherman-helper/packages.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import Pacman from '../../pacman.js';
+/**
+ *
+ * @param distro
+ * @returns yaml-string
+ */
+export function remove(distro) {
+    const packages = ['calamares-eggs', 'calamares'];
+    if (distro.familyId === 'archlinux') {
+        packages.push('penguins-eggs');
+    }
+    if (distro.familyId === 'debian') {
+        packages.push('penguins-eggs', 'live-boot', 'live-boot-doc', 'live-boot-initramfs-tools', 'live-tools');
+    }
+    const installedPackages = [];
+    for (const elem of packages) {
+        if (Pacman.packageIsInstalled(elem)) {
+            installedPackages.push(elem);
+        }
+    }
+    installedPackages.sort();
+    let yaml = '';
+    for (const elem of installedPackages) {
+        yaml += `  - ${elem.trim()}\n`;
+    }
+    if (yaml !== '') {
+        yaml = '- try_remove:\n' + yaml;
+    }
+    return yaml;
+}
+/**
+ *
+ * @param distro
+ * @returns yaml-string
+ */
+export function tryInstall(distro) {
+    let yaml = '';
+    /**
+     * Depending on the distro
+     */
+    if (distro.distroLike === 'Ubuntu') {
+        yaml += '  - language-pack-$LOCALE\n';
+    }
+    // Da localizzare se presenti
+    if (Pacman.packageIsInstalled('hunspell')) {
+        yaml += '  - hunspell-$LOCALE\n';
+    }
+    if (Pacman.packageIsInstalled('libreoffice-base-core')) {
+        yaml += '  - libreoffice-l10n-$LOCALE\n';
+        yaml += '  - libreoffice-help-$LOCALE\n';
+    }
+    if (Pacman.packageIsInstalled('firefox-esr')) {
+        yaml += '  - firefox-esr-$LOCALE\n';
+    }
+    if (Pacman.packageIsInstalled('firefox')) {
+        yaml += '  - firefox-$LOCALE\n';
+    }
+    if (Pacman.packageIsInstalled('thunderbird')) {
+        yaml += '  - thunderbird-locale-$LOCALE\n';
+    }
+    if (yaml !== '') {
+        yaml = '- try_install:\n' + yaml;
+    }
+    return yaml;
+}

package/dist/classes/incubation/fisherman-helper/settings.d.ts

@@ -0,0 +1,15 @@
+/**
+ * ./src/classes/incubation/fisherman-helper/settings.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+/**
+ *
+ * @param src
+ * @param dest
+ * @param theme
+ * @param isClone
+ */
+export declare function settings(src: string, dest: string, theme?: string, isClone?: boolean): Promise<void>;

package/dist/classes/incubation/fisherman-helper/settings.js

@@ -0,0 +1,116 @@
+/**
+ * ./src/classes/incubation/fisherman-helper/settings.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+/**
+ *
+ * @param theme
+ * @param isClone
+ */
+import yaml from 'js-yaml';
+import fs from 'node:fs';
+import shx from 'shelljs';
+import Utils from '../../utils.js';
+import { installer } from '../installer.js';
+/**
+ *
+ * @param src
+ * @param dest
+ * @param theme
+ * @param isClone
+ */
+export async function settings(src, dest, theme = 'eggs', isClone = false) {
+    let branding = theme;
+    const settingsSrc = src + 'settings.yml';
+    if (theme.includes('/')) {
+        branding = theme.slice(Math.max(0, theme.lastIndexOf('/') + 1));
+    }
+    const settingsDest = dest + 'settings.conf';
+    const contentSrc = fs.readFileSync(settingsSrc, "utf-8");
+    const yamlDest = yaml.load(contentSrc);
+    // Trova gli elementi in modo sicuro
+    const showSequenceItem = yamlDest.sequence.find(item => item.show);
+    const execSequenceItem = yamlDest.sequence.find(item => item.exec);
+    if (!showSequenceItem || !execSequenceItem) {
+        throw new Error("Impossibile trovare le sezioni 'show' o 'exec' nel file settings.yml");
+    }
+    // Il '!' dice a TS: "sono sicuro che non è undefined"
+    let showModules = showSequenceItem.show;
+    let execModules = execSequenceItem.exec;
+    // Filtra la lista (ora con type safety)
+    if (!Utils.isSystemd()) {
+        execModules = execModules.filter(module => module !== 'machineid' && module !== 'services-systemd');
+    }
+    // if (displaymanager()) {
+    //   execModules = execModules.filter(module => module !== 'displaymanager')
+    // }
+    if (isClone) {
+        execModules = execModules.filter(module => module !== 'users');
+        showModules = showModules.filter(module => module !== 'users');
+    }
+    // Riassegna gli array
+    showSequenceItem.show = showModules;
+    execSequenceItem.exec = execModules;
+    yamlDest.branding = branding;
+    const contentDeest = yaml.dump(yamlDest);
+    fs.writeFileSync(settingsDest, contentDeest);
+    /*
+    shx.cp(settingsSrc, settingsDest)
+    let hasSystemd = '# '
+    if (Utils.isSystemd()) {
+      hasSystemd = '- '
+    }
+  
+    let createUsers = '- '
+    if (isClone) {
+      createUsers = '# '
+    }
+  
+    let hasDisplaymanager = '# '
+    if (displaymanager().length > 0) {
+      hasDisplaymanager = '- '
+    }
+  
+    shx.sed('-i', '{{hasSystemd}}', hasSystemd, settingsDest)
+    shx.sed('-i', '{{hasDisplaymanager}}', hasDisplaymanager, settingsDest)
+    shx.sed('-i', '{{branding}}', branding, settingsDest)
+    shx.sed('-i', '{{createUsers}}', createUsers, settingsDest)
+  
+    */
+    /**
+     * cfsAppend
+     */
+    const cfsPath = `${theme}/theme/calamares/cfs.yml`;
+    if (fs.existsSync(cfsPath)) {
+        cfsAppend(cfsPath);
+    }
+}
+/**
+ *
+ */
+function cfsAppend(cfs) {
+    const configRoot = installer().configRoot + 'settings.conf';
+    const soContent = fs.readFileSync(configRoot, 'utf8');
+    const so = yaml.load(soContent);
+    const cfsContent = fs.readFileSync(cfs, 'utf8');
+    const cfsSteps = yaml.load(cfsContent);
+    const execSteps = so.sequence[1].exec;
+    for (const execStep of execSteps) {
+        if (execStep.includes('umount')) {
+            so.sequence[1].exec.pop(); // OK remove umount
+            /**
+             * insert cfsStep
+             */
+            for (const cfsStep of cfsSteps) {
+                so.sequence[1].exec.push(cfsStep);
+            }
+            so.sequence[1].exec.push('end-cfs'); // we will replace with umount
+        }
+    }
+    // ***
+    fs.writeFileSync(configRoot, yaml.dump(so), 'utf-8');
+    shx.sed('-i', 'end-cfs', 'umount', configRoot);
+}

package/dist/classes/incubation/fisherman.d.ts

@@ -0,0 +1,71 @@
+import { IDistro, IInstaller } from '../../interfaces/index.js';
+export default class Fisherman {
+    distro: IDistro;
+    installer: IInstaller;
+    verbose: boolean;
+    constructor(distro: IDistro, installer: IInstaller, verbose?: boolean);
+    /**
+     *
+     * @param name
+     * @param isScript
+     */
+    buildCalamaresModule(name: string, isScript?: boolean, theme?: string): Promise<string>;
+    /**
+     *
+     * @param name
+     */
+    buildCalamaresPy(name: string): Promise<void>;
+    /**
+     *
+     * @param name
+     * @param replaces [['search','replace']]
+     */
+    buildModule(name: string, vendor?: string): Promise<void>;
+    /**
+     *
+     * @param name
+     */
+    contextualprocess(name: string): Promise<void>;
+    /**
+     * write settings
+     */
+    createCalamaresSettings(theme?: string, isClone?: boolean): Promise<void>;
+    /**
+     *
+     * @param name
+     */
+    shellprocess(name: string): Promise<void>;
+    /**
+     *
+     * @param module
+     * @param type
+     * @param path
+     */
+    show(name: string, type: string, path: string): void;
+    /**
+    * ====================================================================================
+    * buildModule...
+    * ====================================================================================
+    */
+    /**
+     * buildModuleDracut
+     */
+    buildModuleDracut(initrd: string): Promise<void>;
+    buildModuleInitcpio(): Promise<void>;
+    /**
+     * buildModuleFinished
+     */
+    buildModuleFinished(): Promise<void>;
+    /**
+     * buildModulePackages
+     */
+    buildModulePackages(distro: IDistro, release?: boolean): Promise<void>;
+    /**
+     * buildModuleRemoveuser
+     */
+    buildModuleRemoveuser(username: string): Promise<void>;
+    /**
+     * buildModuleUnpackfs
+     */
+    buildModuleUnpackfs(): Promise<void>;
+}