penguins-eggs 10.1.0 → 25.7.7

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

@@ -0,0 +1,83 @@
+/**
+ * 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
+     *
+     * Normalmente cerca BOOT_IMAGE nei parametri del kernel
+     * BOOT_IMAGE=/boot/vmlinuz-5.16.0-3-amd64 root=UUID=... ro quiet splash
+     *
+     * Se non è presente, come nel caso di Franco, cerca initrd e ricostruisce vmlinuz
+     * ro root=UUID=... initrd=boot\initrd.img-5.15.0-0.bpo.3-amd64
+     *
+     * @param kernel - Versione specifica del kernel (opzionale)
+     * @returns Path al file vmlinuz
+     */
+    static vmlinuz(kernel?: string): string;
+    /**
+     * Ricava path per initramfs/initrd
+     *
+     * @param kernel - Versione del kernel
+     * @returns Path al file initramfs
+     */
+    static initramfs(kernel?: string): string;
+    /**
+     * Rileva automaticamente il kernel dai moduli disponibili
+     */
+    private static detectKernelFromModules;
+    /**
+     * Ottiene il path per un kernel specifico
+     */
+    private static getSpecificKernelPath;
+    /**
+     * Trova la directory dei moduli del kernel
+     */
+    private static getKernelModulesPath;
+    /**
+     * Ottiene la lista dei kernel disponibili, ordinati
+     */
+    private static getAvailableKernels;
+    /**
+     * Gestisce il rilevamento del kernel per Arch Linux
+     */
+    private static getArchLinuxKernelPath;
+    /**
+     * Gestisce il path del kernel per Manjaro
+     */
+    private static getManjaroKernelPath;
+    /**
+     * Gestisce il path del kernel standard per Arch Linux
+     */
+    private static getStandardArchKernelPath;
+    /**
+     * Gestisce il kernel specifico per Arch Linux
+     */
+    private static getArchLinuxSpecificKernel;
+    /**
+     * Gestisce initramfs per Arch Linux
+     */
+    private static getArchInitramfs;
+    /**
+     * Lista i kernel disponibili in /boot per debugging
+     */
+    private static listAvailableKernels;
+    /**
+     * Lista gli initramfs disponibili in /boot per debugging
+     */
+    private static listAvailableInitramfs;
+    /**
+     * Ottiene informazioni sul kernel corrente
+     */
+    static getCurrentKernelInfo(): {
+        version: string;
+        vmlinuz: string;
+        initramfs: string;
+    };
+}

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

@@ -0,0 +1,298 @@
+/**
+ * penguins-eggs
+ *
+ * Kernel management utilities
+ * Handle vmlinuz and initramfs detection across different distributions
+ */
+import fs from 'node:fs';
+import Distro from '../distro.js';
+import Diversions from '../diversions.js';
+/**
+ * Kernel utilities for managing vmlinuz and initramfs paths
+ */
+export default class Kernel {
+    /**
+     * Ricava path per vmlinuz
+     *
+     * Normalmente cerca BOOT_IMAGE nei parametri del kernel
+     * BOOT_IMAGE=/boot/vmlinuz-5.16.0-3-amd64 root=UUID=... ro quiet splash
+     *
+     * Se non è presente, come nel caso di Franco, cerca initrd e ricostruisce vmlinuz
+     * ro root=UUID=... initrd=boot\initrd.img-5.15.0-0.bpo.3-amd64
+     *
+     * @param kernel - Versione specifica del kernel (opzionale)
+     * @returns Path al file vmlinuz
+     */
+    static vmlinuz(kernel = '') {
+        const distro = new Distro();
+        let vmlinuz = '';
+        if (kernel === '') {
+            // Auto-detection del kernel dai moduli disponibili
+            vmlinuz = this.detectKernelFromModules(distro);
+        }
+        else {
+            // Kernel specificato manualmente
+            vmlinuz = this.getSpecificKernelPath(kernel, distro);
+        }
+        // Validazione finale
+        if (!fs.existsSync(vmlinuz)) {
+            console.error(`ERROR: file ${vmlinuz} does not exist!`);
+            console.error('Available kernels in /boot:');
+            this.listAvailableKernels();
+            process.exit(1);
+        }
+        return vmlinuz;
+    }
+    /**
+     * Ricava path per initramfs/initrd
+     *
+     * @param kernel - Versione del kernel
+     * @returns Path al file initramfs
+     */
+    static initramfs(kernel = '') {
+        const distro = new Distro();
+        let initramfs = '';
+        if (kernel === '') {
+            // Auto-detection
+            const kernelModulesPath = this.getKernelModulesPath();
+            const kernels = this.getAvailableKernels(kernelModulesPath);
+            const latestKernel = kernels[kernels.length - 1];
+            kernel = latestKernel;
+        }
+        if (distro.familyId === "archlinux") {
+            initramfs = this.getArchInitramfs(kernel, distro);
+        }
+        else if (distro.familyId === "alpine") {
+            initramfs = '/boot/initramfs-lts';
+        }
+        else {
+            // Debian/Ubuntu/derivatives
+            const possiblePaths = [
+                `/boot/initrd.img-${kernel}`,
+                `/boot/initramfs-${kernel}.img`,
+                `/boot/initramfs-${kernel}`,
+                `/boot/initrd-${kernel}` // opensuse
+            ];
+            for (const path of possiblePaths) {
+                if (fs.existsSync(path)) {
+                    initramfs = path;
+                    break;
+                }
+            }
+        }
+        if (!fs.existsSync(initramfs)) {
+            console.error(`ERROR: initramfs file ${initramfs} does not exist!`);
+            this.listAvailableInitramfs();
+            process.exit(1);
+        }
+        return initramfs;
+    }
+    /**
+     * Rileva automaticamente il kernel dai moduli disponibili
+     */
+    static detectKernelFromModules(distro) {
+        const kernelModulesPath = this.getKernelModulesPath();
+        const kernels = this.getAvailableKernels(kernelModulesPath);
+        if (kernels.length === 0) {
+            throw new Error(`No kernels found in ${kernelModulesPath}`);
+        }
+        if (distro.familyId === "archlinux") {
+            return this.getArchLinuxKernelPath(distro, kernelModulesPath, kernels);
+        }
+        else if (distro.familyId === "alpine") {
+            return `/boot/vmlinuz-lts`;
+        }
+        else {
+            // Per Debian/Ubuntu usa l'ultimo kernel disponibile
+            const latestKernel = kernels[kernels.length - 1];
+            return `/boot/vmlinuz-${latestKernel}`;
+        }
+    }
+    /**
+     * Ottiene il path per un kernel specifico
+     */
+    static getSpecificKernelPath(kernel, distro) {
+        if (distro.familyId === "archlinux") {
+            return this.getArchLinuxSpecificKernel(kernel, distro);
+        }
+        else if (distro.familyId === "alpine") {
+            return `vmlinuz-lts`;
+        }
+        else {
+            return `/boot/vmlinuz-${kernel}`;
+        }
+    }
+    /**
+     * Trova la directory dei moduli del kernel
+     */
+    static getKernelModulesPath() {
+        const possiblePaths = ['/usr/lib/modules', '/lib/modules'];
+        for (const path of possiblePaths) {
+            if (fs.existsSync(path)) {
+                return path;
+            }
+        }
+        throw new Error('No kernel modules directory found');
+    }
+    /**
+     * Ottiene la lista dei kernel disponibili, ordinati
+     */
+    static getAvailableKernels(modulesPath) {
+        try {
+            const kernels = fs.readdirSync(modulesPath);
+            return kernels.sort();
+        }
+        catch (error) {
+            throw new Error(`Cannot read kernel modules from ${modulesPath}: ${error}`);
+        }
+    }
+    /**
+     * Gestisce il rilevamento del kernel per Arch Linux
+     */
+    static getArchLinuxKernelPath(distro, modulesPath, kernels) {
+        if (Diversions.isManjaroBased(distro.distroId)) {
+            return this.getManjaroKernelPath(kernels);
+        }
+        else {
+            return this.getStandardArchKernelPath(kernels[0]);
+        }
+    }
+    /**
+     * Gestisce il path del kernel per Manjaro
+     */
+    static getManjaroKernelPath(kernels) {
+        const latestKernel = kernels[kernels.length - 1];
+        const versionMatch = latestKernel.match(/^(\d+)\.(\d+)\./);
+        if (!versionMatch) {
+            throw new Error(`Cannot parse Manjaro kernel version from: ${latestKernel}`);
+        }
+        const [, major, minor] = versionMatch;
+        return `/boot/vmlinuz-${major}.${minor}-x86_64`;
+    }
+    /**
+     * Gestisce il path del kernel standard per Arch Linux
+     */
+    static getStandardArchKernelPath(firstKernel) {
+        const kernelTypeMap = [
+            { pattern: '-lts', name: 'linux-lts' },
+            { pattern: '-hardened', name: 'linux-hardened' },
+            { pattern: '-zen', name: 'linux-zen' }
+        ];
+        // Cerca un tipo specifico di kernel
+        for (const { pattern, name } of kernelTypeMap) {
+            if (firstKernel.includes(pattern)) {
+                return `/boot/vmlinuz-${name}`;
+            }
+        }
+        // Default: kernel linux standard
+        return '/boot/vmlinuz-linux';
+    }
+    /**
+     * Gestisce il kernel specifico per Arch Linux
+     */
+    static getArchLinuxSpecificKernel(kernel, distro) {
+        if (Diversions.isManjaroBased(distro.distroId)) {
+            const versionMatch = kernel.match(/^(\d+)\.(\d+)\./);
+            if (versionMatch) {
+                const [, major, minor] = versionMatch;
+                return `/boot/vmlinuz-${major}.${minor}-x86_64`;
+            }
+        }
+        // Cerca i kernel Arch in ordine di preferenza
+        const archKernelCandidates = [
+            '/boot/vmlinuz-linux',
+            '/boot/vmlinuz-linux-lts',
+            '/boot/vmlinuz-linux-rt'
+        ];
+        for (const candidate of archKernelCandidates) {
+            if (fs.existsSync(candidate)) {
+                return candidate;
+            }
+        }
+        // Se nessun candidato è trovato, prova con il pattern originale
+        return `/boot/vmlinuz-${kernel}`;
+    }
+    /**
+     * Gestisce initramfs per Arch Linux
+     */
+    static getArchInitramfs(kernel, distro) {
+        if (Diversions.isManjaroBased(distro.distroId)) {
+            const versionMatch = kernel.match(/^(\d+)\.(\d+)\./);
+            if (versionMatch) {
+                const [, major, minor] = versionMatch;
+                return `/boot/initramfs-${major}.${minor}-x86_64.img`;
+            }
+        }
+        // Standard Arch initramfs paths
+        const archInitramfsCandidates = [
+            '/boot/initramfs-linux.img',
+            '/boot/initramfs-linux-lts.img',
+            '/boot/initramfs-linux-rt.img',
+            '/boot/initramfs-linux-zen.img',
+            '/boot/initramfs-linux-hardened.img'
+        ];
+        for (const candidate of archInitramfsCandidates) {
+            if (fs.existsSync(candidate)) {
+                return candidate;
+            }
+        }
+        // Fallback generico
+        return `/boot/initramfs-${kernel}.img`;
+    }
+    /**
+     * Lista i kernel disponibili in /boot per debugging
+     */
+    static listAvailableKernels() {
+        try {
+            const bootFiles = fs.readdirSync('/boot')
+                .filter(f => f.startsWith('vmlinuz'))
+                .sort();
+            if (bootFiles.length > 0) {
+                bootFiles.forEach(file => console.error(`  - ${file}`));
+            }
+            else {
+                console.error('  No vmlinuz files found in /boot');
+            }
+        }
+        catch (error) {
+            console.error('  Cannot read /boot directory');
+        }
+    }
+    /**
+     * Lista gli initramfs disponibili in /boot per debugging
+     */
+    static listAvailableInitramfs() {
+        try {
+            const bootFiles = fs.readdirSync('/boot')
+                .filter(f => f.startsWith('initrd') || f.startsWith('initramfs'))
+                .sort();
+            if (bootFiles.length > 0) {
+                console.error('Available initramfs files in /boot:');
+                bootFiles.forEach(file => console.error(`  - ${file}`));
+            }
+            else {
+                console.error('  No initramfs files found in /boot');
+            }
+        }
+        catch (error) {
+            console.error('  Cannot read /boot directory');
+        }
+    }
+    /**
+     * Ottiene informazioni sul kernel corrente
+     */
+    static getCurrentKernelInfo() {
+        try {
+            const version = fs.readFileSync('/proc/version', 'utf8').trim();
+            const kernelRelease = fs.readFileSync('/proc/sys/kernel/osrelease', 'utf8').trim();
+            return {
+                version: kernelRelease,
+                vmlinuz: this.vmlinuz(kernelRelease),
+                initramfs: this.initramfs(kernelRelease)
+            };
+        }
+        catch (error) {
+            throw new Error(`Cannot get current kernel info: ${error}`);
+        }
+    }
+}

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

@@ -0,0 +1,43 @@
+/**
+ * ./src/classes/utils.d/network.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * Network configuration utilities - IP, DNS, gateway detection
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+export default class Network {
+    /**
+     * return the name of network device
+     */
+    static iface(): Promise<string>;
+    /**
+     * address
+     */
+    static address(): string;
+    /**
+     * netmask
+     */
+    static netmask(): string;
+    /**
+     * cidr
+     */
+    static cidr(): string;
+    /**
+     *
+     * broadcast
+    */
+    static broadcast(): string;
+    /**
+     * dns
+     */
+    static getDns(): string[];
+    /**
+     * getDomain
+     */
+    static getDomain(): string;
+    /**
+     * @returns gateway
+     */
+    static gateway(): string;
+}

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

@@ -0,0 +1,133 @@
+/**
+ * ./src/classes/utils.d/network.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * Network configuration utilities - IP, DNS, gateway detection
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import dns from 'dns';
+import os from 'os';
+import shx from 'shelljs';
+import { Netmask } from 'netmask';
+export default class Network {
+    /**
+     * return the name of network device
+     */
+    static async iface() {
+        // return shx.exec(`ifconfig | awk 'FNR==1 { print $1 }' | tr --d :`, { silent: true }).stdout.trim()
+        const interfaces = Object.keys(os.networkInterfaces());
+        let netDeviceName = '';
+        for (const k in interfaces) {
+            if (interfaces[k] != 'lo') {
+                netDeviceName = interfaces[k];
+            }
+        }
+        return netDeviceName;
+    }
+    /**
+     * address
+     */
+    static address() {
+        const interfaces = os.networkInterfaces();
+        let address = '';
+        if (interfaces !== undefined) {
+            for (const devName in interfaces) {
+                const iface = interfaces[devName];
+                if (iface !== undefined) {
+                    for (const alias of iface) {
+                        if (alias.family === 'IPv4' &&
+                            alias.address !== '127.0.0.1' &&
+                            !alias.internal) {
+                            // take just the first!
+                            if (address === '') {
+                                address = alias.address;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return address;
+    }
+    /**
+     * netmask
+     */
+    static netmask() {
+        const interfaces = os.networkInterfaces();
+        let netmask = '';
+        if (interfaces !== undefined) {
+            for (const devName in interfaces) {
+                const iface = interfaces[devName];
+                if (iface !== undefined) {
+                    for (const alias of iface) {
+                        if (alias.family === 'IPv4' &&
+                            alias.address !== '127.0.0.1' &&
+                            !alias.internal) {
+                            // take just the first!
+                            if (netmask === '') {
+                                netmask = alias.netmask;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return netmask;
+    }
+    /**
+     * cidr
+     */
+    static cidr() {
+        const interfaces = os.networkInterfaces();
+        let cidr = '';
+        if (interfaces !== undefined) {
+            for (const devName in interfaces) {
+                const iface = interfaces[devName];
+                if (iface !== undefined) {
+                    for (const alias of iface) {
+                        if (alias.family === 'IPv4' &&
+                            alias.address !== '127.0.0.1' &&
+                            !alias.internal) {
+                            // take just the first!
+                            if (cidr === '') {
+                                if (alias.cidr !== null) {
+                                    cidr = alias.cidr;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return cidr;
+    }
+    /**
+     *
+     * broadcast
+    */
+    static broadcast() {
+        let n = new Netmask(Network.cidr());
+        return n.broadcast;
+    }
+    /**
+     * dns
+     */
+    static getDns() {
+        return dns.getServers();
+    }
+    /**
+     * getDomain
+     */
+    static getDomain() {
+        return shx.exec('domainname', { silent: true }).stdout.trim();
+        // return shx.exec(`route -n | grep 'UG[ \t]' | awk '{print $2}'`, { silent: true }).stdout.trim()
+    }
+    /**
+     * @returns gateway
+     */
+    static gateway() {
+        return shx.exec(`ip r | grep 'default' | awk '{print $3}'`, { silent: true }).stdout.trim();
+        //return shx.exec(`route -n | grep 'UG[ \t]' | awk '{print $2}'`, { silent: true }).stdout.trim()
+    }
+}

package/dist/classes/utils.d/package-info.d.ts

@@ -0,0 +1,55 @@
+/**
+ * ./src/classes/utils.d/package-info.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * Package information and installation mode detection utilities
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+export default class PackageInfo {
+    /**
+     * return the name of the package: penguins-eggs
+     * @returns penguins-eggs
+     */
+    static getPackageName(): string;
+    /**
+     * return the short name of the package: eggs
+     * @returns eggs
+     */
+    static getFriendName(): string;
+    /**
+     * return the version of the package
+     * @returns version example 8.0.0
+     */
+    static getPackageVersion(): string;
+    /**
+     * Get author name
+     */
+    static getAuthorName(): string;
+    /**
+     * Controlla se è un pacchetto deb
+     * /usr/lib/penguins-eggs/bin/node
+     */
+    static isPackage(): boolean;
+    /**
+     * Controlla se è un pacchetto sorgente
+     */
+    static isSources(): boolean;
+    /**
+     * Controlla se è un pacchetto npm
+     */
+    static isNpmPackage(): boolean;
+    /**
+     *
+     */
+    static rootPenguin(): string;
+    /**
+     *
+     * @returns wardrobe
+     */
+    static wardrobe(): Promise<string>;
+    /**
+     * Return the primary user's name
+     */
+    static getPrimaryUser(): Promise<string>;
+}