penguins-eggs 9.6.34 → 10.0.0

package/dist/commands/syncto.js

@@ -1,243 +1,179 @@
-"use strict";
 /**
- * penguins-eggs
- * command: syncto.ts
+ * ./src/commands/syncto.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
  * author: Piero Proietti
  * email: piero.proietti@gmail.com
  * license: MIT
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
+// https://gist.github.com/ansemjo/6f1cf9d9b8f7ce8f70813f52c63b74a6
+import { Command, Flags } from '@oclif/core';
+import fs from 'node:fs';
+import Compressors from '../classes/compressors.js';
+import Settings from '../classes/settings.js';
+import Utils from '../classes/utils.js';
+import { exec } from '../lib/utils.js';
 /**
  *
- * syncfrom (restore)
- * --include-from file.list // if only include is provided everything from the list if used to update the system.
- * --exclude-from file-list // it just updates the system
- * --delete
- *
-* If both options are provided then it works as a combination as provided in the link above.
-* https://stackoverflow.com/questions/19296190/rsync-include-from-vs-exclude-from-what-is-the-actual-difference
-*
- * The same logic is applied for the syncto also.
- *
- * On top of all of this the --delete option
- * if needed to be passed so that everything else is removed, but this
- * this should not be available by default
  */
-const core_1 = require("@oclif/core");
-const fs_1 = tslib_1.__importDefault(require("fs"));
-const path_1 = tslib_1.__importDefault(require("path"));
-const utils_1 = tslib_1.__importDefault(require("../classes/utils"));
-const utils_2 = require("../lib/utils");
-// backup
-const promises_1 = require("fs/promises");
-const fs_2 = require("fs");
-const users_1 = tslib_1.__importDefault(require("../classes/users"));
-/**
- *
- */
-class Syncto extends core_1.Command {
-    constructor() {
-        super(...arguments);
-        this.verbose = false;
-        this.echo = {};
-        this.luksName = 'luks-eggs-backup';
-        this.luksFile = `/run/live/medium/live/${this.luksName}`;
-        this.luksDevice = `/dev/mapper/${this.luksName}`;
-        this.luksMountpoint = '/tmp/eggs-backup';
-    }
+export default class Syncto extends Command {
+    static description = 'Save users and users\' data ENCRYPTED';
+    static examples = [
+        'sudo eggs syncto',
+        'sudo eggs syncto --file /path/to/luks-volume',
+        'sudo eggs syncto --excludes'
+    ];
+    static flags = {
+        excludes: Flags.boolean({ char: 'e', description: 'use: exclude.list.d/home.list' }),
+        file: Flags.string({ char: 'f', description: 'file luks-volume encrypted' }),
+        help: Flags.help({ char: 'h' }),
+        verbose: Flags.boolean({ char: 'v', description: 'verbose' }),
+    };
+    echo = {};
+    exclude = false;
+    excludeHome = '/etc/penguins-eggs.d/exclude.list.d/home.list';
+    luksName = 'luks-volume';
+    luksDevice = `/dev/mapper/${this.luksName}`;
+    luksFile = `/tmp/${this.luksName}`;
+    luksMountpoint = `/tmp/mnt/${this.luksName}`;
+    privateSquashfs = `private.squashfs`;
+    settings = {};
+    verbose = false;
     /**
      *
      */
-    async run() {
-        const { flags } = await this.parse(Syncto);
-        if (flags.verbose) {
-            this.verbose = true;
-        }
-        this.echo = utils_1.default.setEcho(this.verbose);
-        let fileVolume = '';
-        if (flags.file) {
-            fileVolume = flags.file;
-        }
-        let destDelete = false;
-        if (flags.delete) {
-            destDelete = true;
-        }
-        if (utils_1.default.isRoot()) {
-            /**
-                 * restore con file
-                 */
-            if (fileVolume === '') {
-                fileVolume = '/tmp/luks-eggs-data';
-            }
-            this.luksName = path_1.default.basename(fileVolume);
-            this.luksFile = fileVolume;
-            this.luksDevice = `/dev/mapper/${this.luksName}`;
-            this.luksMountpoint = '/tmp/eggs-data';
-            if (!fs_1.default.existsSync(fileVolume)) {
-                await this.luksCreate();
+    async luksCreate() {
+        await exec(`rm -rf ${this.luksFile}`);
+        // ==========================================================================
+        // Create squashfs
+        // ==========================================================================
+        Utils.warning(`Creating private.squashfs`);
+        const compressors = new Compressors();
+        await compressors.populate();
+        // comp
+        let comp = '';
+        this.settings = new Settings();
+        if (await this.settings.load()) {
+            let compression = compressors.fast();
+            if (this.settings.config.compression == `max`) {
+                compression = compressors.max();
             }
-            else {
-                utils_1.default.warning(`LUKS volume: ${this.luksFile} exist, don't need create`);
+            else if (this.settings.config.compression == `standard`) {
+                compression = compressors.standard();
             }
-            if (fs_1.default.existsSync(fileVolume)) {
-                await this.luksOpen();
-                await this.backup(destDelete);
-                await this.luksClose();
+            comp = `-comp ${compression}`;
+        }
+        // exclude /home/eggs
+        let exclude_nest = '';
+        if (fs.existsSync(this.settings.work_dir.workdir)) {
+            exclude_nest = `-e ${this.settings.config.snapshot_dir}`;
+        }
+        // exclude file
+        let exclude_home = '';
+        if (this.exclude) {
+            exclude_home = `-ef ${this.excludeHome}`;
+        }
+        // creato dummyfs per /etc/
+        await exec(`mkdir -p /tmp/dummyfs/etc`, this.echo);
+        await exec(`cp -a /etc/passwd /tmp/dummyfs/etc`, this.echo);
+        await exec(`cp -a /etc/group /tmp/dummyfs/etc`, this.echo);
+        await exec(`cp -a /etc/shadow /tmp/dummyfs/etc`, this.echo);
+        await exec(`mkdir -p /tmp/dummyfs/etc/lightdm`, this.echo); // lightdm
+        await exec(`cp -a /etc/lightdm/lightdm.conf /tmp/dummyfs/etc/lightdm/`, this.echo); // lightdm  
+        let mkPrivateSquashfs = `mksquashfs \
+                              /tmp/dummyfs/etc \
+                              /home \
+                              /tmp/${this.privateSquashfs} \
+                              ${comp} \
+                              ${exclude_nest} \
+                              ${exclude_home} \
+                              -keep-as-directory \ 
+                              -noappend`;
+        mkPrivateSquashfs = mkPrivateSquashfs.replaceAll(/\s\s+/g, ` `);
+        await exec(mkPrivateSquashfs, Utils.setEcho(true));
+        // remove dummyfs
+        await exec(`rm /tmp/dummyfs/ -rf`, this.echo);
+        // ==========================================================================
+        // Create LUKS volume
+        // ==========================================================================
+        Utils.titles("Creating LUKS Volume");
+        // calcolo size
+        const sizeString = (await exec(`unsquashfs -s /tmp/${this.privateSquashfs} | grep "Filesystem size" | sed -e 's/.*size //' -e 's/ .*//'`, { capture: true, echo: false })).data;
+        let size = Number.parseInt(sizeString) + 2048;
+        console.log("size private.squashfs:", bytesToGB(size), size);
+        const luksBlockSize = 512;
+        const luksBlocks = Math.ceil(size / luksBlockSize);
+        size = luksBlockSize * luksBlocks;
+        // Aggiungo un 20% in più per ottenere luksSize
+        const luksSize = Math.ceil((size) * 1.2);
+        console.log("luksSize:", bytesToGB(luksSize), luksSize);
+        // truncate * 2048 è cruciale
+        const truncateAt = luksSize * 2048;
+        Utils.warning(`Preparing file ${this.luksFile} for ${this.luksDevice}, size ${truncateAt}`);
+        await exec(`truncate --size ${luksSize} ${this.luksFile}`, this.echo);
+        Utils.warning(`Creating LUKS Volume on ${this.luksFile}`);
+        await exec(`cryptsetup --batch-mode luksFormat ${this.luksFile}`, Utils.setEcho(true));
+        console.log('');
+        // open LUKS volume temp
+        Utils.warning(`Opening LUKS Volume on ${this.luksFile}`);
+        const { code } = await exec(`cryptsetup luksOpen ${this.luksFile} ${this.luksName}`, Utils.setEcho(true));
+        if (code != 0) {
+            Utils.error(`cryptsetup luksOpen ${this.luksFile} ${this.luksName} failed`);
+            process.exit(code);
+        }
+        await exec('udevadm settle', this.echo);
+        // formatta ext4 il volume
+        await exec(`mkfs.ext4 ${this.luksDevice}`, this.echo);
+        console.log('');
+        // mount LUKS volume
+        if (!fs.existsSync(`this.luksMountpoint)`)) {
+            Utils.warning(`creating mountpoint ${this.luksMountpoint}`);
+            await exec(`mkdir -p ${this.luksMountpoint}`, this.echo);
+        }
+        if (!Utils.isMountpoint(`${this.luksMountpoint}`)) {
+            Utils.warning(`mounting volume: ${this.luksDevice} on ${this.luksMountpoint}`);
+            const { code } = await exec(`mount ${this.luksDevice} ${this.luksMountpoint}`, Utils.setEcho(true));
+            if (code != 0) {
+                Utils.error(`mount ${this.luksDevice} ${this.luksMountpoint} failed`);
+                process.exit(code);
             }
         }
-        else {
-            utils_1.default.useRoot(this.id);
-        }
+        // copy private.squashfs
+        Utils.warning(`moving /tmp/${this.privateSquashfs} to ${this.luksMountpoint}`);
+        await exec(`mv /tmp/${this.privateSquashfs} ${this.luksMountpoint}`, this.echo);
+        Utils.warning(`Umounting ${this.luksMountpoint}`);
+        await exec(`umount ${this.luksMountpoint}`, this.echo);
+        Utils.warning(`Vlosing ${this.luksMountpoint}`);
+        await exec(`cryptsetup luksClose ${this.luksName}`, this.echo);
     }
     /**
      *
      */
-    async backup(destDelete = false) {
-        if (this.verbose) {
-            utils_1.default.warning('backup');
-        }
-        utils_1.default.warning(`Saving users' data on ${this.luksFile}`);
-        const usersArray = await this.usersFill();
-        for (const element of usersArray) {
-            if (element.saveIt && fs_1.default.existsSync(element.home)) {
-                await (0, utils_2.exec)(`mkdir -p ${this.luksMountpoint}/ROOT${element.home}`, this.echo);
-                const source = element.home;
-                let dest = this.luksMountpoint + '/ROOT' + element.home;
-                dest = dest.slice(0, Math.max(0, dest.lastIndexOf('/')));
-                let cmd = `rsync --archive ${source} ${dest}`;
-                if (destDelete) {
-                    cmd = `rsync --archive --delete ${source} ${dest}`;
-                }
-                await (0, utils_2.exec)(cmd, this.echo);
-            }
-        }
-        utils_1.default.warning(`Saving users' accounts on ${this.luksFile}`);
-        await (0, utils_2.exec)(`mkdir -p ${this.luksMountpoint}/etc`, this.echo);
-        await (0, utils_2.exec)(`cp /etc/passwd ${this.luksMountpoint}/etc`, this.echo);
-        await (0, utils_2.exec)(`cp /etc/shadow ${this.luksMountpoint}/etc`, this.echo);
-        await (0, utils_2.exec)(`cp /etc/group ${this.luksMountpoint}/etc`, this.echo);
-    }
-    /**
-    * usersFill
-    */
-    async usersFill() {
-        const usersArray = [];
-        await (0, promises_1.access)('/etc/passwd', fs_2.constants.R_OK | fs_2.constants.W_OK);
-        const passwd = fs_1.default.readFileSync('/etc/passwd', 'utf-8').split('\n');
-        for (const element of passwd) {
-            const line = element.split(':');
-            const users = new users_1.default(line[0], line[1], line[2], line[3], line[4], line[5], line[6]);
-            await users.getValues();
-            if (users.password !== undefined) {
-                usersArray.push(users);
-            }
-        }
-        return usersArray;
-    }
-    /**
-     *
-     */
-    async luksCreate() {
-        utils_1.default.warning(`Creating LUKS Volume on ${this.luksFile}`);
-        let totalSize = 0;
-        console.log('I will extimate volume size from your private data:');
-        const users = await this.usersFill();
-        for (const user of users) {
-            if (user.login !== 'root' && user.saveIt) {
-                let utype = 'user   ';
-                if (Number.parseInt(user.uid) < 1000) {
-                    utype = 'service';
-                }
-                console.log(`- ${utype}: ${user.login.padEnd(16)} \thome: ${user.home} \tsize: ${utils_1.default.formatBytes(user.size)} \tBytes: ${user.size} `);
-                totalSize += user.size;
-            }
-        }
-        console.log(`Total\t\t\t\t\t\t\tsize: ${utils_1.default.formatBytes(totalSize)} \tBytes: ${totalSize}`);
-        /**
-           * after we get size, we can start building luks-volume
-           */
-        const binaryHeaderSize = 4194304;
-        const volumeSize = totalSize * 1.5 + binaryHeaderSize;
-        // Deciding blockSize and blocks
-        const blockSize = 512;
-        let blocks = Math.ceil(volumeSize / blockSize);
-        // We need a minimum size of 32 MB
-        const minimunSize = 134217728; // 128 * 1024 *1024
-        if (totalSize < minimunSize) { }
-        if (blocks * blockSize < minimunSize) {
-            blocks = Math.ceil(minimunSize / blockSize);
-        }
-        utils_1.default.warning(`Creating an encrypted file ${this.luksFile} blocks=${blocks}, block size: ${blockSize}, size: ${utils_1.default.formatBytes(blocks * blockSize)}`);
-        await (0, utils_2.exec)(`dd if=/dev/zero of=${this.luksFile} bs=${blockSize} count=${blocks}`, this.echo);
-        // find first unused device
-        const findFirstUnusedDevice = await (0, utils_2.exec)('losetup -f', { echo: this.verbose, ignore: false, capture: true });
-        let firstUnusedDevice = '';
-        if (findFirstUnusedDevice.code !== 0) {
-            utils_1.default.pressKeyToExit(`Error: ${findFirstUnusedDevice.code} ${findFirstUnusedDevice.data}`);
-        }
-        else {
-            firstUnusedDevice = findFirstUnusedDevice.data.trim();
-        }
-        await (0, utils_2.exec)(`losetup ${firstUnusedDevice} ${this.luksFile}`, this.echo);
-        // Utils.warning('Enter a large string of random text below to setup the pre-encryption')
-        await (0, utils_2.exec)(`cryptsetup -y -v --type luks2 luksFormat  ${this.luksFile}`, utils_1.default.setEcho(true));
-        // Utils.warning(`Enter the desired passphrase for the encrypted ${this.luksName} below`)
-        const crytoSetup = await (0, utils_2.exec)(`cryptsetup luksOpen --type luks2 ${this.luksFile} ${this.luksName}`, utils_1.default.setEcho(true));
-        if (crytoSetup.code !== 0) {
-            utils_1.default.pressKeyToExit(`Error: ${crytoSetup.code} ${crytoSetup.data}`);
-        }
-        utils_1.default.warning(`Formatting ${this.luksDevice} to ext2`);
-        const formatting = await (0, utils_2.exec)(`sudo mkfs.ext2 ${this.luksDevice}`, this.echo);
-        if (formatting.code !== 0) {
-            utils_1.default.pressKeyToExit(`Error: ${formatting.code} ${formatting.data}`);
-        }
-        // this.luksClose()
-    }
-    /**
-     *
-     */
-    async luksOpen() {
-        if (!fs_1.default.existsSync(this.luksDevice)) {
-            // Utils.warning(`LUKS open volume: ${this.luksName}`)
-            await (0, utils_2.exec)(`cryptsetup luksOpen --type luks2 ${this.luksFile} ${this.luksName}`, utils_1.default.setEcho(true));
+    async run() {
+        Utils.titles(this.id + ' ' + this.argv);
+        const { flags } = await this.parse(Syncto);
+        if (flags.verbose) {
+            this.verbose = true;
         }
-        else {
-            utils_1.default.warning(`LUKS volume: ${this.luksName} already open`);
+        this.echo = Utils.setEcho(this.verbose);
+        let fileLuks = '';
+        if (flags.file) {
+            fileLuks = flags.file;
         }
-        if (!fs_1.default.existsSync(this.luksMountpoint)) {
-            await (0, utils_2.exec)(`mkdir -p ${this.luksMountpoint}`, this.echo);
+        if (flags.excludes) {
+            this.exclude = true;
         }
-        if (!utils_1.default.isMountpoint(this.luksMountpoint)) {
-            utils_1.default.warning(`mount volume: ${this.luksDevice} on ${this.luksMountpoint}`);
-            await (0, utils_2.exec)(`mount ${this.luksDevice} ${this.luksMountpoint}`, this.echo);
+        if (Utils.isRoot()) {
+            await this.luksCreate();
         }
         else {
-            utils_1.default.warning(`mount volume: ${this.luksDevice} already mounted on ${this.luksMountpoint}`);
-        }
-    }
-    /**
-    *
-    */
-    async luksClose() {
-        if (utils_1.default.isMountpoint(this.luksMountpoint)) {
-            await (0, utils_2.exec)(`umount ${this.luksMountpoint}`, this.echo);
-        }
-        if (fs_1.default.existsSync(this.luksDevice)) {
-            utils_1.default.warning(`LUKS close volume: ${this.luksName}`);
-            await (0, utils_2.exec)(`cryptsetup luksClose ${this.luksName}`, this.echo);
+            Utils.useRoot(this.id);
         }
     }
 }
-Syncto.flags = {
-    delete: core_1.Flags.string({ description: 'rsync --delete delete extraneous files from dest dirs' }),
-    file: core_1.Flags.string({ char: 'f', description: 'file LUKS volume encrypted' }),
-    help: core_1.Flags.help({ char: 'h' }),
-    verbose: core_1.Flags.boolean({ char: 'v', description: 'verbose' }),
-};
-Syncto.description = 'saves users and user data in a LUKS volume inside the iso';
-Syncto.examples = [
-    'sudo eggs syncto',
-    'sudo eggs syncto --file /path/to/fileLUKS',
-];
-exports.default = Syncto;
+/**
+ * Convert bytes to gigabytes
+ */
+function bytesToGB(bytes) {
+    const gigabytes = bytes / 1_073_741_824;
+    return gigabytes.toFixed(2) + ' GB';
+}

package/dist/commands/tools/clean.d.ts

@@ -0,0 +1,18 @@
+/**
+ * ./src/commands/tools/clean.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import { Command } from '@oclif/core';
+export default class Clean extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        help: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<void>;
+        nointeractive: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/tools/clean.js

@@ -1,43 +1,39 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
 /**
- * penguins-eggs
- * command: clean.ts
+ * ./src/commands/tools/clean.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
  * author: Piero Proietti
  * email: piero.proietti@gmail.com
  * license: MIT
  */
-const core_1 = require("@oclif/core");
-const utils_1 = tslib_1.__importDefault(require("../../classes/utils"));
-const bleach_1 = tslib_1.__importDefault(require("../../classes/bleach"));
-class Clean extends core_1.Command {
+import { Command, Flags } from '@oclif/core';
+import Bleach from '../../classes/bleach.js';
+import Utils from '../../classes/utils.js';
+export default class Clean extends Command {
+    static description = 'clean system log, apt, etc';
+    static examples = [
+        'sudo eggs tools clean',
+    ];
+    static flags = {
+        help: Flags.help({ char: 'h' }),
+        nointeractive: Flags.boolean({ char: 'n', description: 'no user interaction' }),
+        verbose: Flags.boolean({ char: 'v', description: 'verbose' }),
+    };
     async run() {
         const { flags } = await this.parse(Clean);
-        utils_1.default.titles(this.id + ' ' + this.argv);
+        Utils.titles(this.id + ' ' + this.argv);
         let verbose = false;
         if (flags.verbose) {
             verbose = true;
         }
-        const nointeractive = flags.nointeractive;
-        if (utils_1.default.isRoot()) {
-            if (nointeractive || await utils_1.default.customConfirm('Select yes to continue...')) {
-                const bleach = new bleach_1.default();
+        const { nointeractive } = flags;
+        if (Utils.isRoot()) {
+            if (nointeractive || await Utils.customConfirm('Select yes to continue...')) {
+                const bleach = new Bleach();
                 bleach.clean(verbose);
             }
         }
         else {
-            utils_1.default.useRoot(this.id);
+            Utils.useRoot(this.id);
         }
     }
 }
-Clean.flags = {
-    help: core_1.Flags.help({ char: 'h' }),
-    nointeractive: core_1.Flags.boolean({ char: 'n', description: 'no user interaction' }),
-    verbose: core_1.Flags.boolean({ char: 'v', description: 'verbose' }),
-};
-Clean.description = 'clean system log, apt, etc';
-Clean.examples = [
-    'sudo eggs tools clean',
-];
-exports.default = Clean;

package/dist/commands/tools/ppa.d.ts

@@ -0,0 +1,26 @@
+/**
+ * ./src/commands/tools/ppa.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import { Command } from '@oclif/core';
+/**
+ *
+ */
+export default class Ppa extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        add: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        help: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<void>;
+        nointeractive: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        remove: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    /**
+     *
+     */
+    run(): Promise<void>;
+}