penguins-eggs 25.10.3 → 25.10.6

package/dist/commands/pods.js

@@ -0,0 +1,92 @@
+/**
+ * ./src/commands/cuckoo.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import { Args, Command, Flags } from '@oclif/core';
+import fs from 'fs';
+import Utils from '../classes/utils.js';
+import { exec } from '../lib/utils.js';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+// _dirname
+const __dirname = path.dirname(new URL(import.meta.url).pathname);
+export default class Pods extends Command {
+    static args = {
+        distro: Args.string({ description: 'distro to build', name: 'distro', required: false })
+    };
+    static description = 'eggs pods: build ISOs from containers';
+    static examples = [
+        'eggs pods archlinux',
+        'eggs pods debian',
+        'eggs pods ubuntu',
+    ];
+    static flags = {
+        help: Flags.help({ char: 'h' })
+    };
+    /**
+     *
+     */
+    async run() {
+        Utils.titles(this.id + ' ' + this.argv);
+        const { args, flags } = await this.parse(Pods);
+        if (!isPodmanInstalledSync()) {
+            console.log('You need to install podmand to use this command');
+            process.exit(0);
+        }
+        if (process.getuid && process.getuid() === 0) {
+            Utils.warning('You must use eggs pods without sudo');
+            process.exit(0);
+        }
+        // mode
+        let pathPods = path.resolve(__dirname, `../../pods`);
+        const userHome = `/home/${await Utils.getPrimaryUser()}/`;
+        if (Utils.isSources()) {
+            console.log("Using eggs pods from sources.\nThe pods directory of the source will be used ");
+        }
+        else {
+            console.log("Using eggs pods from package.");
+            if (!fs.existsSync(`${userHome}/pods`)) {
+                console.log(`The pods directory will be created in the user home ${userHome}, do you want to continue?`);
+                if (await Utils.customConfirm()) {
+                    console.log(`Creating a pods folder under ${userHome}`);
+                    await exec(`cp -r ${Utils.rootPenguin()}/pods ${userHome}`);
+                }
+            }
+            pathPods = path.resolve(`${userHome}/pods`);
+        }
+        console.log(`Using ${pathPods}`);
+        let distro = 'debian';
+        if (this.argv['0'] !== undefined) {
+            distro = this.argv['0'];
+        }
+        let cmd = `${pathPods}/${distro}.sh`;
+        if (fs.existsSync(cmd)) {
+            console.log(`We are building a egg from a ${distro} container`);
+            if (!await Utils.customConfirm()) {
+                process.exit(0);
+            }
+            await exec(cmd);
+        }
+        else {
+            console.log(`No script: ${cmd} fpr ${distro} container`);
+        }
+    }
+}
+/**
+ *
+ * @returns
+ */
+function isPodmanInstalledSync() {
+    let podmanInstalled = false;
+    try {
+        execSync('podman --version', { stdio: 'ignore' });
+        podmanInstalled = true;
+    }
+    catch (error) {
+        console.error('Podman does not appear to be installed or is not in the PATH.\n');
+    }
+    return podmanInstalled;
+}

package/dist/commands/produce.d.ts

@@ -0,0 +1,35 @@
+/**
+ * ./src/commands/produce.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 Produce extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        addons: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        basename: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        clone: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        cryptedclone: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        excludes: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        help: import("@oclif/core/interfaces").BooleanFlag<void>;
+        kernel: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        links: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        max: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        noicon: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        nointeractive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        pendrive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        prefix: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        release: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        script: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        standard: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        theme: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        unsecure: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        yolk: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/produce.js

@@ -0,0 +1,221 @@
+/**
+ * ./src/commands/produce.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 path from 'node:path';
+import Compressors from '../classes/compressors.js';
+import Ovary from '../classes/ovary.js';
+import Utils from '../classes/utils.js';
+import Config from './config.js';
+// _dirname
+const __dirname = path.dirname(new URL(import.meta.url).pathname);
+export default class Produce extends Command {
+    static description = 'produce a live image from your system whithout your data';
+    static examples = [
+        'sudo eggs produce                    # zstd fast compression',
+        'sudo eggs produce --standard         # xz compression',
+        'sudo eggs produce --max              # xz max compression',
+        'sudo eggs produce --pendrive         # zstd compression optimized pendrive',
+        'sudo eggs produce --clone            # clone',
+        'sudo eggs produce --cryptedclone     # crypted clone',
+        'sudo eggs produce --basename=colibri',
+        'sudo eggs produce --theme lastos',
+        'sudo eggs produce --excludes static  # you can customize it',
+        'sudo eggs produce --excludes homes   # exclude /home/*',
+        'sudo eggs produce --excludes home    # exclude ~/*'
+    ];
+    static flags = {
+        addons: Flags.string({ description: 'addons to be used: adapt, pve, rsupport', multiple: true }),
+        basename: Flags.string({ description: 'basename' }),
+        clone: Flags.boolean({ char: 'c', description: 'clone' }),
+        cryptedclone: Flags.boolean({ char: 'C', description: 'crypted clone' }),
+        excludes: Flags.string({ description: 'use: static, homes, home', multiple: true }),
+        help: Flags.help({ char: 'h' }),
+        kernel: Flags.string({ char: 'k', description: 'kernel version' }),
+        links: Flags.string({ description: 'desktop links', multiple: true }),
+        max: Flags.boolean({ char: 'm', description: 'max compression: xz -Xbcj ...' }),
+        noicon: Flags.boolean({ char: 'N', description: 'no icon eggs on desktop' }),
+        nointeractive: Flags.boolean({ char: 'n', description: 'no user interaction' }),
+        pendrive: Flags.boolean({ char: 'p', description: 'optimized for pendrive: zstd -b 1M -Xcompression-level 15' }),
+        prefix: Flags.string({ char: 'P', description: 'prefix' }),
+        release: Flags.boolean({ description: 'release: remove penguins-eggs, calamares and dependencies after installation' }),
+        script: Flags.boolean({ char: 's', description: 'script mode. Generate scripts to manage iso build' }),
+        standard: Flags.boolean({ char: 'S', description: 'standard compression: xz -b 1M' }),
+        theme: Flags.string({ description: 'theme for livecd, calamares branding and partitions' }),
+        unsecure: Flags.boolean({ char: 'u', description: '/root contents are included on live' }),
+        verbose: Flags.boolean({ char: 'v', description: 'verbose' }),
+        yolk: Flags.boolean({ char: 'y', description: 'force yolk renew' })
+    };
+    async run() {
+        Utils.titles(this.id + ' ' + this.argv);
+        const { flags } = await this.parse(Produce);
+        const pendrive = flags.pendrive === undefined ? null : Number(flags.pendrive);
+        if (Utils.isRoot()) {
+            /**
+             * ADDONS dei vendors
+             * Fino a 3
+             */
+            const addons = [];
+            if (flags.addons) {
+                const { addons } = flags; // array
+                for (let addon of addons) {
+                    // se non viene specificato il vendor il default è eggs
+                    if (!addon.includes('//')) {
+                        addon = 'eggs/' + addon;
+                    }
+                    const dirAddon = path.resolve(__dirname, `../../addons/${addon}`);
+                    if (!fs.existsSync(dirAddon)) {
+                        console.log(dirAddon);
+                        Utils.warning('addon: ' + chalk.white(addon) + ' not found, terminate!');
+                        process.exit();
+                    }
+                    const vendorAddon = addon.slice(0, Math.max(0, addon.search('/')));
+                    const nameAddon = addon.substring(addon.search('/') + 1, addon.length);
+                    if (nameAddon === 'theme') {
+                        flags.theme = vendorAddon;
+                    }
+                }
+            }
+            // links check
+            const myLinks = [];
+            if (flags.links) {
+                const { links } = flags;
+                for (const link_ of links) {
+                    if (fs.existsSync(`/usr/share/applications/${link_}.desktop`)) {
+                        myLinks.push(link_);
+                    }
+                    else {
+                        Utils.warning('desktop link: ' + chalk.white('/usr/share/applications/' + link_ + '.desktop') + ' not found!');
+                    }
+                }
+            }
+            /**
+             * composizione dei flag
+             */
+            // excludes
+            const excludes = {};
+            excludes.usr = true;
+            excludes.var = true;
+            excludes.static = false;
+            excludes.homes = false;
+            excludes.home = false;
+            if (flags.excludes) {
+                if (flags.excludes.includes('static')) {
+                    excludes.static = true;
+                }
+                if (flags.excludes.includes('homes')) {
+                    excludes.homes = true;
+                }
+                if (flags.excludes.includes('home')) {
+                    excludes.home = true;
+                }
+            }
+            let prefix = '';
+            if (flags.prefix !== undefined) {
+                prefix = flags.prefix;
+            }
+            let basename = ''; // se vuoto viene definito da loadsetting (default nome dell'host)
+            if (flags.basename !== undefined) {
+                basename = flags.basename;
+            }
+            const compressors = new Compressors();
+            await compressors.populate();
+            let compression = compressors.fast();
+            if (flags.max) {
+                compression = compressors.max();
+            }
+            else if (flags.pendrive) {
+                compression = compressors.pendrive('15');
+            }
+            else if (flags.standard) {
+                compression = compressors.standard();
+            }
+            const { release } = flags;
+            const { cryptedclone } = flags;
+            const { clone } = flags;
+            const { verbose } = flags;
+            const scriptOnly = flags.script;
+            const yolkRenew = flags.yolk;
+            const { nointeractive } = flags;
+            const { noicon } = flags;
+            // if clone or cryptedclone unsecure = true
+            const unsecure = flags.unsecure || clone || cryptedclone;
+            let { kernel } = flags;
+            if (kernel === undefined) {
+                kernel = '';
+            }
+            if (kernel !== '') {
+                if (!fs.existsSync(`/usr/lib/modules/${kernel}`)) {
+                    let kernelModules = `/usr/lib/modules/`;
+                    if (!fs.existsSync(kernelModules)) {
+                        kernelModules = `/lib/modules/`;
+                    }
+                    let kernels = fs.readdirSync(kernelModules);
+                    console.log("modules available:");
+                    for (const k of kernels) {
+                        console.log(`- ${k}`);
+                    }
+                    console.log(`\nNo available modules for kernel version "${kernel}" in /usr/lib/modules/`);
+                    process.exit(1);
+                }
+            }
+            /**
+             * theme: if not defined will use eggs
+             */
+            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();
+                }
+            }
+            const i = await Config.thatWeNeed(nointeractive, verbose, cryptedclone);
+            if ((i.needUpdate || i.configurationInstall || i.configurationRefresh || i.distroTemplate)) {
+                await Config.install(i, nointeractive, verbose);
+            }
+            const myAddons = {};
+            if (flags.addons != undefined) {
+                if (flags.addons.includes('adapt')) {
+                    myAddons.adapt = true;
+                }
+                if (flags.addons.includes('pve')) {
+                    myAddons.pve = true;
+                }
+                if (flags.addons.includes('rsupport')) {
+                    myAddons.rsupport = true;
+                }
+            }
+            Utils.titles(this.id + ' ' + this.argv);
+            const ovary = new Ovary();
+            Utils.warning('Produce an egg...');
+            if (i.calamares) {
+                let message = "this is a GUI system, calamares is available, but NOT installed\n";
+                Utils.warning(message);
+            }
+            if (await ovary.fertilization(prefix, basename, theme, compression, !nointeractive)) {
+                await ovary.produce(kernel, clone, cryptedclone, scriptOnly, yolkRenew, release, myAddons, myLinks, excludes, nointeractive, noicon, unsecure, verbose);
+                ovary.finished(scriptOnly);
+            }
+        }
+        else {
+            Utils.useRoot(this.id);
+        }
+    }
+}

package/dist/commands/status.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ./src/commands/status.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 Status 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/status.js

@@ -0,0 +1,31 @@
+/**
+ * ./src/commands/status.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 Information from '../krill/components/information.js';
+/**
+ *
+ */
+export default class Status extends Command {
+    static description = 'informations about eggs status';
+    static examples = ['eggs status'];
+    static flags = {
+        help: Flags.help({ char: 'h' }),
+        verbose: Flags.boolean({ char: 'v' })
+    };
+    /**
+     *
+     */
+    async run() {
+        const { flags } = await this.parse(Status);
+        let verbose = false;
+        if (flags.verbose) {
+            verbose = true;
+        }
+        Information(verbose);
+    }
+}

package/dist/commands/syncfrom.d.ts

@@ -0,0 +1,45 @@
+/**
+ * ./src/commands/syncfrom.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 { IRemix } from '../interfaces/index.js';
+/**
+ *
+ */
+export default class Syncfrom extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        delete: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        file: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        help: import("@oclif/core/interfaces").BooleanFlag<void>;
+        rootdir: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    echo: {};
+    luksName: string;
+    luksDevice: string;
+    luksFile: string;
+    luksMountpoint: string;
+    remix: IRemix;
+    rootDir: string;
+    verbose: boolean;
+    /**
+     *
+     */
+    luksClose(): Promise<void>;
+    /**
+     *
+     */
+    luksOpen(): Promise<void>;
+    run(): Promise<void>;
+    /**
+     *
+     * @param verbose
+     */
+    private restorePrivateData;
+}

package/dist/commands/syncfrom.js

@@ -0,0 +1,152 @@
+/**
+ * ./src/commands/syncfrom.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 Distro from '../classes/distro.js';
+import Utils from '../classes/utils.js';
+import { exec } from '../lib/utils.js';
+/**
+ *
+ */
+export default class Syncfrom extends Command {
+    static description = 'restore users and user data from a LUKS volumes';
+    static examples = ['sudo eggs syncfrom', 'sudo eggs syncfrom --file /path/to/luks-volume'];
+    static flags = {
+        delete: Flags.string({ description: 'rsync --delete delete extraneous files from dest dirs' }),
+        file: Flags.string({ char: 'f', description: 'file containing luks-volume encrypted' }),
+        help: Flags.help({ char: 'h' }),
+        rootdir: Flags.string({ char: 'r', description: 'rootdir of the installed system, when used from live' }),
+        verbose: Flags.boolean({ char: 'v', description: 'verbose' })
+    };
+    echo = {};
+    luksName = 'luks-volume';
+    luksDevice = `/dev/mapper/${this.luksName}`;
+    luksFile = '';
+    luksMountpoint = `/tmp/mnt/${this.luksName}`;
+    remix = {};
+    rootDir = '/';
+    verbose = false;
+    /**
+     *
+     */
+    async luksClose() {
+        if (Utils.isMountpoint(this.luksMountpoint)) {
+            await exec(`umount ${this.luksMountpoint}`, this.echo);
+        }
+        if (fs.existsSync(this.luksDevice)) {
+            Utils.warning(`LUKS close volume: ${this.luksName}`);
+            await exec(`cryptsetup luksClose ${this.luksName}`, this.echo);
+        }
+    }
+    /**
+     *
+     */
+    async luksOpen() {
+        if (fs.existsSync(this.luksDevice)) {
+            Utils.warning(`LUKS volume: ${this.luksName} already open`);
+        }
+        else {
+            Utils.warning(`LUKS open volume: ${this.luksName}`);
+            await exec(`cryptsetup luksOpen --type luks2 ${this.luksFile} ${this.luksName}`, Utils.setEcho(true));
+        }
+        if (!fs.existsSync(this.luksMountpoint)) {
+            await exec(`mkdir -p ${this.luksMountpoint}`, this.echo);
+        }
+        if (Utils.isMountpoint(this.luksMountpoint)) {
+            Utils.warning(`mount volume: ${this.luksDevice} already mounted on ${this.luksMountpoint}`);
+        }
+        else {
+            Utils.warning(`mount volume: ${this.luksDevice} on ${this.luksMountpoint}`);
+            await exec(`mount ${this.luksDevice} ${this.luksMountpoint}`, this.echo);
+        }
+    }
+    async run() {
+        const { flags } = await this.parse(Syncfrom);
+        if (flags.verbose) {
+            this.verbose = true;
+        }
+        this.echo = Utils.setEcho(this.verbose);
+        let fileVolume = '';
+        if (flags.file) {
+            fileVolume = flags.file;
+        }
+        let destDelete = false;
+        if (flags.delete) {
+            destDelete = true;
+        }
+        if (Utils.isLive()) {
+            if (flags.rootdir) {
+                this.rootDir = flags.rootdir;
+            }
+            else {
+                Utils.pressKeyToExit('Argument --rootdir is mandatory, when running live! Process will terminate');
+            }
+        }
+        if (Utils.isRoot()) {
+            if (fileVolume === '') {
+                const distro = new Distro();
+                fileVolume = `${distro.liveMediumPath}live/${this.luksName}`;
+            }
+            if (Utils.isLive()) {
+                /**
+                 * WORKING FROM LIVE
+                 */
+                this.luksName = path.basename(fileVolume);
+                this.luksFile = fileVolume;
+                this.luksDevice = `/dev/mapper/${this.luksName}`;
+                this.luksMountpoint = `/tmp/${this.luksName}`;
+                await this.restorePrivateData();
+            }
+            else {
+                /**
+                 * WORKING FROM INSTALLED
+                 */
+                if (fs.existsSync(fileVolume)) {
+                    this.luksName = path.basename(fileVolume);
+                    this.luksFile = fileVolume;
+                    this.luksDevice = `/dev/mapper/${this.luksName}`;
+                    this.luksMountpoint = `/tmp/${this.luksName}`;
+                    await this.restorePrivateData();
+                    if (await Utils.customConfirm('Your system was updated! Press a key to reboot')) {
+                        await exec('reboot');
+                    }
+                }
+                else {
+                    Utils.pressKeyToExit(`Can't find ${this.luksFile}`);
+                }
+            }
+        }
+        else {
+            Utils.useRoot(this.id);
+        }
+    }
+    /**
+     *
+     * @param verbose
+     */
+    async restorePrivateData(destDelete = false) {
+        if (!fs.existsSync(this.luksMountpoint)) {
+            await exec(`mkdir ${this.luksMountpoint}`, this.echo);
+        }
+        await this.luksOpen();
+        if (Utils.isLive() && this.rootDir !== '/') {
+            Utils.warning('Restoring crypted data');
+            // Rimozione dei file esistenti
+            await exec(`rm -rf ${this.rootDir}/etc/lightdm/lightdm.conf`, this.echo);
+            await exec(`rm -rf ${this.rootDir}/etc/passwd`, this.echo);
+            await exec(`rm -rf ${this.rootDir}/etc/group`, this.echo);
+            await exec(`rm -rf ${this.rootDir}/etc/shadow`, this.echo);
+            await exec(`rm -rf ${this.rootDir}/home/*`, this.echo);
+            // unsquashfs
+            const cmd = `unsquashfs -d ${this.rootDir} -f ${this.luksMountpoint}/private.squashfs`;
+            await exec(cmd, Utils.setEcho(true));
+        }
+        await this.luksClose();
+    }
+}

package/dist/commands/syncto.d.ts

@@ -0,0 +1,40 @@
+/**
+ * ./src/commands/syncto.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 Settings from '../classes/settings.js';
+/**
+ *
+ */
+export default class Syncto extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        excludes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        file: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        help: import("@oclif/core/interfaces").BooleanFlag<void>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    echo: {};
+    exclude: boolean;
+    excludeHome: string;
+    luksName: string;
+    luksDevice: string;
+    luksFile: string;
+    luksMountpoint: string;
+    privateSquashfs: string;
+    settings: Settings;
+    verbose: boolean;
+    /**
+     *
+     */
+    luksCreate(): Promise<void>;
+    /**
+     *
+     */
+    run(): Promise<void>;
+}