penguins-eggs 10.1.0 → 10.1.1

package/dist/classes/users.js

@@ -0,0 +1,143 @@
+/**
+ * ./src/classes/users.ts
+ * penguins-eggs v.10.0.0 / 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/architecture.d.ts

@@ -0,0 +1,41 @@
+/**
+ * ./src/classes/utils.d/architecture.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * Architecture detection utilities - UEFI, arch-specific paths
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+export default class Architecture {
+    /**
+     * Return true if i686 architecture
+     * @remarks to move in Utils
+     * @returns {boolean} true se l'architettura è i686
+     */
+    static isi686(): boolean;
+    /**
+     * uefiArch
+     * @returns arch
+     */
+    static uefiArch(): string;
+    /**
+     * i386-pc,
+     * i386-efi,
+     * x86_64-efi,
+     * arm64-efi,
+     *
+     * ATTEMZIONE: install efibootmgr
+     *
+     * Fedora/RHEL have i386-pc
+     */
+    static uefiFormat(): string;
+    /**
+     *
+     * @returns
+     */
+    static usrLibPath(): string;
+    /**
+     * get the kernel version
+     */
+    static kernelVersion(): string;
+}

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

@@ -0,0 +1,87 @@
+/**
+ * ./src/classes/utils.d/architecture.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * Architecture detection utilities - UEFI, arch-specific paths
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import shx from 'shelljs';
+import os from 'os';
+export default class Architecture {
+    /**
+     * Return true if i686 architecture
+     * @remarks to move in Utils
+     * @returns {boolean} true se l'architettura è i686
+     */
+    static isi686() {
+        return process.arch === 'ia32';
+    }
+    /**
+     * uefiArch
+     * @returns arch
+     */
+    static uefiArch() {
+        let arch = '';
+        if (process.arch === 'ia32') {
+            arch = 'i386';
+            // 
+            if (shx.exec('uname -m', { silent: true }).stdout.trim() === 'x86_64') {
+                arch = 'amd64';
+            }
+        }
+        else if (process.arch === 'x64') {
+            arch = 'amd64';
+        }
+        else if (process.arch === 'arm64') {
+            arch = 'arm64';
+        }
+        return arch;
+    }
+    /**
+     * i386-pc,
+     * i386-efi,
+     * x86_64-efi,
+     * arm64-efi,
+     *
+     * ATTEMZIONE: install efibootmgr
+     *
+     * Fedora/RHEL have i386-pc
+     */
+    static uefiFormat() {
+        let format = '';
+        if (process.arch === 'ia32') {
+            format = 'i386-efi';
+            if (shx.exec('uname -m', { silent: true }).stdout.trim() === 'x86_64') {
+                format = 'x86_64-efi';
+            }
+        }
+        else if (process.arch === 'x64') {
+            format = 'x86_64-efi';
+        }
+        else if (process.arch === 'arm64') {
+            format = 'arm64-efi';
+        }
+        return format;
+    }
+    /**
+     *
+     * @returns
+     */
+    static usrLibPath() {
+        let path = '';
+        if (process.arch === 'x64') {
+            path = 'x86_64-linux-gnu';
+        }
+        else if (process.arch === 'arm64') {
+            path = 'aarch64-linux-gnu';
+        }
+        return path;
+    }
+    /**
+     * get the kernel version
+     */
+    static kernelVersion() {
+        return os.release();
+    }
+}

package/dist/classes/utils.d/console-output.d.ts

@@ -0,0 +1,26 @@
+/**
+ * ./src/classes/utils.d/console-output.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * Console output utilities - colored output, titles, warnings, errors
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+export default class ConsoleOutput {
+    /**
+     *
+     * @param msg
+     */
+    static warning(msg?: string): void;
+    static error(msg?: string): void;
+    /**
+     * titles
+     * Penguin's are gettings alive!
+     */
+    static titles(command?: string): void;
+    /**
+     *
+     * @returns flag
+     */
+    static flag(): string;
+}

package/dist/classes/utils.d/console-output.js

@@ -0,0 +1,46 @@
+/**
+ * ./src/classes/utils.d/console-output.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * Console output utilities - colored output, titles, warnings, errors
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import chalk from 'chalk';
+// pjson
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const pjson = require('../../../package.json');
+export default class ConsoleOutput {
+    /**
+     *
+     * @param msg
+     */
+    static warning(msg = '') {
+        console.log(pjson.shortName + ' >>> ' + chalk.cyanBright(msg) + '.');
+    }
+    static error(msg = '') {
+        console.error(pjson.shortName + ' >>> ' + chalk.bgMagentaBright(chalk.whiteBright(msg)) + '.');
+    }
+    /**
+     * titles
+     * Penguin's are gettings alive!
+     */
+    static titles(command = '') {
+        console.clear();
+        console.log('');
+        console.log(' E G G S: the reproductive system of penguins');
+        console.log('');
+        console.log(ConsoleOutput.flag());
+        console.log('command: ' + chalk.bgBlack.white(command) + '\n');
+    }
+    /**
+     *
+     * @returns flag
+     */
+    static flag() {
+        return chalk.bgGreen.whiteBright('      ' + pjson.name + '      ') +
+            chalk.bgWhite.blue(" Perri's Brewery edition ") +
+            chalk.bgRed.whiteBright('       ver. ' + pjson.version + '       ');
+    }
+}

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

@@ -0,0 +1,53 @@
+/**
+ * ./src/classes/utils.d/filesystem.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * Filesystem operations utilities - files, UUID, disk space
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import IOsRelease from '../../interfaces/i-os-release.js';
+export default class Filesystem {
+    /**
+     *
+     * @param file
+     * @param search
+     * @returns value
+     */
+    static searchOnFile(file?: string, search?: string): string;
+    /**
+     * restituisce uuid
+     * @param device
+     */
+    static uuid(device: string): string;
+    /**
+     *
+     * @param device
+     * @returns
+     */
+    static uuidGen(): string;
+    /**
+     * Calculate the space used on the disk
+     * @return {void}
+     */
+    static getUsedSpace(): number;
+    /**
+     * write a file
+     * @param file
+     * @param text
+     */
+    static write(file: string, text: string): void;
+    /**
+     *
+     * @param file
+     * @param cmd
+     */
+    static writeX(file: string, cmd: string): void;
+    /**
+     *
+     * @param file
+     * @param cmd
+     */
+    static writeXs(file: string, cmds: string[]): void;
+    static getOsRelease(): IOsRelease;
+}

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

@@ -0,0 +1,152 @@
+/**
+ * ./src/classes/utils.d/filesystem.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * Filesystem operations utilities - files, UUID, disk space
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import fs from 'fs';
+import path from 'path';
+import shx from 'shelljs';
+import System from './system.js';
+import Formatters from './formatters.js';
+import PackageInfo from './package-info.js';
+export default class Filesystem {
+    /**
+     *
+     * @param file
+     * @param search
+     * @returns value
+     */
+    static searchOnFile(file = '', search = '') {
+        const lines = fs.readFileSync(file, 'utf8').split("\n");
+        let value = '';
+        lines.forEach(line => {
+            line = line.replace(/\s+/g, ' '); // Remove multiple spaces with single space
+            if (line.includes(search)) {
+                value = line.substring(line.indexOf('=') + 1);
+            }
+        });
+        value = value.replaceAll('"', ''); // Remove "
+        return value.trim();
+    }
+    /**
+     * restituisce uuid
+     * @param device
+     */
+    static uuid(device) {
+        const uuid = shx.exec(`blkid -s UUID -o value ${device}`).stdout.trim();
+        return uuid;
+    }
+    /**
+     *
+     * @param device
+     * @returns
+     */
+    static uuidGen() {
+        const uuid = shx.exec(`uuidgen`, { silent: true }).stdout.trim();
+        return uuid;
+    }
+    /**
+     * Calculate the space used on the disk
+     * @return {void}
+     */
+    static getUsedSpace() {
+        let fileSizeInBytes = 0;
+        if (System.isLive()) {
+            fileSizeInBytes = 0; // this.getLiveRootSpace()
+        }
+        else {
+            fileSizeInBytes = Number(shx.exec(`df /home | /usr/bin/awk 'NR==2 {print $3}'`, {
+                silent: true
+            }).stdout);
+        }
+        return fileSizeInBytes;
+    }
+    /**
+     * write a file
+     * @param file
+     * @param text
+     */
+    static write(file, text) {
+        text = text.trim() + '\n';
+        file = file.trim();
+        fs.writeFileSync(file, text);
+    }
+    /**
+     *
+     * @param file
+     * @param cmd
+     */
+    static writeX(file, cmd) {
+        let text = `#!/bin/sh\n\n`;
+        text += `# Created at: ${Formatters.formatDate(new Date())}\n`;
+        text += `# By: penguins_eggs v. ${PackageInfo.getPackageVersion()}\n`;
+        text += `# ==> Perri\'s Brewery edition <== \n\n`;
+        text += cmd;
+        Filesystem.write(file, text);
+        shx.chmod('+x', file);
+    }
+    /**
+     *
+     * @param file
+     * @param cmd
+     */
+    static writeXs(file, cmds) {
+        let cmd = '';
+        for (const elem of cmds) {
+            cmd += elem + '\n';
+        }
+        Filesystem.writeX(file, cmd);
+    }
+    // Se il metodo fa parte di una classe, usa `static`. Altrimenti, rimuovilo.
+    static getOsRelease() {
+        const osReleasePath = path.join('/etc', 'os-release');
+        // Inizializza l'oggetto con valori predefiniti
+        const osInfo = {
+            ID: '',
+            VERSION_ID: '',
+            VERSION_CODENAME: 'n/a'
+        };
+        // Verifica se il file esiste
+        if (!fs.existsSync(osReleasePath)) {
+            console.error('/etc/os-release file does not exist.');
+            return osInfo;
+        }
+        // Leggi il contenuto del file
+        let fileContent;
+        try {
+            fileContent = fs.readFileSync(osReleasePath, 'utf8');
+        }
+        catch (error) {
+            console.error('Error reading /etc/os-release:', error);
+            return osInfo;
+        }
+        // Analizza ogni linea
+        const lines = fileContent.split('\n');
+        lines.forEach(line => {
+            if (line.startsWith('#') || line.trim() === '')
+                return;
+            const [key, value] = line.split('=');
+            if (key && value) {
+                const trimmedKey = key.trim();
+                const trimmedValue = value.trim().replace(/"/g, '');
+                // Popola solo le chiavi desiderate
+                if (trimmedKey === 'ID') {
+                    osInfo.ID = trimmedValue;
+                }
+                else if (trimmedKey === 'VERSION_ID') {
+                    osInfo.VERSION_ID = trimmedValue;
+                }
+                else if (trimmedKey === 'VERSION_CODENAME') {
+                    osInfo.VERSION_CODENAME = trimmedValue;
+                }
+            }
+        });
+        // capitalize distroId
+        osInfo.ID = osInfo.ID[0].toUpperCase() + osInfo.ID.slice(1).toLowerCase();
+        osInfo.VERSION_CODENAME = osInfo.VERSION_CODENAME.toLowerCase();
+        return osInfo;
+    }
+}

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

@@ -0,0 +1,32 @@
+/**
+ * ./src/classes/utils.d/formatters.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * Formatting utilities - dates, bytes, objects
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+export default class Formatters {
+    /**
+     * Custom function to sort object keys
+     * @param obj
+     * @returns
+     */
+    static sortObjectKeys(obj: {
+        [key: string]: any;
+    }): {
+        [key: string]: any;
+    };
+    /**
+     *
+     * @param date
+     */
+    static formatDate(date: Date): string;
+    /**
+     *
+     * @param bytes
+     * @param decimals
+     * @returns
+     */
+    static formatBytes(bytes: number, decimals?: number): string;
+}

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

@@ -0,0 +1,64 @@
+/**
+ * ./src/classes/utils.d/formatters.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * Formatting utilities - dates, bytes, objects
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+export default class Formatters {
+    /**
+     * Custom function to sort object keys
+     * @param obj
+     * @returns
+     */
+    static sortObjectKeys(obj) {
+        const sorted = {};
+        Object.keys(obj)
+            .sort()
+            .forEach(key => {
+            sorted[key] = obj[key];
+        });
+        return sorted;
+    }
+    /**
+     *
+     * @param date
+     */
+    static formatDate(date) {
+        const d = new Date(date);
+        let month = String(d.getMonth() + 1);
+        let day = String(d.getDate());
+        const year = d.getFullYear();
+        let hh = String(d.getHours());
+        let mm = String(d.getMinutes());
+        if (month.length < 2) {
+            month = '0' + month;
+        }
+        if (day.length < 2) {
+            day = '0' + day;
+        }
+        if (hh.length < 2) {
+            hh = '0' + hh;
+        }
+        if (mm.length < 2) {
+            mm = '0' + mm;
+        }
+        return [year, month, day].join('-') + '_' + hh + mm;
+    }
+    /**
+     *
+     * @param bytes
+     * @param decimals
+     * @returns
+     */
+    static formatBytes(bytes, decimals = 2) {
+        if (bytes === 0)
+            return '0 Bytes';
+        const k = 1024;
+        const dm = decimals < 0 ? 0 : decimals;
+        const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + sizes[i];
+    }
+}