penguins-eggs 25.10.28 → 25.11.8

package/addons/eggs/theme/applications/install-system.desktop

@@ -1,12 +1,14 @@
 [Desktop Entry]
 Type=Application
 Version=1.0
-Name=Install system
-GenericName=Live Installer
-Comment=Install the operating system to disk
-Exec=/usr/bin/calamares_polkit %f
+Name=Install System
+GenericName=System Installer
+Keywords=calamares;system;installer;
+TryExec=calamares
+Exec=sh -c "pkexec calamares"
+Comment=Calamares — System Installer
+Icon=install-system.png
 Terminal=false
 StartupNotify=true
-Type=Application
 Categories=Qt;System;
-Icon=install-system.png
+X-AppStream-Ignore=true

package/assets/calamares/io.calamares.calamares.policy

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- SPDX-FileCopyrightText: no
+     SPDX-License-Identifier: CC0-1.0
+-->
+<!DOCTYPE policyconfig PUBLIC
+"-//freedesktop//DTD PolicyKit Policy Configuration 1.0//EN"
+"http://www.freedesktop.org/standards/PolicyKit/1/policyconfig.dtd">
+<policyconfig>
+
+ <vendor>Calamares</vendor>
+ <vendor_url>https://calamares.io/</vendor_url>
+
+ <action id="io.calamares.calamares.pkexec.run">
+    <description>Run Installer</description>
+    <message>Authentication is required to run the installation program</message>
+    <icon_name>drive-harddisk</icon_name>
+    <defaults>
+     <allow_any>no</allow_any>
+     <allow_inactive>no</allow_inactive>
+     <allow_active>auth_admin</allow_active>
+    </defaults>
+    <annotate key="org.freedesktop.policykit.exec.path">/usr/bin/calamares</annotate>
+    <annotate key="org.freedesktop.policykit.exec.allow_gui">true</annotate>
+ </action>
+</policyconfig>

package/conf/distros/alpine/calamares/modules/packages.mustache

@@ -1,3 +1,4 @@
+# A mustache template for module: packages.conf
 ---
 backend: {{{backend}}}
 

package/conf/distros/alpine/calamares/modules/removeuser.mustache

@@ -1,15 +1,3 @@
-# Debian Buster
-# removeuser
-# SPDX-FileCopyrightText: no
-# SPDX-License-Identifier: CC0-1.0
-#
-# Removes a single user (with userdel) from the system.
-# This is typically used in OEM setups or if the live user
-# spills into the target system.
-#
-# The module never fails; if userdel fails, this is logged
-# but the module still reports success and installation / setup
-# continues as normal.
+# A mustache template for module: removeuser.conf
 ---
-# Username in the target system to be removed.
-username: {{username}}
+username: {{{username}}}

package/conf/distros/alpine/calamares/modules/unpackfs.mustache

@@ -1,6 +1,6 @@
-# Debian/bookworm
+# A mustache template for module: unpackfs.conf
 ---
 unpack:
-    -   source: {{source}}
+    -   source: {{{source}}}
         sourcefs: "squashfs"
         destination: ""

package/conf/distros/buster/calamares/modules/shellprocess@boot_deploy.yml

@@ -1,24 +1,9 @@
 # SPDX-FileCopyrightText: 2020 Harald Sitter <sitter@kde.org>
 # SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
 #
-# This is run outside the chroot!
-# As per at least 20.04+ /boot on the squashfs no longer contains the initrd
-# or vmlinuz, instead we'll first fish the kernel out of the ISO.
-#
-# NB: initrd is handled by the initramfs module.
 ---
 message: "Preparing the boot environment..."
 dontChroot: true
 timeout: 300
 script:
-    # Si tratta di una soluzione un po' improvvisata, ma sufficiente per la versione 20.04+, poiché non è più necessario
-    # considerare la differenza tra firmato e non firmato, quindi quanto riportato di seguito è praticamente
-    # sufficiente. La gestione degli errori è però un po' carente.
-    # Riconfigureremo il kernel nel modulo boot_reconfigure per garantire che gli hook
-    # vengano eseguiti secondo necessità.
-
-    # ubuntu
-    # cp --preserve=timestamps /lib/live/mount/medium/live/vmlinuz-`uname -r` ${ROOT}/boot/vmlinuz-`uname -r`
-
-    # debian
-    - cp --preserve=timestamps /run/live/medium/live/vmlinuz-`uname -r` ${ROOT}/boot/vmlinuz-`uname -r`
+    - cp --preserve=timestamps __LIVE_MEDIUM_PATH__live/vmlinuz-`uname -r` ${ROOT}/boot/vmlinuz-`uname -r`

package/conf/distros/noble/calamares/libexec/calamares-logs-helper.sh

@@ -18,7 +18,7 @@ else
        echo "WARNING: Cannot find calamares/session.log"
 fi
 
-cp /lib/live/mount/medium/.disk/info $install_dir/media-info
+cp __LIVE_MEDIUM_PATH__.disk/info $install_dir/media-info
 #cp /var/log/casper.log $install_dir/casper.log
 cp /var/log/syslog $install_dir/syslog
 

package/conf/distros/noble/calamares/modules/shellprocess@boot_deploy.yml

@@ -1,19 +1,9 @@
 # SPDX-FileCopyrightText: 2020 Harald Sitter <sitter@kde.org>
 # SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
 #
-# This is run outside the chroot!
-# As per at least 20.04+ /boot on the squashfs no longer contains the initrd
-# or vmlinuz, instead we'll first fish the kernel out of the ISO.
-#
-# NB: initrd is handled by the initramfs module.
 ---
 message: "Preparing the boot environment..."
 dontChroot: true
 timeout: 300
 script:
-    # This is a teeny tiny bit hacky but sufficient for 20.04+ as we don't have
-    # to consider signed vs. unsinged anymore, so the below is practically
-    # sufficient. Error handling is a bit on the weak side though.
-    - cp --preserve=timestamps /lib/live/mount/medium/live/vmlinuz-`uname -r` ${ROOT}/boot/vmlinuz-`uname -r`
-    # We'll reconfigure the kernel in the boot_reconfigure module to ensure hooks
-    # are run as needed.
+    - cp --preserve=timestamps __LIVE_MEDIUM_PATH__live/vmlinuz-`uname -r` ${ROOT}/boot/vmlinuz-`uname -r`

package/conf/distros/noble/calamares/modules/shellprocess@logs.yml

@@ -5,4 +5,4 @@ message: "Logs.."
 dontChroot: true
 timeout: 30
 script:
-    - "/usr/libexec/calamares//calamares-logs-helper.sh ${ROOT}"
+    - "/usr/libexec/calamares/calamares-logs-helper.sh ${ROOT}"

package/conf/distros/trixie/calamares/modules/shellprocess@boot_deploy.yml

@@ -11,13 +11,5 @@ message: "Preparing the boot environment..."
 dontChroot: true
 timeout: 300
 script:
-    # Si tratta di una soluzione un po' improvvisata, ma sufficiente per la versione 20.04+, poiché non è più necessario
-    # considerare la differenza tra firmato e non firmato, quindi quanto riportato di seguito è praticamente
-    # sufficiente. La gestione degli errori è però un po' carente.
-    # Riconfigureremo il kernel nel modulo boot_reconfigure per garantire che gli hook
-    # vengano eseguiti secondo necessità.
-
-    # INITRAMFS = '/run/live/medium/'
-    # DRACUT    = '/run/initramfs/live/'
-    - cp --preserve=timestamps /run/live/medium/live/vmlinuz-`uname -r` ${ROOT}/boot/vmlinuz-`uname -r`
-    #- cp --preserve=timestamps /run/initramfs/live/live/vmlinuz-`uname -r` ${ROOT}/boot/vmlinuz-`uname -r`
+    - cp --preserve=timestamps __LIVE_MEDIUM_PATH__live/vmlinuz-`uname -r` ${ROOT}/boot/vmlinuz-`uname -r`
+    

package/dist/classes/bleach.d.ts

@@ -0,0 +1,37 @@
+/**
+ * ./src/classes/bleach.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+/**
+ * Bleach:
+ */
+export default class Bleach {
+    /**
+     * clean
+     * @param verbose
+     */
+    clean(verbose?: boolean): Promise<void>;
+    /**
+     *
+     * @param verbose
+     */
+    private cleanFastpack;
+    /**
+     * cleanHistory
+     * @param verbose
+     */
+    private cleanHistory;
+    /**
+     * cleanJournal
+     * @param verbose
+     */
+    private cleanJournal;
+    /**
+     * cleanSystemCache
+     * @param verbose
+     */
+    private cleanSystemCache;
+}

package/dist/classes/bleach.js

@@ -0,0 +1,148 @@
+/**
+ * ./src/classes/bleach.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import fs from 'node:fs';
+// libraries
+import { exec } from '../lib/utils.js';
+import Distro from './distro.js';
+import Utils from './utils.js';
+/**
+ * Bleach:
+ */
+export default class Bleach {
+    /**
+     * clean
+     * @param verbose
+     */
+    async clean(verbose = false) {
+        let echo = { capture: false, echo: false, ignore: true };
+        if (verbose) {
+            echo = { capture: false, echo: true, ignore: true };
+            Utils.warning('cleaning the system');
+        }
+        const distro = new Distro();
+        if (distro.familyId === 'alpine') {
+            await exec('apk cache clean', echo);
+            await exec('apk cache purge', echo);
+        }
+        else if (distro.familyId === 'archlinux') {
+            await exec('yes | sudo pacman -Scc', Utils.setEcho(true));
+        }
+        else if (distro.familyId === 'debian') {
+            await exec('apt-get clean', echo);
+            await exec('apt-get autoclean', echo);
+            await exec(`rm /var/lib/apt/lists/lock -rf`, echo);
+        }
+        else if (distro.familyId === 'fedora' || distro.familyId === 'openmamba') {
+            await exec(`dnf remove $(dnf repoquery --installonly --latest-limit=-1 -q)`);
+            await exec(`dnf clean all`, echo);
+        }
+        else if (distro.familyId === 'opensuse') {
+            await exec(`zypper clean`, echo);
+        }
+        else if (distro.familyId === 'voidlinux') {
+            await exec(`xbps-remove -O`, echo);
+        }
+        await this.cleanFastpack(verbose);
+        await this.cleanHistory(verbose);
+        await this.cleanJournal(verbose);
+        await this.cleanSystemCache(verbose);
+    }
+    /**
+     *
+     * @param verbose
+     */
+    async cleanFastpack(verbose = false) {
+        let echo = { capture: false, echo: false, ignore: true };
+        if (verbose) {
+            echo = { capture: false, echo: true, ignore: true };
+            Utils.warning('cleaning fastpack');
+        }
+        await exec(`rm /var/tmp/flatpak-cache-* -rf`, echo);
+    }
+    /**
+     * cleanHistory
+     * @param verbose
+     */
+    async cleanHistory(verbose = false) {
+        if (verbose) {
+            Utils.warning('cleaning bash history');
+        }
+        const dest = '/root/.bash_history';
+        if (fs.existsSync(dest)) {
+            await rm(dest, verbose);
+        }
+    }
+    /**
+     * cleanJournal
+     * @param verbose
+     */
+    async cleanJournal(verbose = false) {
+        let echo = { capture: false, echo: false, ignore: true };
+        if (verbose) {
+            echo = { capture: false, echo: true, ignore: true };
+            Utils.warning('cleaning journald');
+        }
+        if (Utils.isSystemd()) {
+            try {
+                await exec('journalctl --rotate', echo);
+                await exec('journalctl --vacuum-time=1s', echo);
+            }
+            catch (error) {
+                Utils.error(error);
+            }
+        }
+        else {
+            // Truncate logs, remove archived logs.
+            await exec('find /var/log -name "*gz" -print0 | xargs -0r rm -f', echo);
+            await exec('find /var/log/ -type f -exec truncate -s 0 {} \\;', echo);
+        }
+    }
+    /**
+     * cleanSystemCache
+     * @param verbose
+     */
+    async cleanSystemCache(verbose = false) {
+        let echo = { capture: false, echo: false, ignore: true };
+        if (verbose) {
+            echo = { capture: false, echo: true, ignore: true };
+            Utils.warning('cleaning system cache');
+        }
+        // Clear PageCache only.
+        await exec('sync; echo 1 > /proc/sys/vm/drop_caches', echo);
+        // Clear dentries and inodes.
+        await exec('sync; echo 2 > /proc/sys/vm/drop_caches', echo);
+        // Clear PageCache, dentries and inodes.
+        await exec('sync; echo 3 > /proc/sys/vm/drop_caches', echo);
+    }
+}
+/**
+ *
+ * @param dest
+ */
+async function rm(dest = '', verbose = false) {
+    let echo = { capture: false, echo: false, ignore: true };
+    if (verbose) {
+        echo = { capture: false, echo: true, ignore: true };
+    }
+    if (fs.existsSync(dest)) {
+        await exec(`rm ${dest} -rf`, echo);
+    }
+    else {
+        console.log(`non esiste ${dest}`);
+    }
+}
+async function rmdir(dest = '', verbose = false) {
+    let echo = { capture: false, echo: false, ignore: true };
+    if (verbose) {
+        echo = { capture: false, echo: true, ignore: true };
+    }
+    const result = fs.readdirSync(dest);
+    if (result.length > 0) {
+        await exec(`rm ${dest} -rf`, echo);
+    }
+}

package/dist/classes/cli-autologin.d.ts

@@ -0,0 +1,14 @@
+/**
+ * ./src/lib/cli-autologin.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * modified by: Hossein Seilani
+ * license: MIT
+ */
+export default class CliAutologin {
+    add(distro: string, version: string, user: string, userPasswd: string, rootPasswd: string, chroot?: string): Promise<void>;
+    addIssue(distro: string, version: string, user: string, userPasswd: string, rootPasswd: string, chroot?: string): Promise<void>;
+    addMotd(distro: string, version: string, user: string, userPasswd: string, rootPasswd: string, chroot?: string): Promise<void>;
+    remove(chroot?: string): Promise<void>;
+    private msgRemove;
+}

package/dist/classes/cli-autologin.js

@@ -0,0 +1,227 @@
+/**
+ * ./src/lib/cli-autologin.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * modified by: Hossein Seilani
+ * license: MIT
+ */
+import chalk from 'chalk';
+import { execSync } from 'node:child_process';
+// 🔧 [Change 1] - Removed unused `{ link }` import to clean up unnecessary dependencies.
+import fs from 'node:fs';
+import path from 'node:path';
+// libraries
+import { exec } from '../lib/utils.js';
+import Pacman from './pacman.js';
+import Utils from './utils.js';
+const startMessage = 'eggs-start-message';
+const stopMessage = 'eggs-stop-message';
+export default class CliAutologin {
+    async add(distro, version, user, userPasswd, rootPasswd, chroot = '/') {
+        // 🔧 [Change 2] - Added parameter validation to prevent running with missing credentials.
+        // This prevents undefined users or empty passwords from breaking the autologin setup.
+        if (!user || !userPasswd || !rootPasswd) {
+            throw new Error('Missing user credentials for CLI autologin setup.');
+        }
+        if (Utils.isSystemd()) {
+            Utils.warning("systemd: creating CLI autologin");
+            const fileOverride = `${chroot}/etc/systemd/system/getty@.service.d/override.conf`;
+            const dirOverride = path.dirname(fileOverride);
+            // 🔧 [Change 3] - Replaced raw `rm -rf` shell command with the safer Node.js `fs.rmSync()`.
+            // This avoids potential shell injection or accidental file deletion outside the target directory.
+            if (fs.existsSync(dirOverride)) {
+                try {
+                    fs.rmSync(dirOverride, { recursive: true, force: true });
+                }
+                catch (err) {
+                    Utils.error(`Failed to remove ${dirOverride}: ${err}`);
+                }
+            }
+            // Exclude OpenSUSE since it uses a different login mechanism.
+            if (distro !== 'Opensuse') {
+                // 🔧 [Change 4] - Used `fs.mkdirSync()` instead of shell command for better cross-platform reliability.
+                fs.mkdirSync(dirOverride, { recursive: true });
+                let content = '';
+                content += '[Service]\n';
+                content += 'ExecStart=\n';
+                content += `ExecStart=-/sbin/agetty --noclear --autologin ${user} %I $TERM\n`;
+                // 🔧 [Change 5] - Wrapped file operations in try/catch for safe I/O handling.
+                // Prevents crash if permission denied or disk error occurs.
+                try {
+                    fs.writeFileSync(fileOverride, content);
+                    fs.chmodSync(fileOverride, 0o755);
+                }
+                catch (err) {
+                    Utils.error(`Failed to write ${fileOverride}: ${err}`);
+                }
+            }
+            await this.addIssue(distro, version, user, userPasswd, rootPasswd, chroot);
+            await this.addMotd(distro, version, user, userPasswd, rootPasswd, chroot);
+        }
+        else if (Utils.isOpenRc()) {
+            Utils.warning("openrc: creating CLI autologin");
+            const inittab = chroot + '/etc/inittab';
+            // 🔧 [Change 6] - Automatically creates a backup of `/etc/inittab` before making modifications.
+            // This allows easy rollback in case autologin configuration fails.
+            if (fs.existsSync(inittab)) {
+                fs.copyFileSync(inittab, `${inittab}.bak`);
+            }
+            let content = '';
+            const search = `tty1::respawn:/sbin/getty 38400 tty1`;
+            const replace = `tty1::respawn:/sbin/getty -L 38400 tty1 -n -l /bin/autologin`;
+            const lines = fs.readFileSync(inittab, 'utf8').split('\n');
+            for (let i = 0; i < lines.length; i++) {
+                if (lines[i].includes(search))
+                    lines[i] = replace;
+                content += lines[i] + '\n';
+            }
+            console.log(`Writing ${inittab}`);
+            fs.writeFileSync(inittab, content, 'utf-8');
+            const autologin = chroot + '/bin/autologin';
+            content = '#!/bin/sh\n';
+            content += `/bin/login -f ${user}\n`;
+            fs.writeFileSync(autologin, content, 'utf-8');
+            execSync(`chmod +x ${autologin}`);
+            await this.addIssue(distro, version, user, userPasswd, rootPasswd, chroot);
+            await this.addMotd(distro, version, user, userPasswd, rootPasswd, chroot);
+        }
+        else if (Utils.isSysvinit()) {
+            Utils.warning("sysvinit: creating CLI autologin");
+            const inittab = chroot + '/etc/inittab';
+            // 🔧 [Change 7] - Added backup for SysVInit `inittab` as well.
+            // Provides consistency and safety across all init systems.
+            if (fs.existsSync(inittab)) {
+                fs.copyFileSync(inittab, `${inittab}.bak`);
+            }
+            const search = '1:2345:respawn:/sbin/getty';
+            const replace = `1:2345:respawn:/sbin/getty --autologin ${user} 38400 tty1`;
+            let content = '';
+            const lines = fs.readFileSync(inittab, 'utf8').split('\n');
+            for (let i = 0; i < lines.length; i++) {
+                if (lines[i].includes(search))
+                    lines[i] = replace;
+                content += lines[i] + '\n';
+            }
+            fs.writeFileSync(inittab, content, 'utf-8');
+            await this.addMotd(distro, version, user, userPasswd, rootPasswd, chroot);
+            await this.addIssue(distro, version, user, userPasswd, rootPasswd, chroot);
+        }
+    }
+    async addIssue(distro, version, user, userPasswd, rootPasswd, chroot = '/') {
+        const fileIssue = `${chroot}/etc/issue`;
+        if (fs.existsSync(fileIssue)) {
+            if (!fs.lstatSync(fileIssue).isSymbolicLink()) {
+                this.msgRemove(fileIssue);
+                let content = fs.readFileSync(fileIssue, 'utf8');
+                content += startMessage + '\n';
+                content += `This is a ${distro}/${version} system created by Penguins' eggs.\n`;
+                content += `You can login with user: ${chalk.bold(user)} and password: ${chalk.bold(userPasswd)}, root password: ${chalk.bold(rootPasswd)}\n`;
+                content += stopMessage + '\n';
+                // 🔧 [Change 8] - File writing is now protected by try/catch for reliability.
+                // Prevents the script from crashing if write permission is missing.
+                try {
+                    fs.writeFileSync(fileIssue, content);
+                }
+                catch (err) {
+                    Utils.error(`Failed to write ${fileIssue}: ${err}`);
+                }
+            }
+        }
+    }
+    async addMotd(distro, version, user, userPasswd, rootPasswd, chroot = '/') {
+        const fileMotd = `${chroot}/etc/motd`;
+        let installer = 'sudo eggs install';
+        if (Pacman.calamaresExists()) {
+            if (Pacman.packageIsInstalled('plasma-desktop')) {
+                installer = 'startplasma-wayland to run GUI and launch calamares';
+            }
+            else if (Pacman.packageIsInstalled('xfce4')) {
+                installer = 'startxfce4 to run GUI and launch calamares installer';
+            }
+        }
+        if (!fs.existsSync(fileMotd)) {
+            await exec(`touch ${fileMotd}`);
+        }
+        this.msgRemove(fileMotd);
+        let eggsMotd = fs.readFileSync(fileMotd, 'utf8');
+        eggsMotd += startMessage + '\n';
+        eggsMotd += Utils.flag() + '\n';
+        eggsMotd += `You are logged as: ${chalk.bold(user)} your password is: ${chalk.bold(userPasswd)}, root password: ${chalk.bold(rootPasswd)}\n\n`;
+        eggsMotd += `install              : ${chalk.bold(installer)}\n`;
+        eggsMotd += ` --unattended        : ${chalk.bold('sudo eggs install --unattended')}\n`;
+        eggsMotd += ` --chroot            : ${chalk.bold('sudo eggs install --chroot')}\n`;
+        eggsMotd += ` --help              : ${chalk.bold('sudo eggs install --help')}\n\n`;
+        eggsMotd += stopMessage + '\n';
+        // 🔧 [Change 9] - Same as above: safe write with error handling to improve reliability.
+        try {
+            fs.writeFileSync(fileMotd, eggsMotd);
+        }
+        catch (err) {
+            Utils.error(`Failed to write ${fileMotd}: ${err}`);
+        }
+    }
+    async remove(chroot = '/') {
+        if (Utils.isSystemd()) {
+            const fileOverride = `${chroot}/etc/systemd/system/getty@.service.d/override.conf`;
+            const dirOverride = path.dirname(fileOverride);
+            // 🔧 [Change 10] - Replaced shell-based deletion with `fs.rmSync()` for safety and consistency.
+            if (fs.existsSync(dirOverride)) {
+                try {
+                    fs.rmSync(dirOverride, { recursive: true, force: true });
+                }
+                catch (err) {
+                    Utils.error(`Failed to remove ${dirOverride}: ${err}`);
+                }
+            }
+            this.msgRemove(`${chroot}/etc/motd`);
+            this.msgRemove(`${chroot}/etc/issue`);
+        }
+        else if (Utils.isOpenRc()) {
+            const inittab = chroot + '/etc/inittab';
+            const search = 'autologin';
+            const replace = `tty1::respawn:/sbin/getty 38400 tty1`;
+            let content = '';
+            const lines = fs.readFileSync(inittab, 'utf8').split('\n');
+            for (let i = 0; i < lines.length; i++) {
+                if (lines[i].includes(search))
+                    lines[i] = replace;
+                content += lines[i] + '\n';
+            }
+            fs.writeFileSync(inittab, content, 'utf-8');
+            this.msgRemove(`${chroot}/etc/motd`);
+            this.msgRemove(`${chroot}/etc/issue`);
+            const autologin = `${chroot}/bin/autologin`;
+            // 🔧 [Change 11] - Added safety check before deleting `/bin/autologin`.
+            // Prevents accidental removal of unrelated files outside chroot.
+            if (autologin.startsWith(chroot)) {
+                execSync(`rm -f ${autologin}`);
+            }
+        }
+        else if (Utils.isSysvinit()) {
+            const inittab = chroot + '/etc/inittab';
+            const search = '--autologin';
+            const replace = '1:2345:respawn:/sbin/getty 38400 tty1         ';
+            let content = '';
+            const lines = fs.readFileSync(inittab, 'utf8').split('\n');
+            for (let i = 0; i < lines.length; i++) {
+                if (lines[i].includes(search))
+                    lines[i] = replace;
+                content += lines[i] + '\n';
+            }
+            fs.writeFileSync(inittab, content, 'utf-8');
+            this.msgRemove(`${chroot}/etc/motd`);
+            this.msgRemove(`${chroot}/etc/issue`);
+        }
+    }
+    async msgRemove(path) {
+        if (fs.existsSync(path)) {
+            if (!fs.lstatSync(path).isSymbolicLink()) {
+                // 🔧 [Change 12] - Rewrote cleanup logic using a regular expression to remove the block
+                // between `eggs-start-message` and `eggs-stop-message`. More efficient and cleaner.
+                let content = fs.readFileSync(path, 'utf8');
+                content = content.replace(/eggs-start-message[\s\S]*?eggs-stop-message/g, '');
+                fs.writeFileSync(path, content, 'utf-8');
+            }
+        }
+    }
+}