penguins-eggs 10.1.0 → 25.7.7

package/dist/commands/dad.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ./src/commands/dad.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 Dad extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        clean: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        default: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        file: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        nointeractive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        help: import("@oclif/core/interfaces").BooleanFlag<void>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/dad.js

@@ -0,0 +1,47 @@
+/**
+ * ./src/commands/dad.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import fs from 'node:fs';
+import Daddy from '../classes/daddy.js';
+import Utils from '../classes/utils.js';
+import { exec } from '../lib/utils.js';
+export default class Dad extends Command {
+    static description = 'ask help from daddy - TUI configuration helper';
+    static examples = ['sudo dad', 'sudo dad --clean', 'sudo dad --default'];
+    static flags = {
+        clean: Flags.boolean({ char: 'c', description: 'remove old configuration before to create' }),
+        default: Flags.boolean({ char: 'd', description: 'reset to default values' }),
+        file: Flags.string({ char: 'f', description: 'use a file configuration custom' }),
+        nointeractive: Flags.boolean({ char: 'n', description: 'no user interaction' }),
+        help: Flags.help({ char: 'h' }),
+        verbose: Flags.boolean({ char: 'v' })
+    };
+    async run() {
+        Utils.titles(this.id + ' ' + this.argv);
+        console.log(chalk.cyan('Daddy, what else did you leave for me?'));
+        const { flags } = await this.parse(Dad);
+        const fileCustom = flags.file;
+        const isCustom = fileCustom !== undefined && fileCustom !== '';
+        const reset = flags.default;
+        if (Utils.isRoot(this.id)) {
+            if (flags.clean || flags.default || flags.mine) {
+                await exec('rm /etc/penguins-eggs.d -rf');
+            }
+            if (isCustom && !fs.existsSync(fileCustom)) {
+                console.log(chalk.red(`Custom configuration file: ${flags.custom} not found!`));
+                process.exit(1);
+            }
+            const daddy = new Daddy();
+            daddy.helpMe(reset, isCustom, fileCustom, flags.verbose);
+        }
+        else {
+            Utils.useRoot(this.id);
+        }
+    }
+}

package/dist/commands/export/iso.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ./src/commands/export/iso.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 ExportIso extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        checksum: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        clean: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        help: import("@oclif/core/interfaces").BooleanFlag<void>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/export/iso.js

@@ -0,0 +1,55 @@
+/**
+ * ./src/commands/export/iso.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import { Command, Flags } from '@oclif/core';
+import Tools from '../../classes/tools.js';
+import Utils from '../../classes/utils.js';
+import { exec } from '../../lib/utils.js';
+export default class ExportIso extends Command {
+    static description = 'export iso in the destination host';
+    static examples = ['eggs export iso', 'eggs export iso --clean'];
+    static flags = {
+        checksum: Flags.boolean({ char: 'C', description: 'export checksums md5 and sha256' }),
+        clean: Flags.boolean({ char: 'c', description: 'delete old ISOs before to copy' }),
+        help: Flags.help({ char: 'h' }),
+        verbose: Flags.boolean({ char: 'v', description: 'verbose' })
+    };
+    async run() {
+        const { flags } = await this.parse(ExportIso);
+        Utils.titles(this.id + ' ' + this.argv);
+        Utils.warning(ExportIso.description);
+        const Tu = new Tools();
+        await Tu.loadSettings();
+        const echo = Utils.setEcho(flags.verbose);
+        const rmount = `/tmp/eggs-${(Math.random() + 1).toString(36).slice(7)}`;
+        let cmd = `rm -f ${rmount}\n`;
+        const filters = ['*.iso', '*.md5', '*.sha256'];
+        cmd += `mkdir ${rmount}\n`;
+        cmd += `sshfs ${Tu.config.remoteUser}@${Tu.config.remoteHost}:${Tu.config.remotePathIso} ${rmount}\n`;
+        if (flags.clean) {
+            cmd += `rm -f ${rmount}/${Tu.snapshot_name}*\n`;
+        }
+        cmd += `cp ${Tu.snapshot_dir}${Tu.snapshot_name}${filters[0]} ${rmount}\n`;
+        if (flags.checksum) {
+            cmd += `cp ${Tu.snapshot_dir}${Tu.snapshot_name}${filters[1]} ${rmount}\n`;
+            cmd += `cp ${Tu.snapshot_dir}${Tu.snapshot_name}${filters[2]} ${rmount}\n`;
+        }
+        cmd += 'sync\n';
+        cmd += `umount ${rmount}\n`;
+        cmd += `rm -f ${rmount}\m`;
+        if (!flags.verbose) {
+            if (flags.clean) {
+                console.log(`remove  ${Tu.config.remoteUser}@${Tu.config.remoteHost}:${Tu.config.remotePathIso}${Tu.snapshot_name}${filters[0]}`);
+            }
+            if (flags.checksum) {
+                console.log(`export  ${Tu.config.localPathIso}/${Tu.snapshot_name}${filters[1]}/${filters[2]} to ${Tu.config.remoteUser}@${Tu.config.remoteHost}:${Tu.config.remotePathIso}`);
+            }
+            console.log(`scp     ${Tu.config.localPathIso}/${Tu.snapshot_name}${filters[0]} ${Tu.config.remoteUser}@${Tu.config.remoteHost}:${Tu.config.remotePathIso}`);
+        }
+        await exec(cmd, echo);
+    }
+}

package/dist/commands/export/pkg.d.ts

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

package/dist/commands/export/pkg.js

@@ -0,0 +1,179 @@
+/**
+ * ./src/commands/export/deb.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import { Command, Flags } from '@oclif/core';
+import Distro from '../../classes/distro.js';
+import Diversions from '../../classes/diversions.js';
+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';
+export default class ExportPkg extends Command {
+    static description = 'export pkg/iso to the destination host';
+    static examples = ['eggs export pkg', 'eggs export pkg --clean', 'eggs export pkg --all'];
+    static flags = {
+        all: Flags.boolean({ char: 'a', description: 'export all archs' }),
+        clean: Flags.boolean({ char: 'c', description: 'remove old .deb before to copy' }),
+        help: Flags.help({ char: 'h' }),
+        verbose: Flags.boolean({ char: 'v', description: 'verbose' })
+    };
+    user = '';
+    all = false;
+    clean = false;
+    verbose = false;
+    echo = {};
+    Tu = new Tools();
+    /**
+     *
+     */
+    async run() {
+        const { args, flags } = await this.parse(ExportPkg);
+        Utils.titles(this.id + ' ' + this.argv);
+        Utils.warning(ExportPkg.description);
+        // Ora servono in più parti
+        this.user = os.userInfo().username;
+        if (this.user === 'root') {
+            this.user = execSync('echo $SUDO_USER', { encoding: 'utf-8' }).trim();
+            if (this.user === '') {
+                this.user = execSync('echo $DOAS_USER', { encoding: 'utf-8' }).trim();
+            }
+        }
+        this.all = flags.all;
+        this.clean = flags.clean;
+        this.verbose = flags.verbose;
+        this.echo = Utils.setEcho(this.verbose);
+        await this.Tu.loadSettings();
+        let distro = new Distro();
+        const familyId = distro.familyId;
+        const distroId = distro.distroId;
+        const remoteMountpoint = `/tmp/eggs-${(Math.random() + 1).toString(36).slice(7)}`;
+        let localPath = '';
+        let remotePath = '';
+        let filter = '';
+        /**
+         * aldos
+         */
+        if (familyId === 'aldos') {
+            Utils.warning("aldos rpm");
+            process.exit();
+            /**
+             * alpine
+             */
+        }
+        else if (familyId === 'alpine') {
+            let arch = 'x86_64';
+            if (process.arch === 'ia32') {
+                arch = 'i386';
+            }
+            Utils.warning(`alpine apk`);
+            localPath = `/home/${this.user}/packages/aports/${arch}`;
+            remotePath = `${this.Tu.config.remotePathPackages}/alpine/${arch}`;
+            filter = `penguins-eggs-*[0-9][0-9].@([0-9]|[0-1][0-9]).@([0-9]|[0-3][0-9])-*.apk`;
+            /**
+             * Arch/Manjaro
+             */
+        }
+        else if (familyId === 'archlinux') {
+            /**
+             * Manjaro
+             */
+            if (Diversions.isManjaroBased(distroId)) {
+                Utils.warning("manjaro PKGBUILD");
+                localPath = `/home/${this.user}/penguins-packs/manjaro/penguins-eggs`;
+                remotePath = this.Tu.config.remotePathPackages + "/manjaro";
+                filter = `penguins-eggs-[0-9][0-9].@([0-9]|[0-1][0-9]).@([0-9]|[0-3][0-9])-*-any.pkg.tar.*`;
+                /**
+                 * Arch
+                 */
+            }
+            else {
+                Utils.warning("aur PKGBUILD");
+                localPath = `/home/${this.user}/penguins-packs/aur/penguins-eggs`;
+                remotePath = this.Tu.config.remotePathPackages + "/aur";
+                filter = `penguins-eggs-[0-9][0-9].@([0-9]|[0-1][0-9]).@([0-9]|[0-3][0-9])-*-any.pkg.tar.zst`;
+            }
+            /**
+             * Debian
+             */
+        }
+        else if (familyId === "debian") {
+            Utils.warning("debian deb");
+            localPath = `/home/${this.user}/penguins-eggs/dist`;
+            remotePath = this.Tu.config.remotePathPackages + "/debs";
+            let arch = Utils.uefiArch();
+            if (this.all) {
+                arch = '*';
+            }
+            filter = `penguins-eggs_[0-9][0-9].@([0-9]|[0-1][0-9]).@([0-9]|[0-3][0-9])-*_${arch}.deb`;
+            /**
+             * fedora
+             */
+        }
+        else if (familyId === 'fedora') {
+            Utils.warning("fedora rpm packages");
+            localPath = `/home/${this.user}/rpmbuild/RPMS/x86_64`;
+            remotePath = this.Tu.config.remotePathPackages + "/fedora";
+            filter = `penguins-eggs-[0-9][0-9].@([0-9]|[0-1][0-9]).@([0-9]|[0-3][0-9])-*fedora.*.rpm`;
+            /**
+             * openmamba
+             */
+        }
+        else if (familyId === 'openmamba') {
+            Utils.warning("openmamba rpm packages");
+            localPath = `/usr/src/RPM/RPMS/x86_64`;
+            remotePath = this.Tu.config.remotePathPackages + "/openmamba";
+            filter = `penguins-eggs-[0-9][0-9].@([0-9]|[0-1][0-9]).@([0-9]|[0-3][0-9])-*mamba.*.rpm`;
+            /**
+             * opensuse
+             */
+        }
+        else if (familyId === 'opensuse') {
+            Utils.warning("opensuse rpm packages");
+            process.exit();
+            /**
+             * voidlinux
+             */
+        }
+        else if (familyId === 'voidlinux') {
+            Utils.warning("voidlinux packages");
+            process.exit();
+        }
+        let cmd = `#!/bin/bash\n`;
+        cmd += `set -e\n`;
+        cmd += 'shopt -s extglob\n';
+        cmd += `mkdir ${remoteMountpoint}\n`;
+        cmd += `sshfs ${this.Tu.config.remoteUser}@${this.Tu.config.remoteHost}:${remotePath} ${remoteMountpoint}\n`;
+        if (this.clean) {
+            let archDest = '';
+            if (distro.familyId === 'alpine') {
+                let archDest = 'x86_64/';
+                if (process.arch === 'ia32') {
+                    archDest = 'i386/';
+                }
+            }
+            cmd += `# Delete old packages\n`;
+            cmd += `rm -f ${remoteMountpoint}/${archDest}${filter}\n`;
+        }
+        cmd += `# Export packages\n`;
+        cmd += `cp ${localPath}/${filter} ${remoteMountpoint}\n`;
+        cmd += 'sync\n';
+        cmd += `# wait before to umount\n`;
+        cmd += 'sleep 2s\n';
+        cmd += `fusermount3 -u ${remoteMountpoint}\n`;
+        cmd += `# remove mountpoint\n`;
+        cmd += `rm -rf ${remoteMountpoint}\n`;
+        if (!this.verbose) {
+            if (this.clean) {
+                console.log(`remove: ${this.Tu.config.remoteUser}@${this.Tu.config.remoteHost}:${filter}`);
+            }
+            console.log(`copy: ${localPath}/${filter} to ${this.Tu.config.remoteUser}@${this.Tu.config.remoteHost}:${remotePath}`);
+        }
+        // console.log(cmd)
+        await exec(cmd, this.echo);
+    }
+}

package/dist/commands/export/tarballs.d.ts

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

package/dist/commands/export/tarballs.js

@@ -0,0 +1,79 @@
+/**
+ * ./src/commands/export/deb.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import { Command, Flags } from '@oclif/core';
+import Tools from '../../classes/tools.js';
+import Utils from '../../classes/utils.js';
+import { exec } from '../../lib/utils.js';
+import os from 'node:os';
+import { globSync } from 'glob';
+import path from 'path';
+// pjson
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const pjson = require('../../../package.json');
+import { execSync } from 'node:child_process';
+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'];
+    static flags = {
+        clean: Flags.boolean({ char: 'c', description: 'remove old .deb before to copy' }),
+        help: Flags.help({ char: 'h' }),
+        verbose: Flags.boolean({ char: 'v', description: 'verbose' })
+    };
+    user = '';
+    clean = false;
+    verbose = false;
+    echo = {};
+    Tu = new Tools();
+    /**
+     *
+     */
+    async run() {
+        const { args, flags } = await this.parse(ExportTarballs);
+        Utils.titles(this.id + ' ' + this.argv);
+        Utils.warning(ExportTarballs.description);
+        // Ora servono in più parti
+        this.user = os.userInfo().username;
+        if (this.user === 'root') {
+            this.user = execSync('echo $SUDO_USER', { encoding: 'utf-8' }).trim();
+            if (this.user === '') {
+                this.user = execSync('echo $DOAS_USER', { encoding: 'utf-8' }).trim();
+            }
+        }
+        this.clean = flags.clean;
+        this.verbose = flags.verbose;
+        this.echo = Utils.setEcho(this.verbose);
+        await this.Tu.loadSettings();
+        const remoteMountpoint = `/tmp/eggs-${(Math.random() + 1).toString(36).slice(7)}`;
+        const localPath = `/home/${this.user}/penguins-eggs/dist/`;
+        const remotePath = `${this.Tu.config.remotePathPackages}/tarballs/`;
+        const tarNamePattern = `penguins-eggs_${pjson.version}-*-linux-x64.tar.gz`;
+        const searchPattern = path.join(localPath, tarNamePattern);
+        const matchingFiles = globSync(searchPattern);
+        if (matchingFiles.length === 0) {
+            console.log(`No ${searchPattern} exists!`);
+            console.log(`Create it using: pnpm tarballs`);
+            process.exit(1);
+        }
+        let cmd = `mkdir ${remoteMountpoint}\n`;
+        cmd += `sshfs ${this.Tu.config.remoteUser}@${this.Tu.config.remoteHost}:${remotePath} ${remoteMountpoint}\n`;
+        if (this.clean) {
+            cmd += `rm -f ${remoteMountpoint}/${tarNamePattern}\n`;
+        }
+        cmd += `cp ${localPath}${tarNamePattern} ${remoteMountpoint}/\n`;
+        cmd += 'sync\n';
+        cmd += `umount ${remoteMountpoint}\n`;
+        cmd += `rm -rf ${remoteMountpoint}\n`;
+        if (!this.verbose) {
+            if (this.clean) {
+                console.log(`remove: ${this.Tu.config.remoteUser}@${this.Tu.config.remoteHost}:${remotePath}/${tarNamePattern}`);
+            }
+        }
+        await exec(cmd, this.echo);
+    }
+}

package/dist/commands/install.d.ts

@@ -0,0 +1,38 @@
+/**
+ * ./src/commands/install.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import { Command } from '@oclif/core';
+/**
+ * Class Krill
+ */
+export default class Install extends Command {
+    static aliases: string[];
+    static description: string;
+    static examples: string[];
+    static flags: {
+        btrfs: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        chroot: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        crypted: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        domain: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        halt: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        help: import("@oclif/core/interfaces").BooleanFlag<void>;
+        ip: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        nointeractive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        none: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        pve: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        random: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        small: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        suspend: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        testing: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        unattended: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    /**
+     * Execute
+     */
+    run(): Promise<void>;
+}

package/dist/commands/install.js

@@ -0,0 +1,91 @@
+/**
+ * ./src/commands/install.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import { Command, Flags } from '@oclif/core';
+import yaml from 'js-yaml';
+import fs from 'node:fs';
+import https from 'node:https';
+import Utils from '../classes/utils.js';
+import Krill from '../krill/classes/prepare.js';
+const agent = new https.Agent({
+    rejectUnauthorized: false
+});
+// import { ILvmOptions } from '../krill/interfaces/i-krill.js'
+/**
+ * Class Krill
+ */
+export default class Install extends Command {
+    static aliases = ['krill'];
+    static description = 'krill: the CLI system installer - the egg became a penguin!';
+    static examples = ['sudo eggs install', 'sudo eggs install --unattended --halt', 'sudo eggs install --chroot'];
+    static flags = {
+        btrfs: Flags.boolean({ char: 'b', description: 'Format btrfs' }),
+        chroot: Flags.boolean({ char: 'c', description: 'chroot before to end' }),
+        crypted: Flags.boolean({ char: 'k', description: 'Crypted CLI installation' }),
+        domain: Flags.string({ char: 'd', description: 'Domain name, defult: .local' }),
+        halt: Flags.boolean({ char: 'H', description: 'Halt the system after installation' }),
+        help: Flags.help({ char: 'h' }),
+        ip: Flags.boolean({ char: 'i', description: 'hostname as ip, eg: ip-192-168-1-33' }),
+        nointeractive: Flags.boolean({ char: 'n', description: 'no user interaction' }),
+        none: Flags.boolean({ char: 'N', description: 'Swap none: 256M' }),
+        pve: Flags.boolean({ char: 'p', description: 'Proxmox VE install' }),
+        random: Flags.boolean({ char: 'r', description: 'Add random to hostname, eg: colibri-ay412dt' }),
+        small: Flags.boolean({ char: 's', description: 'Swap small: RAM' }),
+        suspend: Flags.boolean({ char: 'S', description: 'Swap suspend: RAM x 2' }),
+        testing: Flags.boolean({ char: 't', description: "Just testing krill" }),
+        unattended: Flags.boolean({ char: 'u', description: 'Unattended installation' }),
+        verbose: Flags.boolean({ char: 'v', description: 'Verbose' })
+    };
+    /**
+     * Execute
+     */
+    async run() {
+        Utils.titles(this.id + ' ' + this.argv);
+        const { flags } = await this.parse(Install);
+        const { unattended } = flags;
+        // krillConfig
+        let krillConfig = {};
+        const content = fs.readFileSync('/etc/penguins-eggs.d/krill.yaml', 'utf8');
+        krillConfig = yaml.load(content);
+        // nointeractive
+        const { nointeractive } = flags;
+        // halt
+        const { halt } = flags;
+        // hostname
+        const { ip } = flags;
+        const { random } = flags;
+        // chroot before to end
+        const { chroot } = flags;
+        let domain = '';
+        if (flags.domain) {
+            domain = flags.domain;
+        }
+        // swap
+        const { suspend } = flags;
+        const { small } = flags;
+        const { none } = flags;
+        let { crypted } = flags;
+        const { pve } = flags;
+        if (pve) {
+            crypted = false;
+        }
+        const { testing } = flags;
+        const { verbose } = flags;
+        if (Utils.isRoot() || testing) {
+            if (Utils.isLive() || testing) {
+                const krill = new Krill(unattended, nointeractive, halt, chroot);
+                await krill.prepare(krillConfig, ip, random, domain, suspend, small, none, crypted, pve, flags.btrfs, testing, verbose);
+            }
+            else {
+                Utils.warning('You are in an installed system!');
+            }
+        }
+        else {
+            Utils.useRoot(this.id);
+        }
+    }
+}

package/dist/commands/kill.d.ts

@@ -0,0 +1,24 @@
+/**
+ * ./src/commands/kill.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 Kill extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        help: import("@oclif/core/interfaces").BooleanFlag<void>;
+        isos: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        nointeractive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    config_file: string;
+    snapshot_dir: string;
+    run(): Promise<void>;
+}

package/dist/commands/kill.js

@@ -0,0 +1,50 @@
+/**
+ * ./src/commands/kill.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import { Command, Flags } from '@oclif/core';
+import Settings from '../classes/settings.js';
+import Utils from '../classes/utils.js';
+import killMeSoftly from '../lib/kill_me_softly.js';
+/**
+ *
+ */
+export default class Kill extends Command {
+    static description = 'kill the eggs/free the nest';
+    static examples = ['sudo eggs kill'];
+    static flags = {
+        help: Flags.help({ char: 'h' }),
+        isos: Flags.boolean({ char: 'i', description: 'erase all ISOs on remote mount' }),
+        nointeractive: Flags.boolean({ char: 'n', description: 'no user interaction' }),
+        verbose: Flags.boolean({ char: 'v', description: 'verbose' })
+    };
+    config_file = '/etc/penguins-eggs.d/eggs.yaml';
+    snapshot_dir = '';
+    async run() {
+        Utils.titles(this.id + ' ' + this.argv);
+        const { flags } = await this.parse(Kill);
+        const { verbose } = flags;
+        const { isos } = flags;
+        const { nointeractive } = flags;
+        const echo = Utils.setEcho(verbose);
+        if (Utils.isRoot()) {
+            const settings = new Settings();
+            await settings.load();
+            await settings.listFreeSpace();
+            if (Utils.isMountpoint(settings.config.snapshot_mnt)) {
+                console.log('==========================================');
+                Utils.warning('You are working on a mountpoint');
+                console.log('==========================================');
+            }
+            if (nointeractive || (await Utils.customConfirm())) {
+                await killMeSoftly(settings.config.snapshot_dir, settings.config.snapshot_mnt, isos);
+            }
+        }
+        else {
+            Utils.useRoot(this.id);
+        }
+    }
+}