penguins-eggs 25.10.28 → 25.11.8

package/dist/commands/analyze.js

@@ -0,0 +1,95 @@
+/**
+ * ./src/commands/analyze.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import { Command, Flags } from '@oclif/core';
+import fs, { constants } from 'node:fs';
+import { access } from 'node:fs/promises';
+import si from 'systeminformation';
+import Users from '../classes/users.js';
+import Utils from '../classes/utils.js';
+export default class Analyze extends Command {
+    static description = 'analyze for syncto';
+    static examples = ['sudo eggs analyze'];
+    static flags = {
+        help: Flags.help({ char: 'h' }),
+        verbose: Flags.boolean({ char: 'v', description: 'verbose' })
+    };
+    config_file = '/etc/penguins-eggs.d/eggs.yaml';
+    snapshot_dir = '';
+    work_dir = {};
+    /**
+     * fill
+     */
+    async fill() {
+        try {
+            const usersArray = [];
+            await access('/etc/passwd', constants.R_OK | constants.W_OK);
+            const passwd = fs.readFileSync('/etc/passwd', 'utf8').split('\n');
+            for (const element of passwd) {
+                const line = element.split(':');
+                const users = new Users(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;
+        }
+        catch {
+            console.error("can't read /etc/passwd");
+            process.exit(1);
+        }
+    }
+    async run() {
+        Utils.titles(this.id + ' ' + this.argv);
+        const { flags } = await this.parse(Analyze);
+        let verbose = false;
+        if (flags.verbose) {
+            verbose = true;
+        }
+        Utils.warning('eggs will analyze your system, and get users data');
+        const echo = Utils.setEcho(verbose);
+        let totalSize = 0;
+        if (Utils.isRoot(this.id)) {
+            const audio = await si.audio();
+            const bios = await si.bios();
+            const blockDevices = await si.blockDevices();
+            const chassis = await si.chassis();
+            const cpu = await si.cpu();
+            const diskLayout = await si.diskLayout();
+            const mem = await si.mem();
+            const usb = await si.usb();
+            console.log(`chassis: ${chassis.manufacturer} model: ${chassis.manufacturer}`);
+            console.log(`bios vendor: ${bios.vendor} version: ${bios.version} revision: ${bios.revision}`);
+            console.log(`processor: ${cpu.brand} core: ${cpu.cores} `);
+            if (diskLayout[0].device !== undefined) {
+                console.log(`disk0: ${diskLayout[0].device}`);
+            }
+            if (diskLayout[1] !== undefined) {
+                console.log(`disk1: ${diskLayout[1].device}`);
+            }
+            if (diskLayout[2] !== undefined) {
+                console.log(`disk1: ${diskLayout[2].device}`);
+            }
+            // console.log(`name: ${blockDevices[0].name} fs: ${blockDevices[0].fsType}`)
+            // console.log(`name: ${blockDevices[1].name} fs: ${blockDevices[1].fsType}`)
+            // console.log(`name: ${blockDevices[2].name} fs: ${blockDevices[2].fsType}`)
+            // console.log(`name: ${blockDevices[3].name} fs: ${blockDevices[3].fsType}`)
+            // console.log(`usb: ${usb[0].name}`)
+            const users = await this.fill();
+            for (let i = 0; i < users.length; i++)
+                if (users[i].saveIt) {
+                    console.log(`user: ${users[i].login} \thome: ${users[i].home.padEnd(16)} \tsize: ${Utils.formatBytes(users[i].size)} \tBytes: ${users[i].size} `);
+                    totalSize += users[i].size;
+                }
+            console.log(`Total\t\t\t\t\tSize: ${Utils.formatBytes(totalSize)} \tBytes: ${totalSize}`);
+        }
+        else {
+            Utils.useRoot(this.id);
+        }
+    }
+}

package/dist/commands/calamares.d.ts

@@ -0,0 +1,29 @@
+/**
+ * ./src/commands/calamares.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import { Command } from '@oclif/core';
+import Incubator from '../classes/incubation/incubator.js';
+import Settings from '../classes/settings.js';
+import { IRemix } from '../interfaces/index.js';
+export default class Calamares extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        help: import("@oclif/core/interfaces").BooleanFlag<void>;
+        install: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        nointeractive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        policies: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        release: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        remove: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        theme: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    incubator: Incubator;
+    remix: IRemix;
+    settings: Settings;
+    run(): Promise<void>;
+}

package/dist/commands/calamares.js

@@ -0,0 +1,112 @@
+/**
+ * ./src/commands/calamares.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import { Command, Flags } from '@oclif/core';
+import fs from 'node:fs';
+import path from 'node:path';
+import Incubator from '../classes/incubation/incubator.js';
+import Pacman from '../classes/pacman.js';
+import Settings from '../classes/settings.js';
+import Utils from '../classes/utils.js';
+export default class Calamares extends Command {
+    static description = 'configure calamares or install or configure it';
+    static examples = ['sudo eggs calamares', 'sudo eggs calamares --install', 'sudo eggs calamares --install --theme=/path/to/theme', 'sudo eggs calamares --remove'];
+    static flags = {
+        help: Flags.help({ char: 'h' }),
+        install: Flags.boolean({ char: 'i', description: 'install calamares and its dependencies' }),
+        nointeractive: Flags.boolean({ char: 'n', description: 'no user interaction' }),
+        policies: Flags.boolean({ char: 'p', description: 'configure calamares policies' }),
+        release: Flags.boolean({ char: 'r', description: 'release: remove calamares and all its dependencies after the installation' }),
+        remove: Flags.boolean({ description: 'remove calamares and its dependencies' }),
+        theme: Flags.string({ description: 'theme/branding for eggs and calamares' }),
+        verbose: Flags.boolean({ char: 'v' })
+    };
+    incubator = {};
+    remix = {};
+    settings = {};
+    async run() {
+        Utils.titles(this.id + ' ' + this.argv);
+        this.settings = new Settings();
+        const { flags } = await this.parse(Calamares);
+        const { verbose } = flags;
+        const { remove } = flags;
+        const { install } = flags;
+        const { release } = flags;
+        const { nointeractive } = flags;
+        let { policies } = flags;
+        let theme = 'eggs';
+        if (flags.theme !== undefined) {
+            theme = flags.theme;
+            if (theme.includes('/')) {
+                if (theme.endsWith('/')) {
+                    theme = theme.slice(0, Math.max(0, theme.length - 1));
+                }
+            }
+            else {
+                const wpath = `/home/${await Utils.getPrimaryUser()}/.wardrobe/vendors/`;
+                theme = wpath + flags.theme;
+            }
+            theme = path.resolve(theme);
+            if (!fs.existsSync(theme + '/theme')) {
+                console.log('Cannot find theme: ' + theme);
+                process.exit();
+            }
+        }
+        console.log(`theme: ${theme}`);
+        let installer = 'krill';
+        if (Pacman.calamaresExists()) {
+            installer = 'calamares';
+        }
+        if (Utils.isRoot(this.id)) {
+            if (!nointeractive || (await Utils.customConfirm('Select yes to continue...'))) {
+                if (remove) {
+                    if (Pacman.calamaresExists()) {
+                        await Pacman.calamaresRemove();
+                        if (await this.settings.load()) {
+                            this.settings.config.force_installer = false;
+                            this.settings.save(this.settings.config);
+                            installer = "krill";
+                        }
+                    }
+                    process.exit();
+                }
+                /**
+                 * Install
+                 */
+                if (install) {
+                    Utils.warning('installing package calamares');
+                    await Pacman.calamaresInstall();
+                    if (await this.settings.load()) {
+                        this.settings.config.force_installer = true;
+                        this.settings.save(this.settings.config);
+                        policies = true;
+                        installer = "calamares";
+                    }
+                }
+            }
+            /**
+             * policies
+             */
+            if (policies) {
+                Utils.warning('configuring calamares policies');
+                await Pacman.calamaresPolicies();
+            }
+            /**
+            * configure
+            */
+            if (await this.settings.load()) {
+                await this.settings.loadRemix(theme);
+                const isClone = false;
+                this.incubator = new Incubator(this.settings.remix, this.settings.distro, this.settings.config.user_opt, theme, isClone, verbose);
+                await this.incubator.config(release);
+            }
+        }
+        else {
+            Utils.useRoot(this.id);
+        }
+    }
+}

package/dist/commands/config.d.ts

@@ -0,0 +1,35 @@
+/**
+ * ./src/commands/config.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import { Command } from '@oclif/core';
+import { IInstall } from '../interfaces/index.js';
+/**
+ *
+ */
+export default class Config extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        clean: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        help: import("@oclif/core/interfaces").BooleanFlag<void>;
+        nointeractive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    /**
+     *
+     * @param i
+     * @param verbose
+     */
+    static install(i: IInstall, nointeractive?: boolean, verbose?: boolean): Promise<void>;
+    /**
+     *
+     *
+     * @param verbose
+     */
+    static thatWeNeed(nointeractive?: boolean, verbose?: boolean, homecrypt?: boolean): Promise<IInstall>;
+    run(): Promise<void>;
+}

package/dist/commands/config.js

@@ -0,0 +1,120 @@
+/**
+ * ./src/commands/config.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import { Command, Flags } from '@oclif/core';
+import Bleach from '../classes/bleach.js';
+import Pacman from '../classes/pacman.js';
+import Utils from '../classes/utils.js';
+import { exec } from '../lib/utils.js';
+/**
+ *
+ */
+export default class Config extends Command {
+    static description = 'Configure eggs to run it';
+    static examples = ['sudo eggs config', 'sudo eggs config --clean', 'sudo eggs config --clean --nointeractive'];
+    static flags = {
+        clean: Flags.boolean({ char: 'c', description: 'remove old configuration before to create new one' }),
+        help: Flags.help({ char: 'h' }),
+        nointeractive: Flags.boolean({ char: 'n', description: 'no user interaction' }),
+        verbose: Flags.boolean({ char: 'v', description: 'verbose' })
+    };
+    /**
+     *
+     * @param i
+     * @param verbose
+     */
+    static async install(i, nointeractive = false, verbose = false) {
+        const echo = Utils.setEcho(verbose);
+        Utils.warning("sudo eggs config");
+        if (i.configurationInstall) {
+            Utils.warning('- creating configuration...');
+            await Pacman.configurationInstall(verbose);
+        }
+        if (i.configurationRefresh) {
+            Utils.warning('- refreshing configuration for new machine...');
+            await Pacman.configurationMachineNew(verbose);
+        }
+        if (i.distroTemplate) {
+            Utils.warning('- copying distro templates...');
+            await Pacman.distroTemplateInstall(verbose);
+        }
+        if (i.needUpdate && !nointeractive && Pacman.distro().familyId === 'debian') {
+            Utils.warning('- updating system...');
+            await exec('apt-get update --yes', echo);
+        }
+        if (i.calamares) {
+            let message = "- You are on a graphic system, is suggested\n";
+            message += "           to install the GUI installer calamares.\n";
+            message += '           just type: "sudo eggs calamares --install"';
+            Utils.warning(message);
+        }
+        if (i.addEfi && Pacman.distro().familyId === 'debian') {
+            Utils.warning('- installing UEFI support');
+            await exec('apt-get install grub-efi-' + Utils.uefiArch() + '-bin --yes', echo);
+        }
+        if (i.needUpdate && !nointeractive) {
+            Utils.warning('cleaning the system...');
+            if (Pacman.distro().familyId === 'debian') {
+                const bleach = new Bleach();
+                await bleach.clean(verbose);
+            }
+        }
+    }
+    /**
+     *
+     *
+     * @param verbose
+     */
+    static async thatWeNeed(nointeractive = false, verbose = false, homecrypt = false) {
+        const i = {};
+        i.distroTemplate = !Pacman.distroTemplateCheck();
+        i.addEfi = !Pacman.isUefi();
+        i.calamares = false;
+        if (!homecrypt &&
+            !Pacman.calamaresExists() &&
+            Pacman.isInstalledGui() &&
+            Pacman.isCalamaresAvailable()) {
+            i.calamares = true;
+        }
+        i.configurationInstall = !Pacman.configurationCheck();
+        if (!i.configurationInstall) {
+            i.configurationRefresh = !Pacman.configurationMachineNew();
+        }
+        return i;
+    }
+    async run() {
+        const { flags } = await this.parse(Config);
+        const { nointeractive } = flags;
+        const { verbose } = flags;
+        if (!nointeractive) {
+            Utils.titles(this.id + ' ' + this.argv);
+        }
+        if (Utils.isRoot(this.id)) {
+            if (flags.clean) {
+                Utils.warning('removing old configurations');
+                await exec('rm /etc/penguins-eggs.d -rf');
+            }
+            /**
+             * Se stiamo utilizzando eggs da sorgenti
+             * Aggiungo autocomplete e manPage
+             */
+            if (Utils.isSources()) {
+                Utils.warning('creating autocomplete...');
+                await Pacman.autocompleteInstall(verbose);
+                Utils.warning('creating eggs man page...');
+                await Pacman.manPageInstall(verbose);
+            }
+            const i = await Config.thatWeNeed(nointeractive, verbose);
+            if (i.needUpdate || i.configurationInstall || i.configurationRefresh || i.distroTemplate) {
+                await Config.install(i, nointeractive, verbose);
+            }
+        }
+        else {
+            Utils.useRoot(this.id);
+        }
+    }
+}

package/dist/commands/cuckoo.d.ts

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

package/dist/commands/cuckoo.js

@@ -0,0 +1,61 @@
+/**
+ * ./src/commands/cuckoo.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import { Command, Flags } from '@oclif/core';
+import network from '../classes/network.js';
+import Pxe from '../classes/pxe.js';
+import Settings from '../classes/settings.js';
+import Utils from '../classes/utils.js';
+export default class Cuckoo extends Command {
+    static description = 'PXE start with proxy-dhcp';
+    static examples = ['sudo eggs cuckoo'];
+    static flags = {
+        help: Flags.help({ char: 'h' }),
+        verbose: Flags.boolean({ char: 'v', description: 'verbose' })
+    };
+    async run() {
+        const { args, flags } = await this.parse(Cuckoo);
+        Utils.titles(this.id + ' ' + this.argv);
+        if (Utils.isRoot()) {
+            const settings = new Settings();
+            settings.load();
+            const nest = settings.config.snapshot_mnt;
+            const pxeRoot = nest + 'pxe';
+            const pxe = new Pxe(nest, pxeRoot, flags.verbose);
+            await pxe.fertilization();
+            await pxe.build();
+            const n = new network();
+            /**
+             * service proxy-dhcp
+             */
+            const dhcpOptions = {
+                bios_filename: 'lpxelinux.0',
+                efi32_filename: 'ipxe32.efi',
+                efi64_filename: 'ipxe.pxe', // era ipxe.efi
+                host: n.address,
+                subnet: n.cidr,
+                tftpserver: n.address,
+                broadcast: n.broadcast()
+            };
+            pxe.dhcpdStart(dhcpOptions);
+            /**
+             * service tftp
+             */
+            const tftpOptions = {
+                denyPUT: true,
+                host: n.address,
+                port: 69,
+                root: pxeRoot
+            };
+            await pxe.tftpStart(tftpOptions);
+            await pxe.httpStart();
+        }
+        else {
+            Utils.useRoot(this.id);
+        }
+    }
+}

package/dist/commands/dad.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ./src/commands/dad.ts
+ * penguins-eggs v.25.7.x / 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.25.7.x / 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.25.7.x / 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.25.7.x / 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.25.7.x / 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>;
+}