penguins-eggs 25.10.28 → 25.11.8

package/dist/classes/diversions.js

@@ -0,0 +1,100 @@
+/**
+ * ./src/classes/diversions.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti (modified by Hossein Seilani)
+ * license: MIT
+ *
+ * NEW VERSION: Improved and cleaned with detailed comments and new changes
+ */
+import Distro from './distro.js';
+export default class Diversions {
+    // NEW CHANGE [1]
+    // Made isSystemDBoot more readable by using direct return without extra variable.
+    // Simplified logic for clarity.
+    static isSystemDBoot(familyId, isEfi) {
+        return familyId === 'fedora' && isEfi;
+    }
+    // NEW CHANGE [2]
+    // Simplified deluser function using array.includes and default value.
+    // This makes adding new families easier and avoids long OR chains.
+    static deluser(familyId) {
+        const userdelFamilies = ['aldos', 'archlinux', 'fedora', 'openmamba', 'opensuse', 'voidlinux'];
+        return userdelFamilies.includes(familyId) ? 'userdel' : 'deluser';
+    }
+    // NEW CHANGE [3]
+    // Improved grubName using array.includes and direct return
+    // Cleaner, easier to maintain if new families are added
+    static grubName(familyId) {
+        const grub2Families = ['aldos', 'fedora', 'opensuse'];
+        return grub2Families.includes(familyId) ? 'grub2' : 'grub';
+    }
+    // NEW CHANGE [4]
+    // Simplified grubForce function with array.includes
+    // Provides explicit "--force" only for specific families
+    static grubForce(familyId) {
+        const forceFamilies = ['aldos', 'fedora'];
+        return forceFamilies.includes(familyId) ? '--force' : '';
+    }
+    // NEW CHANGE [5]
+    // Improved kernelParameters function:
+    // - Use template literals consistently
+    // - Reduce redundant code
+    // - Added optional `fullCrypt` handling for debian
+    static kernelParameters(familyId, volid, fullCrypt = false) {
+        let kp = '';
+        switch (familyId) {
+            case 'alpine':
+                kp += `alpinelivelabel=${volid} alpinelivesquashfs=/mnt/live/filesystem.squashfs`;
+                break;
+            case 'archlinux': {
+                const distroId = this.distro().distroId;
+                kp += `boot=live components locales=${process.env.LANG}`;
+                if (this.isManjaroBased(distroId)) {
+                    kp += ` misobasedir=manjaro misolabel=${volid}`;
+                }
+                else {
+                    kp += ` archisobasedir=arch archisolabel=${volid}`;
+                }
+                break;
+            }
+            case 'debian':
+                kp += `boot=live components locales=${process.env.LANG} cow_spacesize=2G`;
+                if (fullCrypt)
+                    kp += ` live-media=/run/live/medium`;
+                break;
+            case 'fedora':
+            case 'openmamba':
+                kp += `root=live:CDLABEL=${volid} rd.live.image rd.live.dir=/live rd.live.squashimg=filesystem.squashfs selinux=0`;
+                break;
+            case 'opensuse':
+                kp += `root=live:CDLABEL=${volid} rd.live.image rd.live.dir=/live rd.live.squashimg=filesystem.squashfs apparmor=0`;
+                break;
+            case 'voidlinux':
+                kp += `root=live:CDLABEL=${volid} rd.live.image rd.live.dir=/live rd.live.squashimg=filesystem.squashfs rd.debug`;
+                break;
+            default:
+                kp += '';
+                break;
+        }
+        return kp;
+    }
+    // NEW CHANGE [6]
+    // Centralized creation of Distro instance
+    // Ensures only one point of modification for Distro
+    static distro() {
+        return new Distro();
+    }
+    // NEW CHANGE [7]
+    // Simplified isManjaroBased function using array.includes
+    // Makes it easier to maintain and extend to new derivatives
+    static isManjaroBased(distro) {
+        const manjaroFamilies = ['Manjaro', 'Biglinux', 'Bigcommunity'];
+        return manjaroFamilies.includes(distro);
+    }
+    // NEW CHANGE [8]
+    // bootloaders path handling improved
+    // Default path for debian, custom path for all other families
+    static bootloaders(familyId) {
+        return familyId === 'debian' ? '/usr/lib/' : '/usr/lib/penguins-eggs/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,12 @@
+/**
+ * ./src/classes/incubation/customize/customize-partitions.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+/**
+ * customize module partition
+ * add/remove filesystem available
+ */
+export declare function customizePartitions(): Promise<void>;

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

@@ -0,0 +1,37 @@
+/**
+ * ./src/classes/incubation/customize/customize-partitions.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import fs from 'node:fs';
+import Pacman from '../../pacman.js';
+import yaml from 'js-yaml';
+import { exec } from '../../../lib/utils.js';
+/**
+ * customize module partition
+ * add/remove filesystem available
+ */
+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('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,76 @@
+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 name
+     */
+    helper(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>;
+}