penguins-eggs 25.11.21 → 25.12.7

package/dist/classes/pacman.js

@@ -5,11 +5,10 @@
  * email: piero.proietti@gmail.com
  * license: MIT
  */
-import { execSync } from 'node:child_process';
+import { shx, execSync } from '../lib/utils.js';
 import fs from 'node:fs';
 // _dirname
 import path from 'node:path';
-import shx from 'shelljs';
 import { exec } from '../lib/utils.js';
 import Distro from './distro.js';
 import Diversions from './diversions.js';
@@ -33,24 +32,35 @@ export default class Pacman {
     distro = {};
     remix = {};
     /**
-     *
+     * autocompleteInstall()
      * @param verbose
      */
-    static async autocompleteInstall(verbose = false) {
+    static async autocompleteInstall() {
         if (Pacman.packageIsInstalled('bash-completion')) {
             if (fs.existsSync('/usr/share/bash-completion/completions/')) {
                 await exec(`cp ${__dirname}/../../scripts/eggs.bash /usr/share/bash-completion/completions/`);
             }
-            else if (fs.existsSync('/etc/bash_completion.d/')) {
-                await exec(`cp ${__dirname}/../../scripts/eggs.bash /etc/bash_completion.d/`);
+        }
+        // Su arch è ok, su debian God know
+        if (Pacman.packageIsInstalled('zsh-completions')) {
+            if (fs.existsSync('/usr/share/zsh/site-functions')) {
+                await exec(`cp ${__dirname}/../../scripts/_eggs /usr/share/zsh/site-functions/`);
             }
         }
     }
+    /**
+     * autocompleteRemove
+     * @param verbose
+     */
+    static async autocompleteRemove(verbose = false) {
+        await exec(`rm -f /usr/share/bash-completion/completions/eggs.bash`);
+        await exec(`rm -f /usr/share/zsh/site-functions/._eggs`);
+    }
     /**
      * return true if calamares is installed
      */
     static calamaresExists() {
-        return this.commandIsInstalled('calamares');
+        return Utils.commandExists('calamares');
     }
     /**
      *
@@ -133,19 +143,6 @@ export default class Pacman {
         }
         return retVal;
     }
-    /**
-     *
-     * @param cmd
-     */
-    static commandIsInstalled(cmd) {
-        let installed = false;
-        // if (shx.exec(`command -V ${cmd} &>/dev/null`).code == 0) {
-        // remove output
-        if (shx.exec(`command -V ${cmd} >/dev/null 2>&1`).code == 0) {
-            installed = true;
-        }
-        return installed;
-    }
     /**
      * Restituisce VERO se i file di configurazione SONO presenti
      */
@@ -186,7 +183,7 @@ export default class Pacman {
         /**
          * Salvo la configurazione di eggs.yaml
          */
-        config.machine_id = Utils.machineId();
+        config.machine_id = ''; //Utils.machineId()
         config.vmlinuz = Utils.vmlinuz();
         config.initrd_img = Utils.initrdImg();
         const settings = new Settings();
@@ -222,7 +219,6 @@ export default class Pacman {
             execSync(`rm -rf ${init}`);
         }
         execSync(`mkdir -p ${init}`);
-        shx.ln('-s', path.resolve(__dirname, '../../addons'), addons);
         shx.cp(path.resolve(__dirname, '../../conf/README.md'), confRoot);
         shx.cp(path.resolve(__dirname, '../../conf/derivatives.yaml'), confRoot);
         shx.cp(path.resolve(__dirname, '../../conf/derivatives_fedora.yaml'), confRoot);
@@ -240,6 +236,21 @@ export default class Pacman {
         shx.cp(path.resolve(__dirname, '../../conf/exclude.list.d/*'), '/etc/penguins-eggs.d/exclude.list.d');
         await this.configurationFresh();
     }
+    /**
+     * Rimozione dei file di configurazione
+     */
+    static async configurationRemove(verbose = false) {
+        const echo = Utils.setEcho(verbose);
+        if (fs.existsSync('/etc/penguins-eggs.d')) {
+            await exec('rm /etc/penguins-eggs.d -rf', echo);
+        }
+        /**
+         * No remove calamares more
+         */
+        // if (fs.existsSync('/etc/calamares')) {
+        //   await exec('rm /etc/calamares -rf', echo)
+        // }
+    }
     /**
      * Ritorna vero se machine-id è uguale
      */
@@ -252,18 +263,6 @@ export default class Pacman {
         }
         return result;
     }
-    /**
-     * Rimozione dei file di configurazione
-     */
-    static async configurationRemove(verbose = true) {
-        const echo = Utils.setEcho(verbose);
-        if (fs.existsSync('/etc/penguins-eggs.d')) {
-            await exec('rm /etc/penguins-eggs.d -rf', echo);
-        }
-        if (fs.existsSync('/etc/calamares')) {
-            await exec('rm /etc/calamares -rf', echo);
-        }
-    }
     /**
      *
      * @returns
@@ -591,22 +590,26 @@ export default class Pacman {
     /**
      * Installa manPage
      */
-    static async manPageInstall(verbose = false) {
-        const manPageSrc = path.resolve(__dirname, '../../manpages/doc/man/eggs.1.gz');
-        if (fs.existsSync(manPageSrc)) {
-            const manPageDest = `/usr/share/man/man1`;
-            if (!fs.existsSync(manPageDest)) {
-                exec(`mkdir ${manPageDest} -p`);
-            }
-            exec(`cp ${manPageSrc} ${manPageDest}`);
-            if (shx.exec('which mandb', { silent: true }).stdout.trim() !== '') {
-                await exec('mandb > /dev/null');
-                if (verbose) {
-                    console.log('manPage eggs installed...');
-                }
+    static async manpageInstall() {
+        const manpageSrc = path.resolve(__dirname, '../../manpages/doc/man/eggs.1.gz');
+        if (fs.existsSync(manpageSrc)) {
+            const manpageDest = `/usr/share/man/man1`;
+            if (!fs.existsSync(manpageDest)) {
+                await exec(`mkdir ${manpageDest} -p`);
             }
+            await exec(`cp ${manpageSrc} ${manpageDest}`);
+            // if (shx.exec('which mandb', { silent: true }).stdout.trim() !== '') {
+            // await exec('mandb > /dev/null')
+            // }
         }
     }
+    /**
+     * manpageRemove
+     */
+    static async manpageRemove() {
+        const manpageEggs = `/usr/share/man/man1/eggs.1.gz`;
+        await exec(`rm -rf ${manpageEggs}`);
+    }
     /**
      *
      * @param debPackage
@@ -674,6 +677,11 @@ export default class Pacman {
         }
         return installed;
     }
+    /**
+     *
+     * @param packageNpm
+     * @returns
+     */
     static async packageNpmLast(packageNpm = 'penguins-eggs') {
         return shx.exec('npm show ' + packageNpm + ' version', { silent: true }).stdout.trim();
     }

package/dist/classes/pve-live.js

@@ -14,7 +14,7 @@
  * This will remove the symbolic link that indicated that the service should be started automatically.
  */
 import path from 'node:path';
-import shx from 'shelljs';
+import { shx } from '../lib/utils.js';
 import Systemctl from './systemctl.js';
 // _dirname
 const __dirname = path.dirname(new URL(import.meta.url).pathname);

package/dist/classes/settings.js

@@ -10,7 +10,7 @@ import yaml from 'js-yaml';
 // packages
 import fs from 'node:fs';
 import os from 'node:os';
-import shx from 'shelljs';
+import { shx } from '../lib/utils.js';
 // pjson
 import { createRequire } from 'node:module';
 const require = createRequire(import.meta.url);

package/dist/classes/sys-users.d.ts

@@ -0,0 +1,76 @@
+/**
+ * src/classes/sys-users.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * * "THE SYSUSER MASTER"
+ * Gestione pura Node.js per utenti e gruppi di sistema.
+ * Sostituisce i binari (useradd/usermod/deluser) per garantire operazioni atomiche
+ * e compatibilità SELinux (Fedora/RHEL) scrivendo file puliti.
+ */
+export interface IPasswdEntry {
+    username: string;
+    password: string;
+    uid: string;
+    gid: string;
+    gecos: string;
+    home: string;
+    shell: string;
+}
+export interface IShadowEntry {
+    username: string;
+    hash: string;
+    lastChange: string;
+    min: string;
+    max: string;
+    warn: string;
+    inactive: string;
+    expire: string;
+}
+export interface IGroupEntry {
+    groupName: string;
+    password: string;
+    gid: string;
+    members: string[];
+}
+export default class SysUsers {
+    private targetRoot;
+    private distroFamily;
+    private passwd;
+    private shadow;
+    private group;
+    private gshadowLines;
+    private subuidLines;
+    private subgidLines;
+    constructor(targetRoot: string, distroFamily: string);
+    /**
+     * Carica tutti i file di configurazione in memoria
+     */
+    load(): void;
+    /**
+     * Salva lo stato della memoria su disco e applica SELinux fix
+     */
+    save(): Promise<void>;
+    /**
+     * Crea un nuovo utente completo
+     */
+    addUser(user: IPasswdEntry, cleanPassword: string): void;
+    /**
+     * Rimuove completamente un utente
+     */
+    removeUser(username: string): void;
+    /**
+     * Aggiunge utente a un gruppo supplementare
+     */
+    addUserToGroup(username: string, groupName: string): void;
+    /**
+     * Cambia password utente
+     */
+    setPassword(username: string, password: string): void;
+    private readFile;
+    private writeFile;
+    private parsePasswd;
+    private serializePasswd;
+    private parseShadow;
+    private serializeShadow;
+    private parseGroup;
+    private serializeGroup;
+}

package/dist/classes/sys-users.js

@@ -0,0 +1,206 @@
+/**
+ * src/classes/sys-users.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * * "THE SYSUSER MASTER"
+ * Gestione pura Node.js per utenti e gruppi di sistema.
+ * Sostituisce i binari (useradd/usermod/deluser) per garantire operazioni atomiche
+ * e compatibilità SELinux (Fedora/RHEL) scrivendo file puliti.
+ */
+import fs from 'fs';
+import path from 'path';
+import * as bcrypt from 'bcryptjs';
+import { exec } from '../lib/utils.js';
+export default class SysUsers {
+    targetRoot;
+    distroFamily;
+    // Cache in memoria
+    passwd = [];
+    shadow = [];
+    group = [];
+    // File "minori" gestiti a righe raw per semplicità
+    gshadowLines = [];
+    subuidLines = [];
+    subgidLines = [];
+    constructor(targetRoot, distroFamily) {
+        this.targetRoot = targetRoot;
+        this.distroFamily = distroFamily;
+    }
+    /**
+     * Carica tutti i file di configurazione in memoria
+     */
+    load() {
+        this.passwd = this.parsePasswd(this.readFile('etc/passwd'));
+        this.shadow = this.parseShadow(this.readFile('etc/shadow'));
+        this.group = this.parseGroup(this.readFile('etc/group'));
+        this.gshadowLines = this.readFile('etc/gshadow');
+        this.subuidLines = this.readFile('etc/subuid');
+        this.subgidLines = this.readFile('etc/subgid');
+    }
+    /**
+     * Salva lo stato della memoria su disco e applica SELinux fix
+     */
+    async save() {
+        // Serializzazione
+        const passwdContent = this.serializePasswd(this.passwd);
+        const shadowContent = this.serializeShadow(this.shadow);
+        const groupContent = this.serializeGroup(this.group);
+        // Scrittura Atomica + Fix SELinux
+        await this.writeFile('etc/passwd', passwdContent, 'passwd_file_t');
+        await this.writeFile('etc/shadow', shadowContent, 'shadow_t');
+        await this.writeFile('etc/group', groupContent, 'passwd_file_t');
+        // File raw
+        if (this.gshadowLines.length > 0)
+            await this.writeFile('etc/gshadow', this.gshadowLines.join('\n'), 'shadow_t');
+        if (this.subuidLines.length > 0)
+            await this.writeFile('etc/subuid', this.subuidLines.join('\n'), 'passwd_file_t');
+        if (this.subgidLines.length > 0)
+            await this.writeFile('etc/subgid', this.subgidLines.join('\n'), 'passwd_file_t');
+    }
+    // =========================================================================
+    // API PUBBLICA
+    // =========================================================================
+    /**
+     * Crea un nuovo utente completo
+     */
+    addUser(user, cleanPassword) {
+        // Rimuovi se esiste (idempotenza)
+        this.removeUser(user.username);
+        // 1. Passwd
+        this.passwd.push(user);
+        // 2. Shadow (Hash Password)
+        const salt = bcrypt.genSaltSync(10);
+        const hash = bcrypt.hashSync(cleanPassword, salt);
+        this.shadow.push({
+            username: user.username,
+            hash: hash,
+            lastChange: '19700', // Data approssimativa
+            min: '0',
+            max: '99999',
+            warn: '7',
+            inactive: '',
+            expire: ''
+        });
+        // 3. Gruppo Primario
+        // Solo se non esiste già un gruppo con quel nome
+        if (!this.group.find(g => g.groupName === user.username)) {
+            this.group.push({
+                groupName: user.username,
+                password: 'x',
+                gid: user.gid,
+                members: []
+            });
+        }
+        // 4. GShadow (placeholder)
+        this.gshadowLines.push(`${user.username}:!::`);
+        // 5. SubUID/SubGID (Podman rootless)
+        // Calcolo offset standard: 100000 + (UID-1000)*65536
+        const uidNum = parseInt(user.uid);
+        if (!isNaN(uidNum) && uidNum >= 1000) {
+            const startUid = 100000 + (uidNum - 1000) * 65536;
+            const subEntry = `${user.username}:${startUid}:65536`;
+            this.subuidLines.push(subEntry);
+            this.subgidLines.push(subEntry);
+        }
+    }
+    /**
+     * Rimuove completamente un utente
+     */
+    removeUser(username) {
+        this.passwd = this.passwd.filter(u => u.username !== username);
+        this.shadow = this.shadow.filter(s => s.username !== username);
+        this.group = this.group.filter(g => g.groupName !== username);
+        // Rimuovi dai membri di altri gruppi
+        this.group.forEach(g => {
+            g.members = g.members.filter(m => m !== username);
+        });
+        this.gshadowLines = this.gshadowLines.filter(l => !l.startsWith(`${username}:`));
+        this.subuidLines = this.subuidLines.filter(l => !l.startsWith(`${username}:`));
+        this.subgidLines = this.subgidLines.filter(l => !l.startsWith(`${username}:`));
+    }
+    /**
+     * Aggiunge utente a un gruppo supplementare
+     */
+    addUserToGroup(username, groupName) {
+        const grp = this.group.find(g => g.groupName === groupName);
+        if (grp) {
+            if (!grp.members.includes(username)) {
+                grp.members.push(username);
+            }
+        }
+        // Se il gruppo non esiste, lo ignoriamo silenziosamente o potremmo crearlo
+    }
+    /**
+     * Cambia password utente
+     */
+    setPassword(username, password) {
+        const entry = this.shadow.find(s => s.username === username);
+        if (entry) {
+            const salt = bcrypt.genSaltSync(10);
+            entry.hash = bcrypt.hashSync(password, salt);
+            entry.lastChange = '19700';
+        }
+    }
+    // =========================================================================
+    // IMPLEMENTAZIONE FILE (Privata)
+    // =========================================================================
+    readFile(relativePath) {
+        const fullPath = path.join(this.targetRoot, relativePath);
+        if (fs.existsSync(fullPath)) {
+            return fs.readFileSync(fullPath, 'utf8').split('\n').filter(l => l.trim().length > 0);
+        }
+        return [];
+    }
+    async writeFile(relativePath, content, contextType) {
+        const fullPath = path.join(this.targetRoot, relativePath);
+        // Crea dir se manca (es. /etc/sudoers.d/ o simili)
+        const dir = path.dirname(fullPath);
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        try {
+            // 1. Scrittura
+            fs.writeFileSync(fullPath, content + '\n');
+            // 2. Fix SELinux (Solo RHEL Family)
+            if (['fedora', 'rhel', 'centos', 'almalinux', 'rocky'].includes(this.distroFamily)) {
+                // await exec, echo false per non sporcare i log
+                await exec(`chcon -t ${contextType} ${fullPath}`, { echo: false }).catch(() => { });
+            }
+        }
+        catch (e) {
+            console.error(`SysUsers Error writing ${relativePath}:`, e);
+        }
+    }
+    // --- PARSERS & SERIALIZERS ---
+    parsePasswd(lines) {
+        return lines.map(line => {
+            const p = line.split(':');
+            if (p.length < 7)
+                return null;
+            return { username: p[0], password: p[1], uid: p[2], gid: p[3], gecos: p[4], home: p[5], shell: p[6] };
+        }).filter((u) => u !== null);
+    }
+    serializePasswd(entries) {
+        return entries.map(u => `${u.username}:${u.password}:${u.uid}:${u.gid}:${u.gecos}:${u.home}:${u.shell}`).join('\n');
+    }
+    parseShadow(lines) {
+        return lines.map(line => {
+            const p = line.split(':');
+            if (p.length < 2)
+                return null;
+            return { username: p[0], hash: p[1], lastChange: p[2] || '', min: p[3] || '', max: p[4] || '', warn: p[5] || '', inactive: p[6] || '', expire: p[7] || '' };
+        }).filter((u) => u !== null);
+    }
+    serializeShadow(entries) {
+        return entries.map(s => `${s.username}:${s.hash}:${s.lastChange}:${s.min}:${s.max}:${s.warn}:${s.inactive}:${s.expire}:`).join('\n');
+    }
+    parseGroup(lines) {
+        return lines.map(line => {
+            const p = line.split(':');
+            if (p.length < 3)
+                return null;
+            return { groupName: p[0], password: p[1], gid: p[2], members: p[3] && p[3].trim() ? p[3].split(',') : [] };
+        }).filter((g) => g !== null);
+    }
+    serializeGroup(entries) {
+        return entries.map(g => `${g.groupName}:${g.password}:${g.gid}:${g.members.join(',')}`).join('\n');
+    }
+}

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

@@ -8,7 +8,7 @@ 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';
+import { execSync } from '../../lib/utils.js';
 /**
  * Kernel utilities for managing vmlinuz and initramfs paths
  */
@@ -55,7 +55,7 @@ export default class Kernel {
                 Utils.warning("Non è possibile determinare il kernel in un container.");
                 process.exit(1);
             }
-            targetKernel = execSync('uname -r').toString().trim();
+            targetKernel = (execSync('uname -r', { stdio: 'ignore' }) || '').trim();
         }
         const kernelVersionShort = targetKernel.split('.').slice(0, 2).join('.');
         const bootDir = '/boot';
@@ -138,7 +138,7 @@ export default class Kernel {
      * debian, fedora, opensuse, rasberry
      */
     static vmlinuzFromUname() {
-        let kernelVersion = execSync('uname -r').toString().trim();
+        let kernelVersion = (execSync('uname -r', { stdio: 'ignore' }) || '').trim();
         // Try 1: path standard (es. Debian, Ubuntu, Fedora)
         let standardPath = `/boot/vmlinuz-${kernelVersion}`;
         if (fs.existsSync(standardPath)) {

package/dist/classes/utils.d.ts

@@ -62,7 +62,7 @@ export default class Utils {
      */
     static isOpenRc(): boolean;
     /**
-     * Occore vedere un modo per creare machine-id dove non esiste
+     * Usata da pacman e config credo non serva affatto
      */
     static machineId(): string;
     /**
@@ -140,7 +140,7 @@ export default class Utils {
      *
      * @param volid
      */
-    static getVolid(volid?: string): string;
+    static VolidTrim(volid?: string): string;
     /**
      * Return postfix
      * @param basename
@@ -153,11 +153,10 @@ export default class Utils {
      */
     static getUsedSpace(): number;
     /**
-     * Extimate the linuxfs dimension
-     * probably is better to rename it as
-     * getLiveSpaceRootNeed
-     * @returns {number} Byte
-     */
+    * Estimate the linuxfs dimension
+    * (Refactored to use native FS instead of dd/od)
+    * @returns {number} GB
+    */
     static getLiveRootSpace(type?: string): number;
     /**
      * Return true if i686 architecture
@@ -247,10 +246,6 @@ export default class Utils {
      * cidr
      */
     static cidr(): string;
-    /**
-     *
-     * broadcast
-    */
     static broadcast(): string;
     /**
      * dns
@@ -331,4 +326,14 @@ export default class Utils {
     static wardrobe(): Promise<string>;
     static getOsRelease(): IOsRelease;
     static sleep(ms?: number): Promise<void>;
+    /**
+     * chpasswdPath
+     * @returns
+     */
+    static chpasswdPath(): string;
+    /**
+     *
+     * @param cmd
+     */
+    static commandExists(cmd: string): boolean;
 }