penguins-eggs 25.11.29 → 25.12.15

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;
     /**
@@ -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
@@ -327,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;
 }

package/dist/classes/utils.js

@@ -7,13 +7,12 @@
  *
  * Refactored Utils class - imports from modular utilities
  */
-import shx from 'shelljs';
+import { shx, spawnSync } from '../lib/utils.js';
 import fs from 'fs';
 import dns from 'dns';
 import path from 'path';
 import os from 'os';
 import inquirer from 'inquirer';
-import { execSync, spawnSync } from 'child_process';
 import chalk from 'chalk';
 import Kernel from './utils.d/kernel.js';
 // libraries
@@ -155,18 +154,12 @@ export default class Utils {
     static isOpenRc() {
         let isOpenRc = false;
         if (!this.isContainer()) {
-            try {
-                execSync('command -v openrc');
-                isOpenRc = true;
-            }
-            catch (error) {
-                isOpenRc = false;
-            }
+            isOpenRc = Utils.commandExists('openrc');
         }
         return isOpenRc;
     }
     /**
-     * Occore vedere un modo per creare machine-id dove non esiste
+     * Usata da pacman e config credo non serva affatto
      */
     static machineId() {
         let result = '';
@@ -245,7 +238,7 @@ export default class Utils {
      * @param device
      */
     static uuid(device) {
-        const uuid = shx.exec(`blkid -s UUID -o value ${device}`).stdout.trim();
+        const uuid = shx.exec(`blkid -p -s UUID -o value ${device}`, { silent: true }).stdout.trim();
         return uuid;
     }
     /**
@@ -436,49 +429,71 @@ export default class Utils {
         return fileSizeInBytes;
     }
     /**
-     * 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 = 'debian-live') {
         let squashFs = '/run/live/medium/live/filesystem.squashfs';
         if (type === 'mx') {
             squashFs = '/live/boot-dev/antiX/linuxfs';
         }
-        // Ottengo la dimensione del file compresso
-        const compressedFs = fs.statSync(squashFs).size;
-        // get compression factor by reading the linuxfs squasfs file, if available
-        const compressedFs_compression_type = shx.exec(`dd if=${compressedFs} bs=1 skip=20 count=2 status=none 2>/dev/null| /usr/bin/od -An -tdI`);
-        let compression_factor = 0;
-        if (compressedFs_compression_type === '1') {
-            compression_factor = 37; // gzip
-        }
-        else if (compressedFs_compression_type === '2') {
-            compression_factor = 52; // lzo, not used by antiX
-        }
-        else if (compressedFs_compression_type === '3') {
-            compression_factor = 52; // lzma, not used by antiX
-        }
-        else if (compressedFs_compression_type === '4') {
-            compression_factor = 31; // xz
-        }
-        else if (compressedFs_compression_type === '5') {
-            compression_factor = 52; // lz4
-        }
-        else {
-            compression_factor = 30; // anything else or linuxfs not reachable (toram), should be pretty conservative
+        // 1. Leggiamo il tipo di compressione DIRETTAMENTE dall'header del file SquashFS
+        // L'identificativo della compressione è a offset 20 (2 bytes, little endian)
+        // 1=gzip, 2=lzo, 3=lzma, 4=xz, 5=lz4, 6=zstd
+        let compressionId = 0;
+        try {
+            if (fs.existsSync(squashFs)) {
+                const fd = fs.openSync(squashFs, 'r');
+                const buffer = Buffer.alloc(2);
+                // Leggi 2 byte alla posizione 20
+                fs.readSync(fd, buffer, 0, 2, 20);
+                fs.closeSync(fd);
+                compressionId = buffer.readUInt16LE(0);
+            }
         }
+        catch (e) {
+            console.error("Error reading squashfs header:", e);
+        }
+        // 2. Determiniamo il fattore di compressione in base all'ID letto
+        let compression_factor = 30; // Default conservative
+        switch (compressionId) {
+            case 1: // gzip
+                compression_factor = 37;
+                break;
+            case 2: // lzo
+                compression_factor = 52;
+                break;
+            case 3: // lzma
+                compression_factor = 52;
+                break;
+            case 4: // xz
+                compression_factor = 31;
+                break;
+            case 5: // lz4
+                compression_factor = 52;
+                break;
+            case 6: // zstd (aggiunto per completezza)
+                compression_factor = 37; // simile a gzip come ratio medio
+                break;
+            default:
+                compression_factor = 30;
+        }
+        // 3. Calcolo dimensione Linux FS
+        // Nota: shx.exec ritorna un oggetto, dobbiamo prendere .stdout e pulirlo
         let rootfs_file_size = 0;
-        const linuxfs_file_size = (Number(shx.exec('df /live/linux --output=used --total | /usr/bin/tail -n1').stdout.trim()) * 1024 * 100) / compression_factor;
+        const dfCmdLinux = 'df /live/linux --output=used --total | /usr/bin/tail -n1';
+        const dfResultLinux = shx.exec(dfCmdLinux, { silent: true }).stdout.trim();
+        const linuxfs_used = Number(dfResultLinux) || 0; // Gestione caso NaN
+        const linuxfs_file_size = (linuxfs_used * 1024 * 100) / compression_factor;
+        // 4. Calcolo persist-root (se esiste)
         if (fs.existsSync('/live/persist-root')) {
-            rootfs_file_size = Number(shx.exec('df /live/persist-root --output=used --total | /usr/bin/tail -n1').stdout.trim()) * 1024;
+            const dfCmdRoot = 'df /live/persist-root --output=used --total | /usr/bin/tail -n1';
+            const dfResultRoot = shx.exec(dfCmdRoot, { silent: true }).stdout.trim();
+            rootfs_file_size = (Number(dfResultRoot) || 0) * 1024;
         }
         let rootSpaceNeeded;
         if (type === 'mx') {
-            /**
-             * add rootfs file size to the calculated linuxfs file size. Probaby conservative, as rootfs will likely have some overlap with linuxfs
-             */
             rootSpaceNeeded = linuxfs_file_size + rootfs_file_size;
         }
         else {
@@ -845,7 +860,7 @@ export default class Utils {
             msg = 'Press a key to continue...';
         }
         console.log(msg);
-        const pressKeyToExit = spawnSync('read _ ', { shell: true, stdio: [0, 1, 2] });
+        const pressKeyToExit = spawnSync('read _ ', [], { shell: true, stdio: [0, 1, 2] });
         if (!procContinue) {
             process.exit(0);
         }
@@ -857,7 +872,7 @@ export default class Utils {
             msg = 'Press a key to continue...';
         }
         console.log(msg);
-        const pressKeyToExit = spawnSync('read _ ', { shell: true, stdio: [0, 1, 2] });
+        const pressKeyToExit = spawnSync('read _ ', [], { shell: true, stdio: [0, 1, 2] });
         if (!procContinue) {
             process.exit(0);
         }
@@ -881,12 +896,12 @@ export default class Utils {
     static flag() {
         let type = '';
         if (!Utils.isAppImage()) {
-            type = 'native';
+            type = ' native';
         }
         let title = `${pjson.name}`;
         let green = ` ${title}`.padEnd(25, " ");
         let white = ` Perri's brewery edition `.padEnd(25, " ");
-        let red = ` v${pjson.version} ${type} `.padStart(25, " ");
+        let red = ` v${pjson.version}${type} `.padStart(25, " ");
         return chalk.bgGreen.whiteBright(green) +
             chalk.bgWhite.blue(white) +
             chalk.bgRed.whiteBright(red);
@@ -984,4 +999,22 @@ export default class Utils {
         // console.log('wait...')
         return new Promise(resolve => setTimeout(resolve, ms));
     }
+    /**
+     * chpasswdPath
+     * @returns
+     */
+    static chpasswdPath() {
+        let chpasswdPath = '/usr/sbin/chpasswd';
+        if (fs.existsSync(chpasswdPath)) {
+            chpasswdPath = '/usr/bin/chpasswd';
+        }
+        return chpasswdPath;
+    }
+    /**
+     *
+     * @param cmd
+     */
+    static commandExists(cmd) {
+        return !!shx.which(cmd);
+    }
 }

package/dist/classes/xdg.js

@@ -7,7 +7,7 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
-import shx from 'shelljs';
+import { shx } from '../lib/utils.js';
 // libraries
 import { exec } from '../lib/utils.js';
 import Distro from './distro.js';

package/dist/classes/yolk.js

@@ -7,10 +7,8 @@
  */
 import yaml from 'js-yaml';
 import fs from 'node:fs';
-import shx from 'shelljs';
-import { exec } from '../lib/utils.js';
+import { shx, exec } from '../lib/utils.js';
 import Bleach from './bleach.js';
-import Pacman from './pacman.js';
 import Utils from './utils.js';
 /**
  *
@@ -31,7 +29,7 @@ export default class Yolk {
         }
         Utils.warning(`Creating yolk on ${this.yolkDir}`);
         Utils.warning('Updating system');
-        if (!Pacman.commandIsInstalled('dpkg-scanpackages')) {
+        if (!Utils.commandExists('dpkg-scanpackages')) {
             Utils.warning(`I cannot find the command dpkg-scanpackages`);
             process.exit(0);
         }
@@ -68,7 +66,7 @@ export default class Yolk {
         Utils.warning(cmd);
         await exec(cmd, { capture: true, echo: false });
         // Create Release date: Sat, 14 Aug 2021 07:42:00 UTC
-        const now = shx.exec('date -R -u').stdout.trim();
+        const now = shx.exec('date -R -u', { silent: true }).stdout.trim();
         const content = `Archive: stable\nComponent: yolk\nOrigin: penguins-eggs\nArchitecture: ${Utils.uefiArch()} \nDate: ${now}\n`;
         Utils.warning('Writing Release');
         fs.writeFileSync('Release', content);

package/dist/commands/export/appimage.js

@@ -10,7 +10,7 @@ import Tools from '../../classes/tools.js';
 import Utils from '../../classes/utils.js';
 import { exec } from '../../lib/utils.js';
 import os from 'node:os';
-import { execSync } from 'node:child_process';
+import { execSync } from '../../lib/utils.js';
 export default class ExportAppimage extends Command {
     static description = 'export penguins-eggs AppImage to the destination host';
     static examples = ['eggs export pkg', 'eggs export pkg --clean', 'eggs export pkg --all'];
@@ -34,9 +34,9 @@ export default class ExportAppimage extends Command {
         // Ora servono in più parti
         this.user = os.userInfo().username;
         if (this.user === 'root') {
-            this.user = execSync('echo $SUDO_USER', { encoding: 'utf-8' }).trim();
+            this.user = (execSync('echo $DOAS_USER') || '').trim();
             if (this.user === '') {
-                this.user = execSync('echo $DOAS_USER', { encoding: 'utf-8' }).trim();
+                this.user = (execSync('echo $DOAS_USER') || '').trim();
             }
         }
         this.clean = flags.clean;

package/dist/commands/export/pkg.js

@@ -12,7 +12,7 @@ import Tools from '../../classes/tools.js';
 import Utils from '../../classes/utils.js';
 import { exec } from '../../lib/utils.js';
 import os from 'node:os';
-import { execSync } from 'node:child_process';
+import { execSync } from '../../lib/utils.js';
 export default class ExportPkg extends Command {
     static description = 'export penguins-eggs package to the destination host';
     static examples = ['eggs export pkg', 'eggs export pkg --clean', 'eggs export pkg --all'];
@@ -38,9 +38,9 @@ export default class ExportPkg extends Command {
         // Ora servono in più parti
         this.user = os.userInfo().username;
         if (this.user === 'root') {
-            this.user = execSync('echo $SUDO_USER', { encoding: 'utf-8' }).trim();
+            this.user = (execSync('echo $DOAS_USER') || '').trim();
             if (this.user === '') {
-                this.user = execSync('echo $DOAS_USER', { encoding: 'utf-8' }).trim();
+                this.user = (execSync('echo $DOAS_USER') || '').trim();
             }
         }
         this.all = flags.all;

package/dist/commands/export/tarballs.js

@@ -16,7 +16,7 @@ import path from 'path';
 import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 const pjson = require('../../../package.json');
-import { execSync } from 'node:child_process';
+import { execSync } from '../../lib/utils.js';
 export default class ExportTarballs extends Command {
     static description = 'export pkg/iso/tarballs to the destination host';
     static examples = ['eggs export tarballs', 'eggs export tarballs --clean'];
@@ -40,9 +40,9 @@ export default class ExportTarballs extends Command {
         // Ora servono in più parti
         this.user = os.userInfo().username;
         if (this.user === 'root') {
-            this.user = execSync('echo $SUDO_USER', { encoding: 'utf-8' }).trim();
+            this.user = (execSync('echo $DOAS_USER') || '').trim();
             if (this.user === '') {
-                this.user = execSync('echo $DOAS_USER', { encoding: 'utf-8' }).trim();
+                this.user = (execSync('echo $DOAS_USER') || '').trim();
             }
         }
         this.clean = flags.clean;

package/dist/commands/krill.js

@@ -9,7 +9,7 @@ import { Command, Flags } from '@oclif/core';
 import yaml from 'js-yaml';
 import fs from 'node:fs';
 import https from 'node:https';
-import shx from 'shelljs';
+import { shx } from '../lib/utils.js';
 import Utils from '../classes/utils.js';
 import Krill from '../krill/classes/prepare.js';
 const agent = new https.Agent({