penguins-eggs 25.8.6 → 25.9.2

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

@@ -25,63 +25,13 @@ export default class Kernel {
      * ALL PRIVATE
      */
     /**
-     * vmlinuxFromCmdline
-     * BOOT_IMAGE=/boot/vmlinuz-5.16.0-3-amd64 root=UUID=13768873-d6ba-4ae5-9e14-b5011f5aa31c ro quiet splash resume=UUID=beafb9b4-c429-4e1f-a268-4270b63a14e6
-     * se non è presente - come nel caso di Franco Conidi - lo ricostruisce da initrd
-     */
-    private static vmlinuxFromCmdline;
-    /**
-         *
-         * @param kernel
-         * @returns
-         */
-    private static vmLinuxFromFiles;
-    /**
-     * Rileva automaticamente il kernel dai moduli disponibili
-     */
-    private static detectKernelFromModules;
-    /**
-     * Ottiene il path per un kernel specifico
+     * most of the distros:
+     * debian, fedora, opensuse, rasberry
      */
-    private static getSpecificKernelPath;
+    private static vmlinuxFromUname;
     /**
-     * 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
+     * vmlinuxFromCmdline
+     * raspbery /proc/cmdline dont contain it
      */
-    private static getCurrentKernelInfo;
+    private static vmlinuxFromCmdline;
 }

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

@@ -7,9 +7,9 @@
 import fs from 'node:fs';
 import path from 'path';
 import Distro from '../distro.js';
-import Diversions from '../diversions.js';
 import Utils from '../utils.js';
 import { execSync } from 'node:child_process';
+import Diversions from '../diversions.js';
 /**
  * Kernel utilities for managing vmlinuz and initramfs paths
  */
@@ -21,18 +21,23 @@ export default class Kernel {
      */
     static vmlinuz(kernel = '') {
         let vmlinuz = '';
-        /**
-         * metodo /proc/cmdline
-         */
         if (!Utils.isContainer()) {
-            vmlinuz = this.vmlinuxFromCmdline();
+            vmlinuz = this.vmlinuxFromUname();
+            if (vmlinuz === '') {
+                vmlinuz = this.vmlinuxFromCmdline();
+                if (vmlinuz === '') {
+                    console.log('vmlinuz not found');
+                    process.exit(1);
+                }
+            }
         }
         else {
-            vmlinuz = this.vmLinuxFromFiles(kernel);
+            Utils.warning("cannot work on containers actually!");
+            process.exit(1);
         }
         if (!fs.existsSync(vmlinuz)) {
             console.log(`file ${vmlinuz} does not exist!`);
-            process.exit();
+            process.exit(1);
         }
         return vmlinuz;
     }
@@ -50,36 +55,41 @@ export default class Kernel {
                 kernel = execSync('uname -r').toString().trim();
             }
             else {
-                const kernelModulesPath = this.getKernelModulesPath();
-                const kernels = this.getAvailableKernels(kernelModulesPath);
-                const latestKernel = kernels[kernels.length - 1];
-                kernel = latestKernel;
+                Utils.warning("cannot work on containers actually!");
+                process.exit(1);
             }
         }
-        if (distro.familyId === "archlinux") {
-            initramfs = this.getArchInitramfs(kernel, distro);
+        // rolling...
+        if (distro.familyId === "alpine") {
+            let suffix = kernel.substring(kernel.lastIndexOf('-'));
+            initramfs = `/boot/initramfs${suffix}`;
+        }
+        else if (distro.familyId === "archlinux" && (!Diversions.isManjaroBased(distro.distroId))) {
+            let suffix = kernel.substring(kernel.lastIndexOf('-'));
+            initramfs = `/boot/initramfs-linux${suffix}.img`;
         }
-        else if (distro.familyId === "alpine") {
-            initramfs = '/boot/initramfs-lts';
+        else if (distro.familyId === "archlinux" && (Diversions.isManjaroBased(distro.distroId))) {
+            let version = kernel.split('.').slice(0, 2).join('.');
+            initramfs = `/boot/initramfs-${version}-x86_64.img`;
         }
         else {
-            // Gestione generica per le altre distro (Debian, Fedora, SUSE, ecc.)
-            const possiblePaths = [
-                `/boot/initrd.img-${kernel}`, // Debian, Ubuntu e derivate
-                `/boot/initramfs-${kernel}.img`, // Fedora, RHEL, CentOS e derivate
+            // Gestione generica per le altre distro (Debian, Fedora, SUSE, OpenMamba, cc.)
+            const candidates = [
+                `/boot/initrd.img-${kernel}`, // Debian, Ubuntu
+                `/boot/initramfs-${kernel}.img`, // Fedora, RHEL
+                `/boot/initramfs-${kernel}-1mamba-x86_64.img`, // Openmamba
                 `/boot/initrd-${kernel}`, // openSUSE
-                `/boot/initramfs-${kernel}` // fallback generico
+                `/boot/initramfs-${kernel}`, // fallbacks
             ];
-            for (const path of possiblePaths) {
-                if (fs.existsSync(path)) {
-                    initramfs = path;
+            for (const candidate of candidates) {
+                if (fs.existsSync(candidate)) {
+                    initramfs = candidate;
                     break;
                 }
             }
         }
         if (!fs.existsSync(initramfs)) {
             console.error(`ERROR: initramfs file ${initramfs} does not exist!`);
-            this.listAvailableInitramfs();
             process.exit(1);
         }
         return initramfs;
@@ -87,10 +97,23 @@ export default class Kernel {
     /**
      * ALL PRIVATE
      */
+    /**
+     * most of the distros:
+     * debian, fedora, opensuse, rasberry
+     */
+    static vmlinuxFromUname() {
+        const kernelVersion = execSync('uname -r').toString().trim();
+        let kernelPath = `/boot/vmlinuz-${kernelVersion}`;
+        if (fs.existsSync(kernelPath)) {
+            return kernelPath;
+        }
+        else {
+            return '';
+        }
+    }
     /**
      * vmlinuxFromCmdline
-     * BOOT_IMAGE=/boot/vmlinuz-5.16.0-3-amd64 root=UUID=13768873-d6ba-4ae5-9e14-b5011f5aa31c ro quiet splash resume=UUID=beafb9b4-c429-4e1f-a268-4270b63a14e6
-     * se non è presente - come nel caso di Franco Conidi - lo ricostruisce da initrd
+     * raspbery /proc/cmdline dont contain it
      */
     static vmlinuxFromCmdline() {
         let distro = new Distro();
@@ -112,7 +135,8 @@ export default class Kernel {
             }
         });
         // btrfs: eg: /@root/boot/vmlinuz
-        if (vmlinuz.indexOf('@')) {
+        //if (vmlinuz.indexOf('@')) {
+        if (vmlinuz.includes('@')) {
             let subvolumeEnd = vmlinuz.indexOf('/', vmlinuz.indexOf('@'));
             vmlinuz = vmlinuz.substring(subvolumeEnd);
         }
@@ -124,260 +148,6 @@ export default class Kernel {
                 vmlinuz = `/boot${vmlinuz}`;
             }
         }
-        /**
-         * If vmlinuz not found
-         */
-        if (vmlinuz === '') {
-            let version = 'linux';
-            if (distro.familyId === 'debian') {
-                cmdline.forEach(cmd => {
-                    if (cmd.includes('initrd.img')) {
-                        version = cmd.substring(cmd.indexOf('initrd.img') + 10);
-                    }
-                });
-            }
-            else if (distro.distroId === 'Manjaro') {
-                cmdline.forEach(cmd => {
-                    if (cmd.includes('initrd.img')) {
-                        version = cmd.substring(cmd.indexOf('initrd.img') + 10);
-                    }
-                });
-            }
-            vmlinuz = '/boot/vmlinuz-' + version;
-        }
         return vmlinuz;
     }
-    /**
-         *
-         * @param kernel
-         * @returns
-         */
-    static vmLinuxFromFiles(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;
-    }
-    /**
-     * 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.js

@@ -80,25 +80,33 @@ export default class Utils {
         if (codenameId === 'rolling' || codenameId === '') {
             const releaseId = Utils.getOsRelease().VERSION_ID.trim();
             if (releaseId !== '') {
-                result += `${releaseId}-`;
+                result += releaseId;
             }
         }
         else {
-            result += `${codenameId.toLowerCase()}-`;
+            result += `${codenameId.toLowerCase()}`;
+        }
+        if (!result.endsWith('-')) {
+            result += '-';
         }
-        result = result.replace(`/`, '-');
         return result;
     }
     /**
      * Detect if running inside a container (Docker or LXC)
      */
     static isContainer() {
-        let isContainer = false;
-        let pathToCheck = '/ci/README.md';
-        if (fs.existsSync(pathToCheck)) {
-            isContainer = true;
+        // Check for Docker's specific file
+        if (fs.existsSync('/.dockerenv')) {
+            return true;
+        }
+        // Check the cgroup file, which works for Docker, Podman, LXC, etc.
+        try {
+            const cgroupContent = fs.readFileSync('/proc/1/cgroup', 'utf8');
+            return cgroupContent.includes('/docker/') || cgroupContent.includes('/kubepods/');
+        }
+        catch (e) {
+            return false;
         }
-        return isContainer;
     }
     /**
      * Check if the system uses Systemd

package/dist/commands/cuckoo.d.ts

@@ -11,6 +11,7 @@ export default class Cuckoo extends Command {
     static examples: string[];
     static flags: {
         help: import("@oclif/core/interfaces").BooleanFlag<void>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }

package/dist/commands/cuckoo.js

@@ -14,7 +14,8 @@ export default class Cuckoo extends Command {
     static description = 'PXE start with proxy-dhcp';
     static examples = ['sudo eggs cuckoo'];
     static flags = {
-        help: Flags.help({ char: 'h' })
+        help: Flags.help({ char: 'h' }),
+        verbose: Flags.boolean({ char: 'v', description: 'verbose' })
     };
     async run() {
         const { args, flags } = await this.parse(Cuckoo);
@@ -24,7 +25,7 @@ export default class Cuckoo extends Command {
             settings.load();
             const nest = settings.config.snapshot_mnt;
             const pxeRoot = nest + 'pxe';
-            const pxe = new Pxe(nest, pxeRoot);
+            const pxe = new Pxe(nest, pxeRoot, flags.verbose);
             await pxe.fertilization();
             await pxe.build();
             const n = new network();

package/dist/commands/export/pkg.js

@@ -121,7 +121,7 @@ export default class ExportPkg extends Command {
         }
         else if (familyId === 'openmamba') {
             Utils.warning("openmamba rpm packages");
-            localPath = `/usr/src/RPM/RPMS/x86_64`;
+            localPath = `/home/${this.user}/rpmbuild/RPMS/x86_64`;
             remotePath = this.Tu.config.remotePathPackages + "/openmamba";
             filter = `penguins-eggs-[0-9][0-9].@([0-9]|[0-1][0-9]).@([0-9]|[0-3][0-9])-*mamba.*.rpm`;
             /**

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

@@ -29,6 +29,9 @@ export default async function addUser(username = 'live', password = 'evolution',
     else if (this.distro.familyId === 'fedora') {
         cmd = `chroot ${this.installTarget} adduser ${username} --create-home --shell /bin/bash --comment "${fullusername},${roomNumber},${workPhone},${homePhone}" ${this.toNull}`;
     }
+    else if (this.distro.familyId === 'openmamba') {
+        cmd = `chroot ${this.installTarget} useradd ${username} --create-home --shell /bin/bash --comment "${fullusername},${roomNumber},${workPhone},${homePhone}" ${this.toNull}`;
+    }
     else if (this.distro.familyId === 'opensuse') {
         cmd = `chroot ${this.installTarget} useradd ${username} --create-home --shell /bin/bash --comment "${fullusername},${roomNumber},${workPhone},${homePhone}" ${this.toNull}`;
     }
@@ -39,6 +42,9 @@ export default async function addUser(username = 'live', password = 'evolution',
     if (this.distro.familyId === 'debian') {
         group = 'sudo';
     }
+    else if (this.distro.familyId === 'openmamba') {
+        group = 'sysadmin';
+    }
     cmd = `chroot ${this.installTarget} usermod -aG ${group} ${username} ${this.toNull}`;
     await exec(cmd, this.echo);
     // add autologin group in archlinux

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

@@ -21,7 +21,15 @@ export default async function bootloader() {
     /**
      * grub-install: added --force per fedora family
      */
-    let cmd = `chroot ${this.installTarget} ${grubName}-install ${this.partitions.installationDevice} ${grubForce} ${this.toNull}`;
+    // define grub-install --target=${target}
+    let target = `x86_64-efi`;
+    if (!this.efi) {
+        target = 'i386-pc';
+    }
+    if (process.arch === 'arm64') {
+        target = `arm64-efi`;
+    }
+    let cmd = `chroot ${this.installTarget} ${grubName}-install --target=${target} ${this.partitions.installationDevice} ${grubForce} ${this.toNull}`;
     await exec(cmd, this.echo);
     /**
      * grub-mkconfig

package/dist/krill/classes/sequence.js

@@ -140,7 +140,7 @@ export default class Sequence {
         this.devices.data = {};
         this.devices.swap = {};
         this.distro = new Distro();
-        this.efi = fs.existsSync('/sys/firmware/efi/efivars');
+        this.efi = fs.existsSync('/efivars');
         this.luksFile = `${this.distro.liveMediumPath}live/${this.luksName}`;
     }
     /**

package/dist/lib/utils.js

@@ -38,6 +38,7 @@ export async function exec(command, { echo = false, ignore = false, capture = fa
      */
     return new Promise((resolve, reject) => {
         if (echo) {
+            // seem no need!
             console.log(command);
         }
         const child = spawn('bash', ['-c', command], {