penguins-eggs 25.11.21 → 25.12.7

package/dist/krill/classes/sequence.d/grubcfg.js

@@ -1,10 +1,7 @@
 /**
  * ./src/krill/modules/grubcfg.ts
  * penguins-eggs v.25.7.x / ecmascript 2020
- * author: Piero Proietti
- * email: piero.proietti@gmail.com
- * license: MIT
- * https://stackoverflow.com/questions/23876782/how-do-i-split-a-typescript-class-into-multiple-files
+ * * REFACTORED: Adds SELinux permissive mode for RHEL family
  */
 import fs from 'node:fs';
 import Utils from '../../../classes/utils.js';
@@ -12,24 +9,47 @@ import { InstallationMode } from '../krill_enums.js';
 /**
  * grubcfg
  * - open /etc/default/grub
- * - find GRUB_CMDLINE_LINUX_DEFAULT=
- * - replace with GRUB_CMDLINE_LINUX_DEFAULT=
- * 's/GRUB_CMDLINE_LINUX_DEFAULT=.*$/GRUB_CMDLINE_LINUX_DEFAULT=/g'
+ * - handle BTRFS/LUKS settings
+ * - inject enforcing=0 for Fedora/RHEL to allow autorelabel on first boot
  */
 export default async function grubcfg() {
     const file = `${this.installTarget}/etc/default/grub`;
+    if (!fs.existsSync(file)) {
+        console.warn(`Warning: ${file} not found. Skipping GRUB config.`);
+        return;
+    }
     let content = '';
     const grubs = fs.readFileSync(file, 'utf8').split('\n');
+    // Cache per la verifica della famiglia
+    const isRhelFamily = ['fedora', 'rhel', 'centos', 'almalinux', 'rocky'].includes(this.distro.familyId);
     for (let i = 0; i < grubs.length; i++) {
-        // RESUME
-        if (grubs[i].includes('GRUB_CMDLINE_LINUX_DEFAULT=')) {
+        let line = grubs[i];
+        // 1. LOGICA ESISTENTE (BTRFS / LUKS)
+        // Questa logica riscrive completamente la riga DEFAULT se necessario
+        if (line.trim().startsWith('GRUB_CMDLINE_LINUX_DEFAULT=')) {
             if (this.partitions.filesystemType === 'btrfs') {
-                // userSwapChoice != SwapChoice.File) {
-                // grubs[i] = this.partitions.installationMode === InstallationMode.Luks ? `GRUB_CMDLINE_LINUX_DEFAULT="resume=UUID=${Utils.uuid(this.devices.swap.name)}"` : `GRUB_CMDLINE_LINUX_DEFAULT="quiet splash resume=UUID=${Utils.uuid(this.devices.swap.name)}"`
-                grubs[i] = this.partitions.installationMode === InstallationMode.Luks ? `GRUB_CMDLINE_LINUX_DEFAULT="resume=UUID=${Utils.uuid(this.devices.swap.name)}"` : `GRUB_CMDLINE_LINUX_DEFAULT="quiet splash rootflags=subvol=@"`;
+                const uuid = Utils.uuid(this.devices.swap.name);
+                if (this.partitions.installationMode === InstallationMode.Luks) {
+                    line = `GRUB_CMDLINE_LINUX_DEFAULT="resume=UUID=${uuid}"`;
+                }
+                else {
+                    line = `GRUB_CMDLINE_LINUX_DEFAULT="quiet splash rootflags=subvol=@"`;
+                }
+            }
+        }
+        // 2. LOGICA SELINUX (RHEL/FEDORA)
+        // Applichiamo la modifica sia se la riga è stata appena toccata, sia se è originale.
+        // Fedora usa spesso anche GRUB_CMDLINE_LINUX (senza DEFAULT), quindi controlliamo entrambe.
+        if (isRhelFamily) {
+            if (line.trim().startsWith('GRUB_CMDLINE_LINUX_DEFAULT=') || line.trim().startsWith('GRUB_CMDLINE_LINUX=')) {
+                // Se non c'è già il parametro, lo iniettiamo subito dopo la prima virgoletta
+                if (!line.includes('enforcing=0')) {
+                    line = line.replace('="', '="enforcing=0 ');
+                    console.log(`- GRUB: injected enforcing=0 into ${line.split('=')[0]}`);
+                }
             }
         }
-        content += grubs[i] + '\n';
+        content += line + '\n';
     }
     fs.writeFileSync(file, content, 'utf-8');
 }

package/dist/krill/classes/sequence.d/mkfs.js

@@ -6,8 +6,7 @@
  * license: MIT
  * https://stackoverflow.com/questions/23876782/how-do-i-split-a-typescript-class-into-multiple-files
  */
-import { exec } from '../../../lib/utils.js';
-import shx from "shelljs";
+import { exec, shx } from '../../../lib/utils.js';
 import { InstallationMode, SwapChoice } from '../krill_enums.js';
 /**
  * mkfs

package/dist/krill/classes/sequence.d/unpackfs.d.ts

@@ -1,13 +1,11 @@
 /**
  * ./src/krill/modules/unpackfs.ts
  * penguins-eggs v.25.7.x / ecmascript 2020
- * author: Piero Proietti
- * email: piero.proietti@gmail.com
- * license: MIT
- * https://stackoverflow.com/questions/23876782/how-do-i-split-a-typescript-class-into-multiple-files
+ * * CLEANED: Just unpacks. SELinux is handled via autorelabel on first boot.
  */
 import Sequence from '../../classes/sequence.js';
 /**
  * unpackfs
+ * Scompatta il filesystem (senza tentare fix SELinux costosi qui)
  */
 export default function unpackfs(this: Sequence): Promise<void>;

package/dist/krill/classes/sequence.d/unpackfs.js

@@ -1,21 +1,24 @@
 /**
  * ./src/krill/modules/unpackfs.ts
  * penguins-eggs v.25.7.x / ecmascript 2020
- * author: Piero Proietti
- * email: piero.proietti@gmail.com
- * license: MIT
- * https://stackoverflow.com/questions/23876782/how-do-i-split-a-typescript-class-into-multiple-files
+ * * CLEANED: Just unpacks. SELinux is handled via autorelabel on first boot.
  */
 import Utils from '../../../classes/utils.js';
 import { exec } from '../../../lib/utils.js';
 import path from 'path';
 /**
  * unpackfs
+ * Scompatta il filesystem (senza tentare fix SELinux costosi qui)
  */
 export default async function unpackfs() {
     const squafsPath = path.join(this.distro.liveMediumPath, this.distro.squashfs);
+    // -d: destination
+    // -f: force (overwrite)
     const cmd = `unsquashfs -d ${this.installTarget} -f ${squafsPath} ${this.toNull}`;
-    const echoYes = Utils.setEcho(true);
+    // Usiamo echo false per evitare di intasare il log con migliaia di file
     const echoNo = Utils.setEcho(false);
+    console.log('Unpacking filesystem (this may take a while)...');
+    // Esecuzione
     await exec(cmd, echoNo);
+    console.log('Filesystem unpacked successfully.');
 }

package/dist/krill/classes/sequence.js

@@ -19,7 +19,7 @@ import Distro from '../../classes/distro.js';
 import Pacman from '../../classes/pacman.js';
 import Utils from '../../classes/utils.js';
 import Xdg from '../../classes/xdg.js';
-import { exec } from '../../lib/utils.js';
+import { exec, spawnSync } from '../../lib/utils.js';
 // Import all modules (unchanged)
 import partition from './sequence.d/partition.js';
 import biosStandard from './sequence.d/partition.d/bios_standard.js';
@@ -51,7 +51,6 @@ import hostname from './sequence.d/hostname.js';
 import CFS from './cfs.js';
 import Title from '../components/title.js';
 import cliCursor from 'cli-cursor';
-import { spawnSync } from 'child_process';
 /**
  * Main Sequence class - Simple Refactoring
  */
@@ -339,7 +338,7 @@ export default class Sequence {
             await sleep(5000);
         }
         else {
-            spawnSync('read _ ', { shell: true, stdio: [0, 1, 2] });
+            spawnSync('read _ ', [], { shell: true, stdio: [0, 1, 2] });
         }
         await exec(cmd, { echo: false });
     }

package/dist/krill/components/title.js

@@ -14,14 +14,14 @@ const require = createRequire(import.meta.url);
 const pjson = require('../../../package.json');
 export default function Title({ title = "", version = "" }) {
     let type = "";
-    if (Utils.isAppImage()) {
-        type = "AppImage:";
+    if (!Utils.isAppImage()) {
+        type = " native";
     }
     if (title === "")
         title = `${pjson.name}`;
-    let green = ` ${type} ${title}`.padEnd(25, " ");
+    let green = ` ${title}`.padEnd(25, " ");
     let white = ` Perri's brewery edition `.padEnd(25, " ");
-    let red = ` v${pjson.version} `.padStart(25, " ");
+    let red = ` v${pjson.version}${type} `.padStart(25, " ");
     return (React.createElement(React.Fragment, null,
         React.createElement(Box, { flexDirection: "column" },
             React.createElement(Box, null),

package/dist/krill/lib/select_installation_device.js

@@ -6,7 +6,7 @@
  * license: MIT
  */
 import inquirer from 'inquirer';
-import shx from 'shelljs';
+import { shx } from '../../lib/utils.js';
 export default async function selectInstallationDevice() {
     const drives = shx.exec('lsblk |grep disk|cut -f 1 "-d "', { silent: true }).stdout.trim().split('\n');
     const raid = shx.exec('lsblk -l | grep raid | cut -f 1 "-d "', { silent: true }).stdout.trim().split('\n');

package/dist/krill/lib/select_replaced_partition.js

@@ -6,7 +6,7 @@
  * license: MIT
  */
 import inquirer from 'inquirer';
-import shx from 'shelljs';
+import { shx } from '../../lib/utils.js';
 export default async function selectReplacedPartition() {
     const partitions = shx.exec('lsblk -l -o NAME,TYPE | grep part | cut -d" " -f1', { silent: true }).stdout.trim().split('\n');
     let partitionsList = [];

package/dist/lib/utils.d.ts

@@ -5,31 +5,63 @@
  * email: piero.proietti@gmail.com
  * license: MIT
  */
+import { SpawnOptions, SpawnSyncOptions, SpawnSyncReturns, ChildProcess } from 'child_process';
+import { IExec } from '../interfaces/index.js';
+interface ShellExecResult {
+    code: number;
+    stdout: string;
+    stderr: string;
+}
+interface ExecSyncOptions {
+    echo?: boolean;
+    ignore?: boolean;
+    stdio?: 'pipe' | 'ignore' | 'inherit';
+}
 /**
- * Executes shell command as it would happen in BASH script
- * @param {string} command
- * @param {Object} [options] Object with options.
- *                           echo: true, to echo command passed.
- *                           ignore: true to ignore stdout
- *                           capture: true, to capture and return stdout.
- *
- * @returns {Promise<{code: number, data: string | undefined, error: Object}>}
- *
- * https://github.com/oclif/core/issues/453#issuecomment-1200778612
- * codespool:
- * You could wrap spawn in a promise, listen to exit event, and resolve when it happens. That should play nicely with oclif/core.
- * We are using it here:
- * https://github.com/AstarNetwork/swanky-cli/blob/master/src/commands/compile/index.ts
+ * spawnSync (WRAPPER INTELLIGENTE)
+ * Supporta:
+ * 1. (command, args, options)
+ * 2. (command, options) -> args diventa []
+ * Pulisce automaticamente l'ambiente.
  */
-import { IExec } from '../interfaces/index.js';
+export declare function spawnSync(command: string, arg2?: string[] | SpawnSyncOptions, arg3?: SpawnSyncOptions): SpawnSyncReturns<string | Buffer>;
+/**
+ * spawn (WRAPPER INTELLIGENTE)
+ * Supporta:
+ * 1. (command, args, options)
+ * 2. (command, options) -> args diventa []
+ * Pulisce automaticamente l'ambiente.
+ */
+export declare function spawn(command: string, arg2?: readonly string[] | SpawnOptions, arg3?: SpawnOptions): ChildProcess;
+/**
+ * shx
+ * Sostituto drop-in per shelljs che usa API native e ambiente pulito.
+ */
+export declare const shx: {
+    sed: (flag: string, regex: string | RegExp, replacement: string, file: string) => void;
+    touch: (file: string) => void;
+    cp: (arg1: string, arg2: string, arg3?: string) => void;
+    rm: (arg1: string, arg2?: string) => void;
+    mkdir: (arg1: string, arg2?: string) => void;
+    mv: (src: string, dest: string) => void;
+    chmod: (mode: string | number, file: string) => void;
+    test: (flag: string, pathToCheck: string) => boolean;
+    which: (cmd: string) => string | null;
+    ln: (flag: string, target: string, link: string) => void;
+    exec: (command: string, options?: {
+        silent?: boolean;
+    }) => ShellExecResult;
+};
+/**
+ * execSync
+ */
+export declare function execSync(command: string, options?: ExecSyncOptions): string | null;
 /**
- *
- * @param command
- * @param param1
- * @returns
+ * exec (Async)
  */
 export declare function exec(command: string, { echo, ignore, capture }?: {
     echo?: boolean | undefined;
     ignore?: boolean | undefined;
     capture?: boolean | undefined;
 }): Promise<IExec>;
+export {};

package/dist/lib/utils.js

@@ -5,53 +5,239 @@
  * email: piero.proietti@gmail.com
  * license: MIT
  */
-import { spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+// Importiamo con alias per poter wrappare
+import { spawn as nodeSpawn, spawnSync as nodeSpawnSync } from 'child_process';
 /**
- *
- * @param command
- * @param param1
- * @returns
+ * Pulizia AppImage
+ * Variabili d'ambiente da rimuovere per evitare conflitti quando si eseguono
+ * comandi di sistema dall'interno di una AppImage.
+ */
+const APPIMAGE_ENV_BLACKLIST = [
+    'LD_LIBRARY_PATH', 'LD_PRELOAD', 'PYTHONPATH', 'PERLLIB',
+    'GSETTINGS_SCHEMA_DIR', 'QT_PLUGIN_PATH', 'XDG_DATA_DIRS',
+    'LIBRARY_PATH', 'PKG_CONFIG_PATH', 'GIO_MODULE_DIR', 'APPIMAGE', 'APPDIR'
+];
+/**
+ * Ottiene un ambiente pulito dalle variabili AppImage
+ * @returns Oggetto process.env sanificato
+ */
+function getCleanEnv() {
+    const env = { ...process.env };
+    if (process.env.APPIMAGE) {
+        APPIMAGE_ENV_BLACKLIST.forEach((key) => delete env[key]);
+    }
+    return env;
+}
+/**
+ * spawnSync (WRAPPER INTELLIGENTE)
+ * Supporta:
+ * 1. (command, args, options)
+ * 2. (command, options) -> args diventa []
+ * Pulisce automaticamente l'ambiente.
+ */
+export function spawnSync(command, arg2, arg3) {
+    let args = [];
+    let options = {};
+    // Rilevamento argomenti (Polimorfismo)
+    if (Array.isArray(arg2)) {
+        args = arg2;
+        options = arg3 || {};
+    }
+    else if (arg2 && typeof arg2 === 'object') {
+        // TypeScript fix: cast esplicito per evitare errori di tipo union
+        options = arg2;
+    }
+    const env = getCleanEnv();
+    const finalEnv = { ...env, ...(options.env || {}) };
+    return nodeSpawnSync(command, args, {
+        ...options,
+        env: finalEnv
+    });
+}
+/**
+ * spawn (WRAPPER INTELLIGENTE)
+ * Supporta:
+ * 1. (command, args, options)
+ * 2. (command, options) -> args diventa []
+ * Pulisce automaticamente l'ambiente.
+ */
+export function spawn(command, arg2, arg3) {
+    let args = [];
+    let options = {};
+    // Rilevamento argomenti (Polimorfismo)
+    if (Array.isArray(arg2)) {
+        args = arg2;
+        options = arg3 || {};
+    }
+    else if (arg2 && typeof arg2 === 'object') {
+        // TypeScript fix: cast esplicito
+        options = arg2;
+    }
+    const env = getCleanEnv();
+    const finalEnv = { ...env, ...(options.env || {}) };
+    return nodeSpawn(command, args, {
+        ...options,
+        env: finalEnv
+    });
+}
+/**
+ * shx
+ * Sostituto drop-in per shelljs che usa API native e ambiente pulito.
+ */
+export const shx = {
+    sed: (flag, regex, replacement, file) => {
+        if (!fs.existsSync(file))
+            return;
+        const content = fs.readFileSync(file, 'utf8');
+        const searchRegex = typeof regex === 'string' ? new RegExp(regex, 'g') : regex;
+        const newContent = content.replace(searchRegex, replacement);
+        fs.writeFileSync(file, newContent, 'utf8');
+    },
+    touch: (file) => {
+        const time = new Date();
+        try {
+            fs.utimesSync(file, time, time);
+        }
+        catch (err) {
+            fs.closeSync(fs.openSync(file, 'w'));
+        }
+    },
+    cp: (arg1, arg2, arg3) => {
+        const src = arg3 ? arg2 : arg1;
+        const dest = arg3 ? arg3 : arg2;
+        // --- GESTIONE WILDCARD (*) ---
+        if (src.endsWith('*')) {
+            const srcDir = path.dirname(src);
+            if (!fs.existsSync(srcDir))
+                return;
+            if (!fs.existsSync(dest))
+                fs.mkdirSync(dest, { recursive: true });
+            const items = fs.readdirSync(srcDir);
+            items.forEach(item => {
+                const s = path.join(srcDir, item);
+                const d = path.join(dest, item);
+                fs.cpSync(s, d, { recursive: true, force: true });
+            });
+            return;
+        }
+        // ----------------------------
+        let finalDest = dest;
+        if (fs.existsSync(dest) && fs.statSync(dest).isDirectory()) {
+            finalDest = path.join(dest, path.basename(src));
+        }
+        if (fs.existsSync(src)) {
+            fs.cpSync(src, finalDest, { recursive: true, force: true });
+        }
+    },
+    rm: (arg1, arg2) => {
+        const target = arg2 ? arg2 : arg1;
+        fs.rmSync(target, { recursive: true, force: true });
+    },
+    mkdir: (arg1, arg2) => {
+        const dir = arg2 ? arg2 : arg1;
+        fs.mkdirSync(dir, { recursive: true });
+    },
+    mv: (src, dest) => {
+        if (!fs.existsSync(src))
+            return;
+        fs.renameSync(src, dest);
+    },
+    chmod: (mode, file) => {
+        if (!fs.existsSync(file))
+            return;
+        let finalMode = mode;
+        if (mode === '+x')
+            finalMode = 0o755;
+        if (typeof mode === 'string' && !isNaN(parseInt(mode, 8))) {
+            finalMode = parseInt(mode, 8);
+        }
+        fs.chmodSync(file, finalMode);
+    },
+    test: (flag, pathToCheck) => {
+        try {
+            const stats = fs.statSync(pathToCheck);
+            if (flag === '-f')
+                return stats.isFile();
+            if (flag === '-d')
+                return stats.isDirectory();
+            return true; // -e
+        }
+        catch (e) {
+            return false;
+        }
+    },
+    which: (cmd) => {
+        const result = shx.exec(`command -v ${cmd}`, { silent: true });
+        return result.code === 0 ? result.stdout.trim() : null;
+    },
+    ln: (flag, target, link) => {
+        if (fs.existsSync(link) || fs.lstatSync(link, { throwIfNoEntry: false })) {
+            fs.rmSync(link, { force: true });
+        }
+        fs.symlinkSync(target, link);
+    },
+    exec: (command, options = {}) => {
+        const env = getCleanEnv();
+        const spawnOpts = {
+            stdio: options.silent ? 'pipe' : 'inherit',
+            env: env,
+            shell: '/bin/bash',
+            encoding: 'utf-8'
+        };
+        // Usiamo nodeSpawnSync perché calcoliamo l'env qui sopra
+        const result = nodeSpawnSync(command, [], spawnOpts);
+        return {
+            code: result.status ?? 1,
+            stdout: result.stdout ? result.stdout.toString() : '',
+            stderr: result.stderr ? result.stderr.toString() : ''
+        };
+    }
+};
+/**
+ * execSync
+ */
+export function execSync(command, options = {}) {
+    const { echo = false, ignore = false, stdio } = options;
+    if (echo)
+        console.log(command);
+    const isSilent = ignore || stdio === 'ignore';
+    const result = shx.exec(command, { silent: isSilent });
+    if (result.code !== 0) {
+        throw new Error(`Command failed: ${command}\nExit Code: ${result.code}\nStderr: ${result.stderr}`);
+    }
+    return result.stdout.trim();
+}
+/**
+ * exec (Async)
  */
 export async function exec(command, { echo = false, ignore = false, capture = false } = {}) {
     return new Promise((resolve, reject) => {
-        if (echo) {
+        if (echo)
             console.log(command);
-        }
-        // Opzioni di base per spawn
-        const spawnOptions = {
-            stdio: ignore ? 'ignore' : capture ? 'pipe' : 'inherit'
-        };
-        // AppImage Detected
-        if (process.env.APPIMAGE) {
-            // Clona l'ambiente attuale
-            const env = { ...process.env };
-            // 1. Rimuovi le variabili che causano conflitti di librerie (Kernel Panic)
-            delete env.LD_LIBRARY_PATH;
-            delete env.LD_PRELOAD;
-            delete env.GSETTINGS_SCHEMA_DIR;
-            delete env.PYTHONPATH;
-            delete env.MANPATH;
-            // 2. FORZA IL PATH DI SISTEMA
-            env.PATH = '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin';
-            // Applica l'ambiente pulito alle opzioni di spawn
-            spawnOptions.env = env;
-            // (Opzionale) Debug visivo per essere sicuri che stia funzionando
-            if (echo) {
-                console.log(' [AppImage Detected] Environment sanitized for system command.');
-            }
-        }
-        const child = spawn('bash', ['-c', command], spawnOptions);
+        const env = getCleanEnv();
+        // Usiamo nodeSpawn direttamente qui per coerenza
+        const child = nodeSpawn(command, [], {
+            stdio: ignore ? 'ignore' : (capture ? 'pipe' : 'inherit'),
+            env: env,
+            shell: '/bin/bash'
+        });
         let stdout = '';
-        if (capture) {
-            child.stdout?.on('data', (data) => {
-                stdout += data;
-            });
-        }
+        let stderr = '';
+        if (capture && child.stdout)
+            child.stdout.on('data', d => stdout += d.toString());
+        if (capture && child.stderr)
+            child.stderr.on('data', d => stderr += d.toString());
         child.on('error', (error) => {
-            reject({ code: 1, error });
+            reject({ code: 1, error, stderr });
         });
-        child.on('exit', (code) => {
-            resolve({ code, data: stdout });
+        child.on('close', (code) => {
+            resolve({
+                code: code || 0,
+                data: stdout.trim(),
+                error: code !== 0 ? stderr.trim() : undefined
+            });
         });
     });
 }

package/manpages/doc/man/eggs.html

@@ -6,12 +6,12 @@
     <meta name="viewport" content="width=device-width, initial-scale=1">
   </head>
   <body>
-    <h1>eggs(1) -- the reproductive system of penguins: eggs v25.11.21</h1>
+    <h1>eggs(1) -- the reproductive system of penguins: eggs v25.12.7</h1>
     <h1>SYNOPSIS</h1>
     <p>eggs is a console utility, in active development, who let you to remaster your system and redistribuite it as live ISO image.</p>
     <h1>INSTALL</h1>
     <p>penguins-eggs as an AppImage, it can be installed on all supported distributions. Download it from https://github.com/pieroproietti/penguins-eggs/releases, then run the following commands:</p>
-    <pre><code>$ chmod +x penguins-eggs_25.11.21-1_amd64-x86_64.AppImage
+    <pre><code>$ chmod +x penguins-eggs_25.12.7-1_amd64-x86_64.AppImage
 $ sudo mv /usr/local/bin
 $ sudo eggs setup
 </code></pre>
@@ -19,30 +19,30 @@ $ sudo eggs setup
     <pre><code>$ doas apk add penguins-eggs@testing
 </code></pre>
     <p>AlmaLinux/RockyLinux</p>
-    <pre><code>$ sudo dnf install ./penguins-eggs_25.11.21-1_amd64-1rocky9.5..x86_64.rpm
+    <pre><code>$ sudo dnf install ./penguins-eggs_25.12.7-1_amd64-1rocky9.5..x86_64.rpm
 
 </code></pre>
     <p>Arch</p>
     <pre><code>$ sudo pacman -S penguins-eggs
-$ sudo pacman -U penguins-eggs_25.11.21-1_amd64-1-x86_64.pkg.tar.zst
+$ sudo pacman -U penguins-eggs_25.12.7-1_amd64-1-x86_64.pkg.tar.zst
 </code></pre>
     <p>Debian/Devuan/Ubuntu</p>
     <pre><code>$ sudo apt install penguins-eggs
-$ sudo dpkg -i penguins-eggs_25.11.21-1_amd64.deb
+$ sudo dpkg -i penguins-eggs_25.12.7-1_amd64.deb
 </code></pre>
     <p>Fedora</p>
-    <pre><code>$ sudo dnf install ./penguins-eggs_25.11.21-1_amd64-1fedora.x86_64.rpm
+    <pre><code>$ sudo dnf install ./penguins-eggs_25.12.7-1_amd64-1fedora.x86_64.rpm
 </code></pre>
     <p>Manjaro</p>
     <pre><code>$ sudo pamac install penguins-eggs
 </code></pre>
     <p>OpenMamba</p>
-    <pre><code>$ sudo dnf install ./penguins-eggs_25.11.21-1_amd64-1mamba.x86_64.rpm
+    <pre><code>$ sudo dnf install ./penguins-eggs_25.12.7-1_amd64-1mamba.x86_64.rpm
 </code></pre>
     <h1>USAGE</h1>
     <pre><code>$ eggs (-v|--version|version)
 
-penguins-eggs/25.11.21  
+penguins-eggs/25.12.7  
 $ eggs --help [COMMAND]
 
 USAGE
@@ -79,7 +79,8 @@ sudo eggs dad
       <li><a href="#eggs-love"><code>eggs love</code></a></li>
       <li><a href="#eggs-mom"><code>eggs mom</code></a></li>
       <li><a href="#eggs-produce"><code>eggs produce</code></a></li>
-      <li><a href="#eggs-setup"><code>eggs setup</code></a></li>
+      <li><a href="#eggs-setup-install"><code>eggs setup install</code></a></li>
+      <li><a href="#eggs-setup-purge"><code>eggs setup purge</code></a></li>
       <li><a href="#eggs-status"><code>eggs status</code></a></li>
       <li><a href="#eggs-tools-clean"><code>eggs tools clean</code></a></li>
       <li><a href="#eggs-tools-repo"><code>eggs tools repo</code></a></li>
@@ -444,24 +445,35 @@ EXAMPLES
 
   sudo eggs produce --basename=colibri
 </code></pre>
-    <h2><code>eggs setup</code></h2>
+    <h2><code>eggs setup install</code></h2>
     <p>Automatically check and install system prerequisites</p>
     <pre><code>USAGE
-  $ eggs setup [-c] [-f]
+  $ eggs setup install
 
-FLAGS
-  -c, --check  check status only, do not install
-  -f, --force  force installation even if already installed
+DESCRIPTION
+  Automatically check and install system prerequisites
+
+EXAMPLES
+  $ eggs setup                           # this help
+
+  sudo eggs setup install              # install native dependencies, autocomplete, man, etc
+
+  sudo eggs setup purge                # purge all configurations, autocomplete, man, etc installed from penguins-eggs AppImage
+</code></pre>
+    <h2><code>eggs setup purge</code></h2>
+    <p>Automatically check and install system prerequisites</p>
+    <pre><code>USAGE
+  $ eggs setup purge
 
 DESCRIPTION
   Automatically check and install system prerequisites
 
 EXAMPLES
-  sudo eggs setup                      # install prerequisites
+  $ eggs setup                           # this help
 
-  sudo eggs setup --check              # check prerequisites presence
+  sudo eggs setup install              # install native dependencies, autocomplete, man, etc
 
-  sudo eggs setup --force              # force prerequisites install
+  sudo eggs setup purge                # purge all configurations, autocomplete, man, etc installed from penguins-eggs AppImage
 </code></pre>
     <h2><code>eggs status</code></h2>
     <p>informations about eggs status</p>