penguins-eggs 25.10.30 → 25.11.8

package/dist/classes/daddy.js

@@ -1,18 +1,15 @@
 /**
  * ./src/classes/daddy.ts
- * penguins-eggs v.25.7.x / ecmascript 2020
- * author: Piero Proietti
- * email: piero.proietti@gmail.com
+ * penguins-eggs v.25.7.x / ECMAScript 2020
+ * author: Piero Proietti (modified by Hossein Seilani)
  * license: MIT
  */
 import chalk from 'chalk';
 import inquirer from 'inquirer';
 import yaml from 'js-yaml';
-import fs from 'node:fs';
-// _dirname
+import fs from 'node:fs/promises';
 import path from 'node:path';
 import { exec } from '../lib/utils.js';
-// 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';
@@ -20,159 +17,191 @@ const __dirname = path.dirname(new URL(import.meta.url).pathname);
 export default class Daddy {
     settings = {};
     /**
-     * editConfif
-     * @param c
-     * @returns
+     * [CHANGE 1] Modular, type-safe, interactive configuration editor
+     * This method asks the user for LiveCD parameters using inquirer and returns
+     * a fully typed IEggsConfig object. It replaces the older JSON.stringify/parse approach.
      */
-    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;
+    async editConfig(config) {
+        console.log(chalk.cyan('Edit and save Live system parameters\n'));
+        // Determine default compression option
+        let compressionOpt;
+        switch (config.compression) {
+            case 'xz':
+                compressionOpt = 1;
+                break;
+            case 'xz -Xbcj x86':
+                compressionOpt = 2;
+                break;
+            default:
+                compressionOpt = 0;
+                break;
+        }
+        // Provide a default snapshot prefix if empty
+        if (!config.snapshot_prefix) {
+            config.snapshot_prefix = Utils.snapshotPrefix(this.settings.distro.distroId, this.settings.distro.codenameId);
         }
-        else if (c.compression === 'xz -Xbcj x86') {
-            compressionOpt = 2;
+        /**
+         *     // Define type-safe inquirer questions
+         * const questions: inquirer.QuestionCollection<IEggsConfig> = [
+         */
+        const questions = [
+            {
+                type: 'input',
+                name: 'snapshot_prefix',
+                message: 'LiveCD iso prefix: ',
+                default: config.snapshot_prefix,
+            },
+            {
+                type: 'input',
+                name: 'snapshot_basename',
+                message: 'LiveCD iso basename: ',
+                default: config.snapshot_basename,
+            },
+            {
+                type: 'input',
+                name: 'user_opt',
+                message: 'LiveCD user:',
+                default: config.user_opt,
+            },
+            {
+                type: 'input',
+                name: 'user_opt_passwd',
+                message: 'LiveCD user password:',
+                default: config.user_opt_passwd,
+            },
+            {
+                type: 'input',
+                name: 'root_passwd',
+                message: 'LiveCD root password:',
+                default: config.root_passwd,
+            },
+            {
+                type: 'list',
+                name: 'compression',
+                message: 'LiveCD compression: ',
+                choices: ['fast', 'max'],
+                default: compressionOpt,
+            },
+        ];
+        try {
+            // Prompt the user and return the typed config object
+            const answers = await inquirer.prompt(questions);
+            return answers;
         }
-        if (c.snapshot_prefix === '') {
-            c.snapshot_prefix = Utils.snapshotPrefix(this.settings.distro.distroId, this.settings.distro.codenameId);
+        catch (err) {
+            console.error(chalk.red('Error editing configuration:'), err);
+            throw err;
         }
-        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
+     * [CHANGE 2] Central method to manage environment, configuration and save
+     * This method is modular, type-safe, and handles:
+     * - Pacman and distro templates check
+     * - Load, reset, or apply custom configuration
+     * - Save configuration to disk
+     * - Provide clear guidance to the user
      */
     async helpMe(reset = false, isCustom = false, fileCustom = '', verbose = false) {
-        if (isCustom) {
-            console.log('using custom file:', fileCustom);
+        try {
+            if (isCustom)
+                console.log('Using custom file:', fileCustom);
+            // Step 1: Check system prerequisites
+            await this.checkPacman(verbose);
+            // Step 2: Load settings
+            this.settings = new Settings();
+            const loaded = await this.settings.load();
+            let config = loaded ? this.settings.config : {};
+            // Step 3: Apply reset or custom configuration
+            if (reset || isCustom) {
+                await this.applyResetOrCustomConfig(config, isCustom, fileCustom);
+            }
+            else {
+                config = await this.editConfig(config);
+            }
+            // Step 4: Save final configuration
+            await this.settings.save(config);
+            // Step 5: Display help messages
+            this.displayFinalHelp();
         }
-        // Controllo configurazione
+        catch (err) {
+            console.error(chalk.red('An error occurred in helpMe:'), err);
+        }
+    }
+    /**
+     * Check and install Pacman configuration and templates if missing
+     */
+    async checkPacman(verbose) {
         if (!Pacman.configurationCheck()) {
-            console.log('- creating configuration dir...');
+            console.log('- creating configuration directory...');
             await Pacman.configurationInstall(verbose);
         }
-        // Templates
         if (!Pacman.distroTemplateCheck()) {
-            console.log('- distro template install...');
+            console.log('- installing distro template...');
             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');
+        if (!Pacman.calamaresExists() && Pacman.isInstalledGui() && Pacman.isCalamaresAvailable()) {
+            console.log('- GUI system detected, 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) {
-                // add fstype to snapshot_prefix 
-                if (config.snapshot_prefix === '') {
-                    let fstype = ((await exec(`findmnt -n -o FSTYPE /`, { capture: true })).data.trim());
-                    if (fstype === 'ext4') {
-                        fstype = '';
-                    }
-                    else {
-                        // btrfs-, etc
-                        fstype += '-';
-                    }
-                    // excluded now
-                    fstype = '';
-                    config.snapshot_prefix = Utils.snapshotPrefix(this.settings.distro.distroId, this.settings.distro.codenameId) + fstype;
-                }
-                jsonConf = JSON.stringify(config);
-            }
-            else {
-                jsonConf = await this.editConfig(config);
+    }
+    /**
+     * Apply reset or custom configuration
+     */
+    async applyResetOrCustomConfig(config, isCustom, fileCustom) {
+        // Reset snapshot prefix if empty
+        if (!config.snapshot_prefix) {
+            let fstype = '';
+            try {
+                const { data } = await exec(`findmnt -n -o FSTYPE /`, { capture: true });
+                fstype = data.trim() === 'ext4' ? '' : `${data.trim()}-`;
             }
-            // 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);
+            catch (err) {
+                console.warn('Unable to detect FSTYPE:', err);
             }
-            // 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);
+            config.snapshot_prefix = Utils.snapshotPrefix(this.settings.distro.distroId, this.settings.distro.codenameId) + fstype;
+        }
+        // Apply custom YAML if needed
+        if (isCustom && fileCustom) {
+            await this.applyCustomYAML(config, fileCustom);
+        }
+    }
+    /**
+     * Load and apply a custom YAML configuration
+     * [CHANGE 3] Async reading of file and type-safe parsing
+     */
+    async applyCustomYAML(config, fileCustom) {
+        try {
+            const conf = await fs.readFile(fileCustom, 'utf8');
+            const confCustom = yaml.load(conf);
+            // Safely copy fields from YAML to config
+            config.snapshot_basename = confCustom.snapshot_basename ?? config.snapshot_basename;
+            config.snapshot_prefix = confCustom.snapshot_prefix ?? config.snapshot_prefix;
+            config.user_opt = confCustom.user_opt ?? config.user_opt;
+            config.user_opt_passwd = confCustom.user_opt_passwd ?? config.user_opt_passwd;
+            config.root_passwd = confCustom.root_passwd ?? config.root_passwd;
+            config.theme = confCustom.theme ?? config.theme;
         }
+        catch (err) {
+            console.error(chalk.red('Failed to load custom YAML config:'), err);
+            throw err;
+        }
+    }
+    /**
+     * Display final guidance and tips to the user
+     * [CHANGE 4] Modular, clear, user-friendly messages
+     */
+    displayFinalHelp() {
         console.log();
         console.log(chalk.cyan('Your configuration was saved on: /etc/penguins-eggs.d'));
+        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(`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(chalk.cyan('If you don’t have enough space to remaster, you can mount remote or local space:'));
+        console.log(chalk.cyan('- Create a hidden mountpoint under the nest:'));
+        console.log(chalk.white('sudo mkdir /home/eggs/.mnt -p'));
+        console.log(chalk.cyan('- 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-hossein.d.ts

@@ -0,0 +1,52 @@
+/**
+ * penguins-eggs
+ * class: distro.ts
+ * author: Piero Proietti (modified by Hossein Seilani)
+ * license: MIT
+ *
+ * FINAL VERSION WITH EXPLAINED COMMENTS AND NEW CHANGE TAGS
+ */
+import { IDistro } from '../interfaces/index.js';
+declare class Distro implements IDistro {
+    bugReportUrl: string;
+    codenameId: string;
+    distroUniqueId: string;
+    distroId: string;
+    distroLike: string;
+    familyId: string;
+    homeUrl: string;
+    isCalamaresAvailable: boolean;
+    liveMediumPath: string;
+    releaseId: string;
+    squashfs: string;
+    supportUrl: string;
+    syslinuxPath: string;
+    usrLibPath: string;
+    constructor();
+    /**
+     * NEW CHANGE6: Modular configuration for main distro types like Alpine, Fedora-family, etc.
+     * This simplifies the constructor and keeps distro-specific logic isolated.
+     */
+    private configureDistro;
+    /**
+     * NEW CHANGE12: Map Debian, Ubuntu, Devuan codenames to proper IDs and paths
+     * This avoids long if/else chains and allows easier future updates.
+     */
+    private debianFamily;
+    /**
+     * NEW CHANGE15: Async derivative detection from YAML files
+     * This allows future-proofing and easy updates for new distros.
+     */
+    private detectDerivatives;
+    /**
+     * NEW CHANGE16: Apply family-specific paths for usrLibPath, squashfs, and liveMediumPath
+     * Handles Debian, openSUSE, Manjaro and derivatives consistently.
+     */
+    private applyFamilySpecificPaths;
+    /**
+     * NEW CHANGE17: Load custom HOME, SUPPORT, BUG_REPORT URLs from /etc/os-release
+     * Allows overrides of default URLs for user-friendly experience.
+     */
+    private loadOSReleaseUrls;
+}
+export default Distro;

package/dist/classes/distro-hossein.js

@@ -0,0 +1,239 @@
+/**
+ * penguins-eggs
+ * class: distro.ts
+ * author: Piero Proietti (modified by Hossein Seilani)
+ * license: MIT
+ *
+ * FINAL VERSION WITH EXPLAINED COMMENTS AND NEW CHANGE TAGS
+ */
+import yaml from 'js-yaml';
+import fs from 'node:fs/promises';
+import fsSync from 'node:fs';
+import path from 'node:path';
+import shell from 'shelljs';
+import Utils from './utils.js';
+import Diversions from './diversions.js';
+const __dirname = path.dirname(new URL(import.meta.url).pathname);
+class Distro {
+    // NEW CHANGE 1: Added default values for all main distro properties to ensure proper initialization.
+    // This prevents undefined values in later logic and standardizes URLs and paths.
+    bugReportUrl = 'https://github.com-pieroproietti/penguins-eggs/issue';
+    codenameId = '';
+    distroUniqueId = '';
+    distroId = '';
+    distroLike = '';
+    familyId = 'debian';
+    homeUrl = 'https://penguins-eggs.net';
+    isCalamaresAvailable = true;
+    liveMediumPath = '/run/live/medium/';
+    releaseId = '';
+    squashfs = 'live/filesystem.squashfs';
+    supportUrl = 'https://penguins-eggs.net';
+    syslinuxPath = path.resolve(__dirname, `../../syslinux`);
+    usrLibPath = '/usr/lib';
+    constructor() {
+        // NEW CHANGE2: Initialize OS info using Utils.getOsRelease()
+        // This ensures the distroId, codenameId, and releaseId are set early for proper logic.
+        const osInfo = Utils.getOsRelease();
+        this.distroId = osInfo.ID;
+        this.codenameId = osInfo.VERSION_CODENAME;
+        this.releaseId = osInfo.VERSION_ID;
+        // NEW CHANGE3: Normalize special distro names to handle edge cases like Debian sid
+        // or custom Biglinux/Bigcommunity derivatives to maintain consistency.
+        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';
+        // NEW CHANGE4: Modularize distro configuration for better readability and maintenance
+        this.configureDistro();
+        this.applyFamilySpecificPaths();
+        // NEW CHANGE5: Load URLs from /etc/os-release to override defaults if available
+        this.loadOSReleaseUrls();
+    }
+    /**
+     * NEW CHANGE6: Modular configuration for main distro types like Alpine, Fedora-family, etc.
+     * This simplifies the constructor and keeps distro-specific logic isolated.
+     */
+    configureDistro() {
+        // NEW CHANGE7: Handle Alpine specific paths and properties
+        if (this.distroId === 'Alpine') {
+            this.familyId = 'alpine';
+            this.distroLike = 'Alpine';
+            this.codenameId = 'rolling';
+            this.distroUniqueId = this.familyId;
+            this.liveMediumPath = '/mnt/';
+            return;
+        }
+        /**
+         * Arch
+         */
+        if (this.codenameId === 'rolling' || this.codenameId === 'n/a') {
+            this.familyId = 'archlinux';
+            this.distroLike = 'Arch';
+            this.codenameId = 'rolling';
+            this.distroUniqueId = 'archlinux';
+            this.liveMediumPath = '/run/archiso/bootmnt/';
+            this.squashfs = `arch/x86_64/airootfs.sfs`;
+            return;
+        }
+        // NEW CHANGE8: Consolidated Fedora-family detection for multiple derivatives
+        const fedoraDistros = ['Almalinux', 'Fedora', 'Nobara', 'Rhel', 'Rocky'];
+        if (fedoraDistros.includes(this.distroId)) {
+            this.familyId = 'fedora';
+            this.distroLike = 'Fedora';
+            this.codenameId = 'rolling';
+            this.distroUniqueId = this.familyId;
+            this.liveMediumPath = '/run/initramfs/live/';
+            return;
+        }
+        // NEW CHANGE9: Openmamba specific properties
+        if (this.distroId === 'Openmamba') {
+            this.familyId = 'openmamba';
+            this.distroLike = 'Openmamba';
+            this.codenameId = 'rolling';
+            this.distroUniqueId = this.familyId;
+            this.liveMediumPath = '/run/initramfs/live/';
+            return;
+        }
+        // NEW CHANGE10: OpenSUSE specific properties
+        if (this.distroId.includes('Opensuse')) {
+            this.familyId = 'opensuse';
+            this.distroLike = 'Opensuse';
+            this.codenameId = 'rolling';
+            this.distroUniqueId = this.familyId;
+            this.liveMediumPath = '/run/initramfs/live/';
+            return;
+        }
+        // NEW CHANGE11: Handle Debian/Ubuntu/Devuan and their derivatives
+        this.debianFamily();
+    }
+    /**
+     * NEW CHANGE12: Map Debian, Ubuntu, Devuan codenames to proper IDs and paths
+     * This avoids long if/else chains and allows easier future updates.
+     */
+    debianFamily() {
+        const mapping = {
+            jessie: { distroLike: 'Debian', uniqueId: 'jessie', livePath: '/lib/live/mount/medium/', calamares: false },
+            stretch: { distroLike: 'Debian', uniqueId: 'stretch', livePath: '/lib/live/mount/medium/', calamares: false },
+            buster: { distroLike: 'Debian', uniqueId: 'buster' },
+            bullseye: { distroLike: 'Debian', uniqueId: 'bullseye' },
+            bookworm: { distroLike: 'Debian', uniqueId: 'bookworm' },
+            trixie: { distroLike: 'Debian', uniqueId: 'trixie' },
+            forky: { distroLike: 'Debian', uniqueId: 'forky' },
+            beowulf: { distroLike: 'Devuan', uniqueId: 'beowulf' },
+            chimaera: { distroLike: 'Devuan', uniqueId: 'chimaera' },
+            daedalus: { distroLike: 'Devuan', uniqueId: 'daedalus' },
+            excalibur: { distroLike: 'Devuan', uniqueId: 'excalibur' },
+            bionic: { distroLike: 'Ubuntu', uniqueId: 'bionic', livePath: '/lib/live/mount/medium/' },
+            focal: { distroLike: 'Ubuntu', uniqueId: 'focal' },
+            jammy: { distroLike: 'Ubuntu', uniqueId: 'jammy' },
+            noble: { distroLike: 'Ubuntu', uniqueId: 'noble' },
+            devel: { distroLike: 'Ubuntu', uniqueId: 'devel' },
+        };
+        // NEW CHANGE13: Apply mapping if codename exists
+        const cfg = mapping[this.codenameId];
+        if (cfg) {
+            this.familyId = "debian";
+            this.distroLike = cfg.distroLike;
+            this.distroUniqueId = cfg.uniqueId;
+            if (cfg.livePath !== undefined)
+                this.liveMediumPath = cfg.livePath;
+            if (cfg.calamares !== undefined)
+                this.isCalamaresAvailable = cfg.calamares;
+            return;
+        }
+        // NEW CHANGE14: Detect derivatives if not in mapping
+        this.detectDerivatives();
+    }
+    /**
+     * NEW CHANGE15: Async derivative detection from YAML files
+     * This allows future-proofing and easy updates for new distros.
+     */
+    async detectDerivatives() {
+        let archDebianDerivatives = path.resolve(__dirname, '../../conf/derivatives.yaml');
+        if (fsSync.existsSync('/etc/penguins-eggs.d/derivatives.yaml')) {
+            archDebianDerivatives = '/etc/penguins-eggs.d/derivatives.yaml';
+        }
+        let found = false;
+        if (fsSync.existsSync(archDebianDerivatives)) {
+            const content = await fs.readFile(archDebianDerivatives, '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.distroUniqueId = distro.id;
+                            this.familyId = distro.family;
+                            found = true;
+                        }
+                    }
+                }
+            }
+        }
+        if (!found) {
+            let fedoraDerivatives = path.resolve(__dirname, '../../conf/derivatives_fedora.yaml');
+            if (fsSync.existsSync('/etc/penguins-eggs.d/derivatives_fedora.yaml')) {
+                fedoraDerivatives = '/etc/penguins-eggs.d/derivatives_fedora.yaml';
+            }
+            const content = fsSync.readFileSync(fedoraDerivatives, 'utf8');
+            const elem = yaml.load(content);
+            if (elem.includes(this.distroId)) {
+                this.familyId = 'fedora';
+                this.distroLike = 'Fedora';
+                this.codenameId = 'rolling';
+                this.distroUniqueId = this.familyId;
+                this.liveMediumPath = '/run/initramfs/live/';
+                found = true;
+            }
+        }
+        if (!found) {
+            console.warn(`This distro ${this.distroId}/${this.codenameId} is not yet recognized!`);
+            console.warn('Edit derivatives.yaml and run: sudo eggs dad -d to re-configure.');
+            process.exit(0);
+        }
+    }
+    /**
+     * NEW CHANGE16: Apply family-specific paths for usrLibPath, squashfs, and liveMediumPath
+     * Handles Debian, openSUSE, Manjaro and derivatives consistently.
+     */
+    applyFamilySpecificPaths() {
+        if (this.familyId === 'archlinux') {
+            if (Diversions.isManjaroBased(this.distroId)) {
+                this.liveMediumPath = '/run/miso/bootmnt/';
+                this.squashfs = 'manjaro/x86_64/livefs.sfs';
+                this.codenameId = shell.exec('lsb_release -cs', { silent: true }).stdout.toString().trim();
+                this.distroUniqueId = 'manjaro';
+            }
+        }
+        else if (this.familyId === 'debian') {
+            this.usrLibPath = '/usr/lib/' + Utils.usrLibPath();
+        }
+        else if (this.familyId === 'opensuse') {
+            this.usrLibPath = '/usr/lib64/';
+        }
+    }
+    /**
+     * NEW CHANGE17: Load custom HOME, SUPPORT, BUG_REPORT URLs from /etc/os-release
+     * Allows overrides of default URLs for user-friendly experience.
+     */
+    loadOSReleaseUrls() {
+        const os_release = '/etc/os-release';
+        if (!fsSync.existsSync(os_release))
+            return;
+        const data = fsSync.readFileSync(os_release, 'utf8');
+        const lines = data.split('\n');
+        for (const line of lines) {
+            if (line.startsWith('HOME_URL='))
+                this.homeUrl = line.slice('HOME_URL='.length).replace(/"/g, '');
+            if (line.startsWith('SUPPORT_URL='))
+                this.supportUrl = line.slice('SUPPORT_URL='.length).replace(/"/g, '');
+            if (line.startsWith('BUG_REPORT_URL='))
+                this.bugReportUrl = line.slice('BUG_REPORT_URL='.length).replace(/"/g, '');
+        }
+    }
+}
+export default Distro;