penguins-eggs 10.1.0 → 10.1.1

package/dist/commands/tools/stat.js

@@ -0,0 +1,70 @@
+/**
+ * ./src/commands/tools/stat.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 axios from 'axios';
+import https from 'node:https';
+import Utils from '../../classes/utils.js';
+const agent = new https.Agent({
+    rejectUnauthorized: false
+});
+/**
+ *
+ */
+export default class ToolsStat extends Command {
+    static description = 'get statistics from sourceforge';
+    static examples = ['eggs tools stat', 'eggs tools stat --month', 'eggs tools stat --year'];
+    static flags = {
+        help: Flags.help({ char: 'h' }),
+        month: Flags.boolean({ char: 'm', description: 'current month' }),
+        year: Flags.boolean({ char: 'y', description: 'current year' })
+    };
+    /**
+     *
+     */
+    async run() {
+        const { args, flags } = await this.parse(ToolsStat);
+        Utils.titles(this.id + ' ' + this.argv);
+        const yesterday = new Date();
+        yesterday.setDate(yesterday.getDate() - 1);
+        // current date
+        // adjust 0 before single digit date
+        const day = ('0' + yesterday.getDate()).slice(-2);
+        // current month
+        const month = ('0' + (yesterday.getMonth() + 1)).slice(-2);
+        // current year
+        const year = yesterday.getFullYear();
+        const end = year + '-' + month + '-' + day;
+        let start = year + '-' + month + '-' + day;
+        if (flags.month) {
+            start = year + '-' + month + '-01';
+        }
+        if (flags.year) {
+            start = year + '-01-01';
+        }
+        this.log('start: ' + start + ', end: ' + end + '\n');
+        await this.show(start, end, 'Packages/DEBS');
+        console.log();
+        await this.show(start, end, 'ISOS');
+    }
+    /**
+     *
+     * @param start
+     * @param end
+     * @param type
+     */
+    async show(start, end, type) {
+        let url = `https://sourceforge.net/projects/penguins-eggs/files/${type}/stats/json`;
+        const request = '?start_date=' + start + '&end_date=' + end;
+        url += request;
+        const res = await axios.get(url, { httpsAgent: agent });
+        console.log(type);
+        for (const country of res.data.countries) {
+            console.log('- ' + country[0] + ': ' + country[1]);
+        }
+    }
+}

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

@@ -0,0 +1,24 @@
+/**
+ * ./src/commands/tools/yolk.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 ToolsYolk extends Command {
+    static description: string;
+    static dir: 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/tools/yolk.js

@@ -0,0 +1,45 @@
+/**
+ * ./src/commands/tools/yolk.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 fs from 'node:fs';
+import shx from 'shelljs';
+import Utils from '../../classes/utils.js';
+import Yolk from '../../classes/yolk.js';
+/**
+ *
+ */
+export default class ToolsYolk extends Command {
+    static description = 'configure eggs to install without internet';
+    static dir = '/var/local/yolk';
+    static examples = ['sudo eggs tools yolk'];
+    static flags = {
+        help: Flags.help({ char: 'h' }),
+        verbose: Flags.boolean({ char: 'v' })
+    };
+    /**
+     *
+     */
+    async run() {
+        Utils.titles(this.id + ' ' + this.argv);
+        const { flags } = await this.parse(ToolsYolk);
+        let verbose = false;
+        if (flags.verbose) {
+            verbose = true;
+        }
+        if (Utils.isRoot()) {
+            if (fs.existsSync(ToolsYolk.dir)) {
+                shx.exec(`rm ${ToolsYolk.dir} -rf `);
+            }
+            const yolk = new Yolk();
+            await yolk.create(verbose);
+        }
+        else {
+            Utils.useRoot(this.id);
+        }
+    }
+}

package/dist/commands/update.d.ts

@@ -0,0 +1,51 @@
+/**
+ * ./src/commands/syncfrom.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 Distro from '../classes/distro.js';
+/**
+ *
+ */
+export default class Update extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        help: import("@oclif/core/interfaces").BooleanFlag<void>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    distro: Distro;
+    /**
+     * run
+     */
+    run(): Promise<void>;
+    chooseUpdate(): Promise<void>;
+    /**
+     *
+     */
+    choosePkg(): Promise<string>;
+    /**
+     *
+     */
+    getPkgFromRepo(): Promise<void>;
+    /**
+     * download da LAN
+     */
+    getPkgFromLan(): Promise<void>;
+    /**
+     *
+     */
+    getPkgFromSourceforge(): Promise<void>;
+    /**
+   *
+   * @param aptVersion
+   */
+    getFromSources(): void;
+    /**
+     * show
+     */
+    show(url: string): Promise<void>;
+}

package/dist/commands/update.js

@@ -0,0 +1,219 @@
+/**
+ * ./src/commands/syncfrom.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 inquirer from 'inquirer';
+import Distro from '../classes/distro.js';
+import Tools from '../classes/tools.js';
+import Utils from '../classes/utils.js';
+import Diversions from '../classes/diversions.js';
+import { exec } from '../lib/utils.js';
+import axios from 'axios';
+import https from 'node:https';
+const agent = new https.Agent({
+    rejectUnauthorized: false
+});
+/**
+ *
+ */
+export default class Update extends Command {
+    static description = "update the Penguins' eggs tool";
+    static examples = ['eggs update'];
+    static flags = {
+        help: Flags.help({ char: 'h' }),
+        verbose: Flags.boolean({ char: 'v', description: 'verbose' })
+    };
+    distro = new Distro();
+    /**
+     * run
+     */
+    async run() {
+        Utils.titles(this.id + ' ' + this.argv);
+        const { flags } = await this.parse(Update);
+        Utils.titles(this.id + ' ' + this.argv);
+        if (Utils.isRoot()) {
+            if (Utils.isSources()) {
+                Utils.warning(`You are on penguins-eggs v. ${Utils.getPackageVersion()} from sources`);
+            }
+            else if (Utils.isPackage()) {
+                Utils.warning(`You are on eggs-${Utils.getPackageVersion()} installed as package`);
+            }
+            await this.chooseUpdate();
+        }
+        else {
+            Utils.useRoot(this.id);
+        }
+    }
+    async chooseUpdate() {
+        console.log();
+        const choose = await this.choosePkg();
+        Utils.titles(`updating via ${choose}`);
+        switch (choose) {
+            case 'repos': {
+                await this.getPkgFromRepo();
+                break;
+            }
+            case 'lan': {
+                await this.getPkgFromLan();
+                break;
+            }
+            case 'sourceforge': {
+                this.getPkgFromSourceforge();
+                break;
+            }
+            case 'sources': {
+                this.getFromSources();
+                break;
+            }
+            // No default
+        }
+    }
+    /**
+     *
+     */
+    async choosePkg() {
+        const choices = ['abort'];
+        choices.push('lan', 'repos', 'sourceforge', 'sources');
+        const questions = [
+            {
+                choices,
+                message: 'select update method',
+                name: 'selected',
+                type: 'list'
+            }
+        ];
+        const answer = await inquirer.prompt(questions);
+        if (answer.selected === 'abort') {
+            process.exit(0);
+        }
+        return answer.selected;
+    }
+    /**
+     *
+     */
+    async getPkgFromRepo() {
+        let cmd = "";
+        if (this.distro.familyId === "debian") {
+            cmd = 'apt install penguins-eggs';
+        }
+        else if (this.distro.familyId === 'archlinux') {
+            cmd = 'pacman -S penguins-eggs';
+        }
+        else if (this.distro.familyId === 'alpine') {
+            cmd = `apk add penguins-egga`;
+        }
+        console.log(cmd);
+        await exec(cmd);
+    }
+    /**
+     * download da LAN
+     */
+    async getPkgFromLan() {
+        const Tu = new Tools();
+        await Tu.loadSettings();
+        Utils.warning('import from lan');
+        if (this.distro.familyId === "debian") {
+            const filterDeb = `penguins-eggs_10.?.*-*_${Utils.uefiArch()}.deb`;
+            const cmd = `scp ${Tu.config.remoteUser}@${Tu.config.remoteHost}:${Tu.config.remotePathPackages}/debs/${filterDeb} /tmp`;
+            await exec(cmd, { capture: true, echo: true });
+            if (await Utils.customConfirm(`Want to install ${filterDeb}`)) {
+                await exec(`dpkg -i /tmp/${filterDeb}`);
+            }
+        }
+        else if (this.distro.familyId === 'archlinux') {
+            let repo = "aur";
+            if (Diversions.isManjaroBased(this.distro.distroId)) {
+                repo = 'manjaro';
+            }
+            const filterAur = `penguins-eggs-10.?.*-?-any.pkg.tar.zst`;
+            const cmd = `scp ${Tu.config.remoteUser}@${Tu.config.remoteHost}:${Tu.config.remotePathPackages}/${repo}/${filterAur} /tmp`;
+            await exec(cmd, { capture: true, echo: true });
+            if (await Utils.customConfirm(`Want to install ${filterAur}`)) {
+                await exec(`pacman -U /tmp/${filterAur}`);
+            }
+        }
+        else if (this.distro.familyId === 'alpine') {
+            let arch = 'x86_64';
+            if (process.arch === 'ia32') {
+                arch = 'i386';
+            }
+            const filter = `penguins-eggs*10.?.*-r*.apk`;
+            const cmd = `scp ${Tu.config.remoteUser}@${Tu.config.remoteHost}:${Tu.config.remotePathPackages}/alpine/${filter} /tmp`;
+            await exec(cmd, { capture: true, echo: true });
+            if (await Utils.customConfirm(`Want to install ${filter}`)) {
+                await exec(`apk add /tmp/${filter}`);
+            }
+        }
+    }
+    /**
+     *
+     */
+    async getPkgFromSourceforge() {
+        let repo = '';
+        let cmd = '';
+        let url = 'https://sourceforge.net/projects/penguins-eggs/files/Packages';
+        let filter = `penguins-eggs`;
+        if (this.distro.familyId === "debian") {
+            repo = "debs";
+            url = `${url}/${repo}/${Utils.uefiArch()}`;
+            filter = `penguins-eggs_10.?.*-?_${Utils.uefiArch()}.deb`;
+            cmd = `sudo dpkg -i ${filter}`;
+        }
+        else if (this.distro.familyId === 'archlinux') {
+            repo = "aur";
+            filter = `penguins-eggs-10.?.*-?-any.pkg.tar.zst`;
+            cmd = `sudo pacman -U ${filter}`;
+            if (Diversions.isManjaroBased(this.distro.distroId)) {
+                repo = 'manjaro';
+            }
+            url = `${url}/${repo}`;
+        }
+        let command = `Open your browser at:\n`;
+        command += `${url}\n`;
+        command += `select and download the package: ${filter},\n`;
+        command += `then type the command:\n`;
+        command += `${cmd}`;
+        console.log(command);
+        await this.show(url);
+    }
+    /**
+   *
+   * @param aptVersion
+   */
+    getFromSources() {
+        console.log('You can get a fresh installation, cloning penguins-eggs:');
+        console.log('cd ~');
+        console.log('git clone https://github.com/pieroproietti/penguins-eggs');
+        console.log('');
+        console.log('Then, open your browser to read detailed instructions:');
+        console.log('https://github.com/pieroproietti/penguins-eggs/blob/master/PREREQUISITES/README.md');
+        console.log('');
+        console.log('');
+    }
+    /**
+     * show
+     */
+    async show(url) {
+        url += `/stats/json`;
+        const yesterday = new Date();
+        yesterday.setDate(yesterday.getDate() - 1);
+        // adjust 0 before single digit date
+        const day = ('0' + yesterday.getDate()).slice(-2);
+        const month = ('0' + (yesterday.getMonth() + 1)).slice(-2);
+        const year = yesterday.getFullYear();
+        const end = year + '-' + month + '-' + day;
+        let start = year + '-' + month + '-' + day;
+        const request = '?start_date=' + start + '&end_date=' + end;
+        url += request;
+        const res = await axios.get(url, { httpsAgent: agent });
+        console.log("\nStatistics to get an idea: yesterday downloads");
+        console.log();
+        for (const country of res.data.countries) {
+            console.log('- ' + country[0] + ': ' + country[1]);
+        }
+    }
+}

package/dist/commands/wardrobe/get.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ./src/commands/wardrobe/get.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 Get extends Command {
+    static args: {
+        repo: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    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/wardrobe/get.js

@@ -0,0 +1,52 @@
+/**
+ * ./src/commands/wardrobe/get.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import { Args, Command, Flags } from '@oclif/core';
+import { basename } from 'node:path';
+import Utils from '../../classes/utils.js';
+// libraries
+import { exec } from '../../lib/utils.js';
+/**
+ *
+ */
+export default class Get extends Command {
+    static args = {
+        repo: Args.string({ description: 'repository to get', name: 'repo', required: false })
+    };
+    // static args ={name: 'repo', description: 'repository to get', required: false}
+    static description = 'get warorobe';
+    static examples = ['eggs wardrobe get', 'eggs wardrobe get your-wardrobe'];
+    static flags = {
+        help: Flags.help({ char: 'h' }),
+        verbose: Flags.boolean({ char: 'v' })
+    };
+    async run() {
+        const { args, flags } = await this.parse(Get);
+        let verbose = false;
+        if (flags.verbose) {
+            verbose = true;
+        }
+        const echo = Utils.setEcho(verbose);
+        Utils.titles(this.id + ' ' + this.argv);
+        let repo = 'https://github.com/pieroproietti/penguins-wardrobe';
+        if (this.argv['0'] !== undefined) {
+            repo = this.argv['0'];
+        }
+        // No sudo for get
+        if (process.getuid && process.getuid() === 0) {
+            Utils.warning('You must run: eggs wardrobe get without sudo');
+            process.exit(0);
+        }
+        const wardrobe = basename(repo); // ~/.eggs-wardrobe
+        // git clone -b <branchname> --single-branch
+        // const result = await exec(`git clone -b devel --single-branch --depth 1 ${repo} ${await Utils.wardrobe()}`)
+        const result = await exec(`git clone --single-branch --depth 1 ${repo} ${await Utils.wardrobe()}`);
+        if (result.code === 0) {
+            Utils.warning(`you get new wardrobe from repo: ${repo} in ${await Utils.wardrobe()}`);
+        }
+    }
+}

package/dist/commands/wardrobe/list.d.ts

@@ -0,0 +1,24 @@
+/**
+ * ./src/commands/wardrobe/list.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 List extends Command {
+    static args: {
+        repo: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        distro: 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>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/wardrobe/list.js

@@ -0,0 +1,125 @@
+/**
+ * ./src/commands/wardrobe/list.ts
+ * penguins-eggs v.10.0.0 / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import { Args, Command, Flags } from '@oclif/core';
+// libraries
+import chalk from 'chalk';
+import yaml from 'js-yaml';
+import fs from 'node:fs';
+import path from 'node:path';
+import Distro from '../../classes/distro.js';
+import Utils from '../../classes/utils.js';
+/**
+ *
+ */
+export default class List extends Command {
+    static args = {
+        repo: Args.string({ description: 'wardrobe to get', name: 'wardrobe', required: false })
+    };
+    // static args = [{ name: 'wardrobe', description: 'wardrobe', required: false }]
+    static description = 'list costumes and accessoires in wardrobe';
+    static examples = ['eggs wardrobe list', 'eggs wardrobe list your-wardrobe', 'eggs wardrobe list --distro arch'];
+    static flags = {
+        distro: Flags.string({ char: 'd', description: 'distro' }),
+        help: Flags.help({ char: 'h' }),
+        verbose: Flags.boolean({ char: 'v' })
+    };
+    async run() {
+        const { args, flags } = await this.parse(List);
+        let verbose = false;
+        if (flags.verbose) {
+            verbose = true;
+        }
+        const echo = Utils.setEcho(verbose);
+        Utils.titles(this.id + ' ' + this.argv);
+        /**
+         * wardobe
+         */
+        let wardrobe = await Utils.wardrobe();
+        if (flags.distro === undefined && this.argv['0'] !== undefined) {
+            wardrobe = this.argv['0'];
+        }
+        /**
+         * seleziona distro
+         */
+        let index = '';
+        const distro = new Distro();
+        switch (distro.distroLike) {
+            case 'Arch': {
+                index = 'arch';
+                break;
+            }
+            case 'Debian':
+            case 'Devuan': {
+                index = 'debian';
+                break;
+            }
+            case 'Ubuntu': {
+                index = 'ubuntu';
+                break;
+            }
+            // No default
+        }
+        if (flags.distro !== undefined) {
+            index = flags.distro;
+        }
+        index += '.yml';
+        console.log(chalk.green('wardrobe: ') + wardrobe);
+        console.log();
+        wardrobe = `${path.resolve(process.cwd(), wardrobe)}/`;
+        if (!fs.existsSync(wardrobe)) {
+            Utils.warning(`wardrobe: ${wardrobe} not found!`);
+            process.exit();
+        }
+        /**
+         * costumes
+         */
+        const costumes = fs.readdirSync(`${wardrobe}costumes/`);
+        console.log(chalk.green('costumes: '));
+        for (const costume of costumes) {
+            if (fs.existsSync(`${wardrobe}costumes/${costume}/${index}`)) {
+                const materials = yaml.load(fs.readFileSync(`${wardrobe}costumes/${costume}/${index}`, 'utf8'));
+                console.log('- ' + chalk.cyan(costume) + ': ' + materials.description);
+            }
+        }
+        console.log();
+        /**
+         * accessories
+         */
+        const accessories = fs.readdirSync(`${wardrobe}/accessories/`);
+        console.log(chalk.green('accessories: '));
+        for (const accessory of accessories) {
+            if (fs.existsSync(`${wardrobe}/accessories/${accessory}/${index}`)) {
+                const materials = yaml.load(fs.readFileSync(`${wardrobe}/accessories/${accessory}/${index}`, 'utf8'));
+                console.log('- ' + chalk.cyan(accessory) + ': ' + materials.description);
+            }
+        }
+        console.log();
+        /**
+         * servers
+         */
+        const servers = fs.readdirSync(`${wardrobe}/servers/`);
+        console.log(chalk.green('servers: '));
+        for (const server of servers) {
+            if (fs.existsSync(`${wardrobe}/servers/${server}/${index}`)) {
+                const materials = yaml.load(fs.readFileSync(`${wardrobe}/servers/${server}/${index}`, 'utf8'));
+                console.log('- ' + chalk.cyan(server) + ': ' + materials.description);
+            }
+        }
+        console.log();
+        /**
+         * vendors
+         */
+        const vendors = fs.readdirSync(`${wardrobe}/vendors/`);
+        console.log(chalk.green('vendors/themes: '));
+        for (const vendor of vendors) {
+            if (fs.existsSync(`${wardrobe}/vendors/${vendor}/theme`)) {
+                console.log('- ' + chalk.cyan(vendor));
+            }
+        }
+    }
+}

package/dist/commands/wardrobe/show.d.ts

@@ -0,0 +1,25 @@
+/**
+ * ./src/commands/wardrobe/show.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 Show extends Command {
+    static args: {
+        repo: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static example: string[];
+    static flags: {
+        help: import("@oclif/core/interfaces").BooleanFlag<void>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        wardrobe: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}