penguins-eggs 25.10.28 → 25.11.8

package/dist/classes/users.js

@@ -0,0 +1,143 @@
+/**
+ * ./src/classes/users.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 { exec } from '../lib/utils.js';
+/**
+ *
+ */
+export default class Users {
+    gecos;
+    gid;
+    hasHome;
+    home;
+    login;
+    password;
+    saveIt;
+    shell;
+    size;
+    uid;
+    constructor(login, password, uid, gid, gecos, home, shell) {
+        this.login = login;
+        this.password = password;
+        this.uid = uid;
+        this.gid = gid;
+        this.gecos = gecos;
+        this.home = home;
+        this.shell = shell;
+        this.size = 0;
+        this.hasHome = false;
+        this.saveIt = false;
+    }
+    /**
+     * getSize
+     * @param verbose
+     */
+    async getValues() {
+        const fLevels = [
+            { path: 'bin', saveIt: false },
+            { path: 'boot', saveIt: false },
+            { path: 'dev', saveIt: false },
+            { path: 'etc', saveIt: false },
+            { path: 'lib', saveIt: false },
+            { path: 'lib32,', saveIt: false },
+            { path: 'libx32', saveIt: false },
+            { path: 'lib64', saveIt: false },
+            { path: 'home', saveIt: true },
+            { path: 'media', saveIt: false },
+            { path: 'mnt', saveIt: false },
+            { path: 'opt', saveIt: true },
+            { path: 'proc', saveIt: false },
+            { path: 'root', saveIt: false },
+            { path: 'run', saveIt: false },
+            { path: 'sbin', saveIt: false },
+            { path: 'sys', saveIt: false },
+            { path: 'srv', saveIt: true },
+            { path: 'tmp', saveIt: false },
+            { path: 'usr', saveIt: true },
+            { path: 'var', saveIt: true }
+        ];
+        let hasHome = false;
+        let saveIt = false;
+        let size = 0;
+        // Only users not services
+        if (Number.parseInt(this.uid) >= 1000) {
+            if (this.home != undefined) {
+                /**
+                 * analyze firstLevel and
+                 * excluded to be saved
+                 */
+                const fLevel = this.home.split('/')[1];
+                for (const fLevel_ of fLevels) {
+                    if (fLevel_.path === fLevel) {
+                        saveIt = fLevel_.saveIt;
+                    }
+                }
+                /**
+                 * analize second level
+                 * examples: /var/run, /var/cache, /var/spool, etc
+                 */
+                if (saveIt) {
+                    const sLevel = this.home.split('/')[2];
+                    if (sLevel === 'cache' || sLevel === 'run' || sLevel === 'spool') {
+                        saveIt = false;
+                    }
+                }
+                /**
+                 * exclude to save if home don't exist
+                 */
+                if (!fs.existsSync(this.home)) {
+                    saveIt = false;
+                }
+                /**
+                 * others motivations to exclude
+                 */
+                if (saveIt) {
+                    switch (this.home) {
+                        /**
+                         * exclude always /
+                         */
+                        case '/': {
+                            break;
+                        }
+                        /**
+                         * excludes: under /usr
+                         */
+                        case '/usr/bin':
+                        case '/usr/sbin': {
+                            saveIt = false;
+                            break;
+                        }
+                        /**
+                         * excludes: under var
+                         */
+                        case '/var/backups':
+                        case '/var/lib/colord':
+                        case '/var/lib/geoclue':
+                        case '/var/lib/misc':
+                        case '/var/mail': {
+                            saveIt = false;
+                            break;
+                        }
+                        default: {
+                            if (fs.existsSync(this.home)) {
+                                hasHome = true;
+                                const sizeUser = await exec(` du --block-size=1 --summarize ${this.home} | awk '{print $1}'`, { capture: true, echo: false, ignore: false });
+                                size = Number.parseInt(sizeUser.data);
+                            }
+                            saveIt = true;
+                            break;
+                        }
+                    }
+                }
+            }
+            this.saveIt = saveIt;
+            this.size = size;
+            this.hasHome = hasHome;
+        }
+    }
+}

package/dist/classes/utils.d/kernel.d.ts

@@ -0,0 +1,39 @@
+/**
+ * penguins-eggs
+ *
+ * Kernel management utilities
+ * Handle vmlinuz and initramfs detection across different distributions
+ */
+/**
+ * Kernel utilities for managing vmlinuz and initramfs paths
+ */
+export default class Kernel {
+    /**
+     * Ricava path per vmlinuz
+     *
+     * @returns Path al file vmlinuz
+     */
+    static vmlinuz(kernel?: string): string;
+    /**
+     * cerca il path per initramfs/initrd nella directory /boot
+     * se fallisce, prova la convenzione Arch
+     *
+     * @param kernel - Versione del kernel (es. '6.5.0-14-generic'). Se omessa, usa il kernel in esecuzione.
+     * @returns Path al file initramfs.
+     */
+    static initramfs(kernel?: string): string;
+    /**
+     * ALL PRIVATE
+     */
+    /**
+     * most of the distros:
+     * debian, fedora, opensuse, rasberry
+     */
+    private static vmlinuzFromUname;
+    /**
+     * vmlinuxFromCmdline
+     *
+     * It's used mostly on Manjaro
+     */
+    private static vmlinuzFromCmdline;
+}

package/dist/classes/utils.d/kernel.js

@@ -0,0 +1,206 @@
+/**
+ * penguins-eggs
+ *
+ * Kernel management utilities
+ * Handle vmlinuz and initramfs detection across different distributions
+ */
+import fs from 'node:fs';
+import path from 'path';
+import Distro from '../distro.js';
+import Utils from '../utils.js';
+import { execSync } from 'node:child_process';
+/**
+ * Kernel utilities for managing vmlinuz and initramfs paths
+ */
+export default class Kernel {
+    /**
+     * Ricava path per vmlinuz
+     *
+     * @returns Path al file vmlinuz
+     */
+    static vmlinuz(kernel = '') {
+        let vmlinuz = '';
+        if (!Utils.isContainer()) {
+            vmlinuz = this.vmlinuzFromUname();
+            if (vmlinuz === '') {
+                vmlinuz = this.vmlinuzFromCmdline();
+                if (vmlinuz === '') {
+                    console.log('vmlinuz not found');
+                    process.exit(1);
+                }
+            }
+        }
+        else {
+            Utils.warning("cannot work on containers actually!");
+            process.exit(1);
+        }
+        if (!fs.existsSync(vmlinuz)) {
+            console.log(`vmlinuz: ${vmlinuz} does not exist!`);
+            process.exit(1);
+        }
+        return vmlinuz;
+    }
+    /**
+     * cerca il path per initramfs/initrd nella directory /boot
+     * se fallisce, prova la convenzione Arch
+     *
+     * @param kernel - Versione del kernel (es. '6.5.0-14-generic'). Se omessa, usa il kernel in esecuzione.
+     * @returns Path al file initramfs.
+     */
+    static initramfs(kernel = '') {
+        let targetKernel = kernel;
+        // 1. Determina la versione del kernel target
+        if (targetKernel === '') {
+            if (Utils.isContainer()) {
+                Utils.warning("Non è possibile determinare il kernel in un container.");
+                process.exit(1);
+            }
+            targetKernel = execSync('uname -r').toString().trim();
+        }
+        const kernelVersionShort = targetKernel.split('.').slice(0, 2).join('.');
+        const bootDir = '/boot';
+        // 2. Leggi tutti i file nella directory /boot
+        let bootFiles;
+        try {
+            bootFiles = fs.readdirSync(bootDir);
+        }
+        catch (error) {
+            console.error(`ERRORE: Impossibile leggere la directory ${bootDir}.`);
+            process.exit(1);
+        }
+        // 3. Cerca il file corrispondente con un sistema di priorità
+        const candidates = [];
+        for (const filename of bootFiles) {
+            if ((filename.startsWith('initramfs-') ||
+                filename.startsWith('initrd.img-') ||
+                filename.startsWith('initrd-')) &&
+                (filename.includes(targetKernel) || filename.includes(kernelVersionShort))) {
+                candidates.push(filename);
+            }
+        }
+        // Se troviamo almeno un candidato, usiamo quello
+        if (candidates.length > 0) {
+            let foundPath = path.join(bootDir, candidates[0]);
+            /**
+             * ma, se sono più di uno, usiamo il più breve
+             * per evitare estensioni come -fallback.img, .old, .bak, etc
+             */
+            if (candidates.length > 1) {
+                // Filtra i candidati per escludere quelli di fallback se esiste un'alternativa
+                const nonFallbackCandidates = candidates.filter(c => !c.includes('-fallback'));
+                const searchArray = nonFallbackCandidates.length > 0 ? nonFallbackCandidates : candidates;
+                foundPath = path.join(bootDir, searchArray[0]); // Inizia con il primo
+                for (const candidate of searchArray) {
+                    const current = path.join(bootDir, candidate);
+                    if (current.length < foundPath.length) {
+                        foundPath = current;
+                    }
+                }
+            }
+            return foundPath;
+        }
+        // 4. Fallback per casi specifici (Arch e Alpine Linux)
+        // Questo viene eseguito solo se la ricerca dinamica fallisce.
+        const staticFallbacks = [
+            // --- Alpine Linux ---
+            'initramfs-lts', // Kernel Long-Term Support
+            'initramfs-virt', // Kernel per ambienti virtualizzati
+            'initramfs-standard', // Kernel standard (meno comune)
+            'initramfs-rpi', // Kernel per Raspberry Pi
+            // --- Arch Linux ---
+            'initramfs-linux.img', // Arch Linux standard
+            'initramfs-linux-lts.img', // Arch Linux LTS
+            'initramfs-linux-zen.img', // Arch Linux Zen
+            'initramfs-linux-hardened.img', // Arch Linux hardened
+            // --- Cacky Linux ---
+            'initramfs-linux-cachyos.img', // Cachyos standard
+            'initramfs-linux-cachyos-lts.img', // Cachyos LTS
+            'initramfs-linux-cachyos-zen.img', // Cachyos zen
+            'initramfs-linux-cachyos-hardened.img', // Cachyos hardened
+        ];
+        for (const fallback of staticFallbacks) {
+            const fallbackPath = path.join(bootDir, fallback);
+            if (fs.existsSync(fallbackPath)) {
+                // Nota: questo potrebbe non corrispondere al 100% al kernel in esecuzione,
+                // ma è il comportamento atteso su questi sistemi
+                return fallbackPath;
+            }
+        }
+        // 5. Se nessuna delle strategie ha funzionato, esci con errore
+        Utils.warning(`Could not find an initramfs file for kernel ${targetKernel} in ${bootDir}.`);
+        process.exit(1);
+    }
+    /**
+     * ALL PRIVATE
+     */
+    /**
+     * most of the distros:
+     * debian, fedora, opensuse, rasberry
+     */
+    static vmlinuzFromUname() {
+        let kernelVersion = execSync('uname -r').toString().trim();
+        // Try 1: path standard (es. Debian, Ubuntu, Fedora)
+        let standardPath = `/boot/vmlinuz-${kernelVersion}`;
+        if (fs.existsSync(standardPath)) {
+            return standardPath;
+        }
+        // Try 2: Arch Linux
+        let archPath = '';
+        if (kernelVersion.includes("-lts")) {
+            archPath = `/boot/vmlinuz-linux-lts`;
+        }
+        else if (kernelVersion.includes("-zen")) {
+            archPath = `/boot/vmlinuz-linux-zen`;
+        }
+        else if (kernelVersion.includes("-hardened")) {
+            archPath = `/boot/vmlinuz-linux-hardened`;
+        }
+        else if (kernelVersion.includes("-arch")) {
+            archPath = `/boot/vmlinuz-linux`;
+        }
+        // Se abbiamo trovato un percorso per Arch e il file esiste, lo ritorniamo
+        if (archPath && fs.existsSync(archPath)) {
+            return archPath;
+        }
+        // return an empty string: manjaro
+        return '';
+    }
+    /**
+     * vmlinuxFromCmdline
+     *
+     * It's used mostly on Manjaro
+     */
+    static vmlinuzFromCmdline() {
+        let distro = new Distro();
+        let vmlinuz = '';
+        const cmdline = fs.readFileSync('/proc/cmdline', 'utf8').split(" ");
+        cmdline.forEach(cmd => {
+            if (cmd.includes('BOOT_IMAGE')) {
+                vmlinuz = cmd.substring(cmd.indexOf('=') + 1);
+                // patch per fedora BOOT_IMAGE=(hd0,gpt2)/vmlinuz-6.9.9-200.fc40.x86_64
+                if (vmlinuz.includes(")")) {
+                    vmlinuz = cmd.substring(cmd.indexOf(')') + 1);
+                }
+                if (!fs.existsSync(vmlinuz)) {
+                    if (fs.existsSync(`/boot/${vmlinuz}`)) {
+                        vmlinuz = `/boot/${vmlinuz}`;
+                    }
+                }
+            }
+        });
+        // btrfs: eg: /@root/boot/vmlinuz
+        if (vmlinuz.includes('@')) {
+            let subvolumeEnd = vmlinuz.indexOf('/', vmlinuz.indexOf('@'));
+            vmlinuz = vmlinuz.substring(subvolumeEnd);
+        }
+        /**
+         * Take always /boot/vmlinuz if exists
+         */
+        if (path.dirname(vmlinuz) === '/') {
+            if (fs.existsSync(`/boot${vmlinuz}`)) {
+                vmlinuz = `/boot${vmlinuz}`;
+            }
+        }
+        return vmlinuz;
+    }
+}