penguins-eggs 10.1.0 → 25.7.7

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

@@ -0,0 +1,137 @@
+/**
+ * ./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
+ */
+import path from 'path';
+import os from 'os';
+import System from './system.js';
+// pjson
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const pjson = require('../../../package.json');
+// __dirname
+const __dirname = path.dirname(new URL(import.meta.url).pathname);
+export default class PackageInfo {
+    /**
+     * return the name of the package: penguins-eggs
+     * @returns penguins-eggs
+     */
+    static getPackageName() {
+        return pjson.shortName;
+    }
+    /**
+     * return the short name of the package: eggs
+     * @returns eggs
+     */
+    static getFriendName() {
+        return pjson.shortName;
+    }
+    /**
+     * return the version of the package
+     * @returns version example 8.0.0
+     */
+    static getPackageVersion() {
+        return pjson.version;
+    }
+    /**
+     * Get author name
+     */
+    static getAuthorName() {
+        return 'Piero Proietti piero.proietti@gmail.com';
+    }
+    /**
+     * Controlla se è un pacchetto deb
+     * /usr/lib/penguins-eggs/bin/node
+     */
+    static isPackage() {
+        let ret = false;
+        //if (process.execPath !== '/usr/bin/node') {
+        if (process.execPath === '/usr/lib/penguins-eggs/bin/node') {
+            ret = true;
+        }
+        return ret;
+    }
+    /**
+     * Controlla se è un pacchetto sorgente
+     */
+    static isSources() {
+        let ret = false;
+        if (__dirname.substring(0, 6) === '/home/') {
+            ret = true;
+        }
+        return ret;
+    }
+    /**
+     * Controlla se è un pacchetto npm
+     */
+    static isNpmPackage() {
+        return !(this.isPackage() || this.isSources());
+    }
+    /**
+     *
+     */
+    static rootPenguin() {
+        return path.resolve(__dirname, '../../../');
+    }
+    /**
+     *
+     * @returns wardrobe
+     */
+    static async wardrobe() {
+        let wardrobe = `${os.homedir()}/.wardrobe`;
+        if (System.isRoot()) {
+            wardrobe = `/home/${await PackageInfo.getPrimaryUser()}/.wardrobe`;
+        }
+        return wardrobe;
+    }
+    /**
+     * Return the primary user's name
+     */
+    static async getPrimaryUser() {
+        const { execSync } = require('child_process');
+        let primaryUser = '';
+        try {
+            // Attempt to get the user from logname
+            primaryUser = execSync('/usr/bin/logname 2>/dev/null', { encoding: 'utf-8' }).trim();
+        }
+        catch (error) {
+            // console.log("logname failed, so we continue with other methods")
+        }
+        if (primaryUser === 'root') {
+            primaryUser = '';
+        }
+        if (primaryUser === '') {
+            try {
+                // Check if doas is installed and get the DOAS_USER
+                execSync('command -v doas', { stdio: 'ignore' });
+                primaryUser = execSync('echo $DOAS_USER', { encoding: 'utf-8' }).trim();
+            }
+            catch (error) {
+                // console.log("doas is not installed or DOAS_USER is not set, continue with the next method")
+            }
+        }
+        if (primaryUser === '') {
+            try {
+                // Check for the SUDO_USER
+                primaryUser = execSync('echo $SUDO_USER', { encoding: 'utf-8' }).trim();
+            }
+            catch (error) {
+                // console.log("SUDO_USER is not set, continue with the next method")
+            }
+        }
+        if (primaryUser === '') {
+            // console.log("Fallback to the USER environment variable")
+            primaryUser = process.env.USER || '';
+        }
+        if (primaryUser === '') {
+            primaryUser = 'dummy';
+            // console.error('Cannot determine the primary user.');
+            // process.exit(1);
+        }
+        return primaryUser;
+    }
+}

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

@@ -0,0 +1,44 @@
+/**
+ * ./src/classes/utils.d/snapshot.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * Snapshot management utilities - ISO, prefixes, volid
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+export default class Snapshot {
+    /**
+     * Restituisce il prefisso della iso
+     * @param distroId
+     * @param codenameId
+     */
+    static snapshotPrefix(distroId: string, codenameId: string): string;
+    /**
+     * Count the eggs present in the nest
+     * @returns {number} Numero degli snapshot presenti
+     */
+    static getSnapshotCount(snapshot_dir?: string): number;
+    /**
+     * Get the syze of the snapshot
+     * @returns {string} grandezza dello snapshot in Byte
+     */
+    static getSnapshotSize(snapshot_dir?: string): number;
+    /**
+     *
+     * @param prefix
+     * @param backup
+     * @returns
+     */
+    static getPrefix(prefix: string, backup?: boolean): string;
+    /**
+     *
+     * @param volid
+     */
+    static getVolid(volid?: string): string;
+    /**
+     * Return postfix
+     * @param basename
+     * @returns eggName
+     */
+    static getPostfix(): string;
+}

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

@@ -0,0 +1,102 @@
+/**
+ * ./src/classes/utils.d/snapshot.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * Snapshot management utilities - ISO, prefixes, volid
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import fs from 'fs';
+import shx from 'shelljs';
+import Filesystem from './filesystem.js';
+import Formatters from './formatters.js';
+export default class Snapshot {
+    /**
+     * Restituisce il prefisso della iso
+     * @param distroId
+     * @param codenameId
+     */
+    static snapshotPrefix(distroId, codenameId) {
+        let result = `egg-of_${distroId.toLowerCase()}-`;
+        if (codenameId === 'rolling' || codenameId === '') {
+            const releaseId = Filesystem.getOsRelease().VERSION_ID.trim();
+            if (releaseId !== '') {
+                result += `${releaseId}-`;
+            }
+        }
+        else {
+            result += `${codenameId.toLowerCase()}-`;
+        }
+        // result = result.replace(`/`, '-')
+        return result;
+    }
+    /**
+     * Count the eggs present in the nest
+     * @returns {number} Numero degli snapshot presenti
+     */
+    static getSnapshotCount(snapshot_dir = '/') {
+        if (fs.existsSync(snapshot_dir)) {
+            const files = fs.readdirSync(snapshot_dir);
+            let nIsos = 0;
+            for (const f of files) {
+                if (f.endsWith('.iso')) {
+                    nIsos++;
+                }
+            }
+            return nIsos;
+        }
+        return 0;
+    }
+    /**
+     * Get the syze of the snapshot
+     * @returns {string} grandezza dello snapshot in Byte
+     */
+    static getSnapshotSize(snapshot_dir = '/') {
+        let fileSizeInBytes = 0;
+        const size = shx.exec(`/usr/bin/find ${snapshot_dir} -maxdepth 1 -type f -name '*.iso' -exec du -sc {} + | tail -1 | awk '{print $1}'`, { silent: true }).stdout.trim();
+        if (size === '') {
+            fileSizeInBytes = 0;
+        }
+        else {
+            fileSizeInBytes = Number(size);
+        }
+        return fileSizeInBytes;
+    }
+    /**
+     *
+     * @param prefix
+     * @param backup
+     * @returns
+     */
+    static getPrefix(prefix, backup = false) {
+        if (backup) {
+            if (prefix.substring(0, 7) === 'egg-of_') {
+                prefix = 'egg-bk_' + prefix.substring(7);
+            }
+            else {
+                prefix = 'egg-bk_' + prefix;
+            }
+        }
+        return prefix;
+    }
+    /**
+     *
+     * @param volid
+     */
+    static getVolid(volid = 'unknown') {
+        // // 28 +  4 .iso = 32 lunghezza max di volid
+        if (volid.length >= 32) {
+            volid = volid.substring(0, 32);
+        }
+        return volid;
+    }
+    /**
+     * Return postfix
+     * @param basename
+     * @returns eggName
+     */
+    static getPostfix() {
+        let postfix = '_' + Formatters.formatDate(new Date()) + '.iso';
+        return postfix;
+    }
+}

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

@@ -0,0 +1,63 @@
+/**
+ * ./src/classes/utils.d/system.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * System detection utilities - init systems, containers, live/installed detection
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+export default class System {
+    /**
+     * Detect if running inside a container (Docker or LXC)
+     */
+    static isContainer(): boolean;
+    /**
+     * Check if the system uses Systemd
+     */
+    static isSystemd(): boolean;
+    /**
+     * Check if the system uses SysVinit
+     */
+    static isSysvinit(): boolean;
+    /**
+     * Check if the system uses OpenRC
+     */
+    static isOpenRc(): boolean;
+    /**
+     * Return true if live system
+     * @returns {boolean} isLive
+     */
+    static isLive(): boolean;
+    /**
+     * Ritorna vero se path è un mountpoint
+     * @param path
+     */
+    static isMountpoint(path?: string): boolean;
+    /**
+     *
+     * @param device
+     * @returns
+     */
+    static isBlockDevice(device?: string): boolean;
+    /**
+     * return true if eggs run as root
+     * @returns isRoot
+     */
+    static isRoot(command?: string): boolean;
+    /**
+     * Occore vedere un modo per creare machine-id dove non esiste
+     */
+    static machineId(): string;
+    /**
+     * Return the Debian version
+     * @returns {number} Versione di Debian
+     */
+    static getDebianVersion(): number;
+    /**
+     * Extimate the linuxfs dimension
+     * probably is better to rename it as
+     * getLiveSpaceRootNeed
+     * @returns {number} Byte
+     */
+    static getLiveRootSpace(type?: string): number;
+}

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

@@ -0,0 +1,200 @@
+/**
+ * ./src/classes/utils.d/system.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * System detection utilities - init systems, containers, live/installed detection
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import fs from 'fs';
+import shx from 'shelljs';
+import { execSync } from 'child_process';
+import Distro from '../distro.js';
+export default class System {
+    /**
+     * 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;
+        }
+        return isContainer;
+    }
+    /**
+     * Check if the system uses Systemd
+     */
+    static isSystemd() {
+        let isSystemd = false;
+        if (!this.isContainer()) {
+            isSystemd = fs.readFileSync("/proc/1/comm").includes('systemd');
+        }
+        else {
+            isSystemd = true;
+            let distro = new Distro();
+            if (distro.distroId === "Alpine" || distro.distroId === "Devuan") {
+                isSystemd = false;
+            }
+        }
+        return isSystemd;
+    }
+    /**
+     * Check if the system uses SysVinit
+     */
+    static isSysvinit() {
+        let isSysvinit = false;
+        if (!this.isContainer()) {
+            isSysvinit = fs.readFileSync("/proc/1/comm").includes('init');
+        }
+        else {
+            let distro = new Distro();
+            if (distro.distroId === "Alpine" || distro.distroId === "Devuan") {
+                isSysvinit = true;
+            }
+        }
+        return isSysvinit;
+    }
+    /**
+     * Check if the system uses OpenRC
+     */
+    static isOpenRc() {
+        let isOpenRc = false;
+        if (!this.isContainer()) {
+            try {
+                execSync('command -v openrc');
+                isOpenRc = true;
+            }
+            catch (error) {
+                isOpenRc = false;
+            }
+        }
+        return isOpenRc;
+    }
+    /**
+     * Return true if live system
+     * @returns {boolean} isLive
+     */
+    static isLive() {
+        let retVal = false;
+        const paths = [
+            '/lib/live/mount', // debian-live
+            '/run/live/rootfs/filesystem.squashfs', // debian trixie
+            '/lib/live/mount/rootfs/filesystem.squashfs', // ubuntu bionic
+            '/live/aufs', // mx-linux
+            '/media/root-rw', // AlpineLinux
+            '/run/archiso/airootfs', // Arch
+            '/run/miso/sfs/livefs', // Manjarolinux
+            '/run/rootfsbase' // Fedora
+        ];
+        for (let i = 0; i < paths.length; i++) {
+            if (System.isMountpoint(paths[i])) {
+                retVal = true;
+            }
+        }
+        return retVal;
+    }
+    /**
+     * Ritorna vero se path è un mountpoint
+     * @param path
+     */
+    static isMountpoint(path = '') {
+        const cmd = `mountpoint -q ${path}`;
+        // return 0 if the directory is a mountpoint, non-zero if not.
+        const result = shx.exec(cmd, { silent: true }).code;
+        return result === 0;
+    }
+    /**
+     *
+     * @param device
+     * @returns
+     */
+    static isBlockDevice(device = '') {
+        const cmd = `lsblk -d -o name | grep ${device}`;
+        const result = shx.exec(cmd, { silent: true }).code;
+        return result === 0;
+    }
+    /**
+     * return true if eggs run as root
+     * @returns isRoot
+     */
+    static isRoot(command = '') {
+        if (process.getuid && process.getuid() === 0) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Occore vedere un modo per creare machine-id dove non esiste
+     */
+    static machineId() {
+        let result = '';
+        if (fs.existsSync('/etc/machine-id')) {
+            result = fs.readFileSync('/etc/machine-id', 'utf-8').trim();
+        }
+        else if (fs.existsSync('/var/lib/dbus/machine-id')) {
+            result = fs.readFileSync('/var/lib/dbus/machine-id', 'utf-8').trim();
+        }
+        return result;
+    }
+    /**
+     * Return the Debian version
+     * @returns {number} Versione di Debian
+     */
+    static getDebianVersion() {
+        const cmd = "cat /etc/debian_version | /usr/bin/cut -f1 -d'.'";
+        const version = Number(shx.exec(cmd, { silent: true }).stdout);
+        return version;
+    }
+    /**
+     * Extimate the linuxfs dimension
+     * probably is better to rename it as
+     * getLiveSpaceRootNeed
+     * @returns {number} Byte
+     */
+    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
+        }
+        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;
+        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;
+        }
+        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 {
+            rootSpaceNeeded = linuxfs_file_size;
+        }
+        return rootSpaceNeeded / 1073741824.0; // Converte in GB
+    }
+}

package/dist/classes/utils.d/user-interaction.d.ts

@@ -0,0 +1,39 @@
+/**
+ * ./src/classes/utils.d/user-interaction.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * User interaction utilities - prompts, confirmations, user input
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+export default class UserInteraction {
+    /**
+     *
+     * @param msg
+     */
+    static customConfirm(msg?: string): Promise<boolean>;
+    /**
+     *
+     * @param msg
+     */
+    static customConfirmCompanion(msg?: string): Promise<any>;
+    /**
+     *
+     * @param msg
+     */
+    static customConfirmAbort(msg?: string): Promise<any>;
+    /**
+     *
+     */
+    static pressKeyToExit(warming?: string, procContinue?: boolean): Promise<void>;
+    /**
+     *
+     * @param command
+     */
+    static useRoot(command?: string): void;
+    /**
+     *
+     * @param verbose
+     */
+    static setEcho(verbose?: boolean): object;
+}

package/dist/classes/utils.d/user-interaction.js

@@ -0,0 +1,104 @@
+/**
+ * ./src/classes/utils.d/user-interaction.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * User interaction utilities - prompts, confirmations, user input
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import inquirer from 'inquirer';
+import { spawnSync } from 'child_process';
+import ConsoleOutput from './console-output.js';
+// pjson
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const pjson = require('../../../package.json');
+export default class UserInteraction {
+    /**
+     *
+     * @param msg
+     */
+    static async customConfirm(msg = 'Select yes to continue... ') {
+        const varResult = await UserInteraction.customConfirmCompanion(msg);
+        const result = JSON.parse(varResult);
+        if (result.confirm === 'Yes') {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    /**
+     *
+     * @param msg
+     */
+    static async customConfirmCompanion(msg = 'Select yes to continue... ') {
+        return new Promise(function (resolve) {
+            const questions = [
+                {
+                    type: 'list',
+                    name: 'confirm',
+                    message: msg,
+                    choices: ['No', 'Yes'],
+                    default: 'No'
+                }
+            ];
+            inquirer.prompt(questions).then(function (options) {
+                resolve(JSON.stringify(options));
+            });
+        });
+    }
+    /**
+     *
+     * @param msg
+     */
+    static async customConfirmAbort(msg = 'Confirm') {
+        return new Promise(function (resolve) {
+            const questions = [
+                {
+                    type: 'list',
+                    name: 'confirm',
+                    message: msg,
+                    choices: ['No', 'Yes', 'Abort'],
+                    default: 'Yes'
+                }
+            ];
+            inquirer.prompt(questions).then(function (options) {
+                resolve(JSON.stringify(options));
+            });
+        });
+    }
+    /**
+     *
+     */
+    static async pressKeyToExit(warming = 'Process will end', procContinue = true) {
+        ConsoleOutput.warning(warming);
+        let msg = 'Press a key to exit...';
+        if (procContinue) {
+            msg = 'Press a key to continue...';
+        }
+        console.log(msg);
+        const pressKeyToExit = spawnSync('read _ ', { shell: true, stdio: [0, 1, 2] });
+        if (!procContinue) {
+            process.exit(0);
+        }
+    }
+    /**
+     *
+     * @param command
+     */
+    static useRoot(command = '') {
+        ConsoleOutput.titles(pjson.shortName + ' ' + command + ` need to run with root privileges. Please, prefix it with sudo`);
+    }
+    /**
+     *
+     * @param verbose
+     */
+    static setEcho(verbose = false) {
+        let echo = { echo: false, ignore: true };
+        if (verbose) {
+            echo = { echo: true, ignore: false };
+        }
+        return echo;
+    }
+}