penguins-eggs 25.10.28 → 25.11.8

package/dist/classes/incubation/installer.js

@@ -0,0 +1,52 @@
+/**
+ * ./src/classes/incubation/installer.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+/**
+ * installer
+ *
+ * name  = 'calamares' oppure 'krill'
+ * configRoot = '/etc/calamares/' oppure '/etc/penguins-eggs.d/krill/'
+ * modules = configuration + 'modules/'
+ * modulesMultiarch = '/usr/lib/' + arch-linux-gnu + '/' + installer + '/'
+ *
+ * template = '/etc/penguins-eggs/' + .distro.distroUniqueId + '/' + installer + '/'
+ * templateModules = template + '/modules/'
+ * templateMultiarch = template + installer + '-modules/'
+ *
+ */
+import Distro from '../../classes/distro.js';
+import Pacman from '../../classes/pacman.js';
+/**
+ *
+ * @returns
+ */
+export function installer() {
+    const installer = {};
+    // configRoot
+    installer.configRoot = '';
+    if (Pacman.calamaresExists()) {
+        installer.name = 'calamares';
+        installer.configRoot = '/etc/calamares/';
+        installer.multiarch = Pacman.distro().usrLibPath + '/calamares/';
+    }
+    else {
+        installer.name = 'krill';
+        installer.configRoot = '/etc/penguins-eggs.d/krill/';
+        installer.multiarch = Pacman.distro().usrLibPath + '/krill/';
+    }
+    installer.modules = installer.configRoot + 'modules/';
+    installer.multiarchModules = installer.multiarch + 'modules/';
+    /**
+     * i template calamares/krill sono SEMPRE nel folder calamares e calamares-modules
+     *
+     */
+    const distro = new Distro();
+    installer.template = `/etc/penguins-eggs.d/distros/${distro.distroUniqueId}/calamares/`;
+    installer.templateModules = `${installer.template}modules/`;
+    installer.templateMultiarch = `${installer.template}calamares-modules/`;
+    return installer;
+}

package/dist/classes/keyboards.d.ts

@@ -0,0 +1,31 @@
+/**
+ * ./src/classes/keyboards.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti (modified)
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import { IXkbLayout, IXkbModel, IXkbOption, IXkbVariant } from '../interfaces/i-xkb-model.js';
+/**
+ * Keyboard class - reads and manages X11 keyboard configuration
+ */
+export default class Keyboard {
+    layouts: IXkbLayout[];
+    models: IXkbModel[];
+    options: IXkbOption[];
+    variants: IXkbVariant[];
+    private defaultKeyboardFile;
+    private xorgLstFile;
+    constructor();
+    private parseXorgLst;
+    private setDefaults;
+    private readKeyboardConfig;
+    getLayout(): Promise<string>;
+    getLayouts(): IXkbLayout[];
+    getModel(): Promise<string>;
+    getModels(): IXkbModel[];
+    getOption(): Promise<string>;
+    getOptions(): IXkbOption[];
+    getVariant(): Promise<string>;
+    getVariants(layout: string): IXkbVariant[];
+}

package/dist/classes/keyboards.js

@@ -0,0 +1,136 @@
+/**
+ * ./src/classes/keyboards.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti (modified)
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import fs from 'node:fs';
+import { exec } from '../lib/utils.js';
+/**
+ * Keyboard class - reads and manages X11 keyboard configuration
+ */
+export default class Keyboard {
+    layouts = []; // New change #1: store typed objects instead of raw strings
+    models = []; // New change #1
+    options = []; // New change #1
+    variants = []; // New change #1
+    defaultKeyboardFile = '/etc/default/keyboard'; // New change #2: store default keyboard file path
+    xorgLstFile = '/usr/share/X11/xkb/rules/xorg.lst';
+    constructor() {
+        // New change #3: Use a safer approach to read xorg.lst
+        if (fs.existsSync(this.xorgLstFile)) {
+            const content = fs.readFileSync(this.xorgLstFile, 'utf8');
+            this.parseXorgLst(content);
+        }
+        else {
+            this.setDefaults();
+        }
+    }
+    // New change #4: parse xorg.lst with regex instead of fixed slicing
+    parseXorgLst(content) {
+        const sections = ['model', 'layout', 'variant', 'option'];
+        let currentSection = null;
+        content.split('\n').forEach(line => {
+            line = line.trim();
+            if (!line)
+                return;
+            if (line.startsWith('!')) {
+                const sectionName = line.slice(2).toLowerCase();
+                if (sections.includes(sectionName)) {
+                    currentSection = sectionName;
+                }
+                else {
+                    currentSection = null;
+                }
+                return;
+            }
+            if (!currentSection)
+                return;
+            // Separate code and description with regex
+            const match = line.match(/^(\S+)\s+(.*)$/);
+            if (!match)
+                return;
+            const [_, code, description] = match;
+            const desc = description || '';
+            switch (currentSection) {
+                case 'model':
+                    this.models.push({ code, description: desc });
+                    break;
+                case 'layout':
+                    this.layouts.push({ code, description: desc });
+                    break;
+                case 'variant':
+                    // Extract language if possible
+                    const langMatch = desc.match(/^(\S+):\s*(.*)$/);
+                    this.variants.push({
+                        code,
+                        lang: langMatch ? langMatch[1] : '',
+                        description: langMatch ? langMatch[2] : desc
+                    });
+                    break;
+                case 'option':
+                    this.options.push({ code, description: desc });
+                    break;
+            }
+        });
+    }
+    // New change #5: set default keyboard data if xorg.lst not found
+    setDefaults() {
+        this.models.push({ code: 'pc105', description: 'Generic 105-key PC' });
+        const defaultLayouts = ['us', 'fr', 'de', 'gb', 'es', 'it', 'ru', 'jp']; // shortened for example
+        defaultLayouts.forEach(l => this.layouts.push({ code: l, description: '' }));
+        this.variants.push({ code: 'none', lang: '', description: 'none' });
+        this.options.push({ code: 'none', description: 'none' });
+    }
+    // New change #6: read keyboard configuration from file safely
+    async readKeyboardConfig(variable) {
+        if (!fs.existsSync(this.defaultKeyboardFile))
+            return '';
+        try {
+            const cmd = `grep ^${variable}= ${this.defaultKeyboardFile} | cut -d= -f2 | tr -d '"'`;
+            const result = await exec(cmd, { capture: true, echo: false, ignore: false });
+            if (result.code === 0) {
+                return result.data.trim();
+            }
+            return '';
+        }
+        catch {
+            return '';
+        }
+    }
+    // Get current layout
+    async getLayout() {
+        const layout = await this.readKeyboardConfig('XKBLAYOUT');
+        return layout || 'us';
+    }
+    // Get all layouts
+    getLayouts() {
+        return this.layouts;
+    }
+    // Get current model
+    async getModel() {
+        const model = await this.readKeyboardConfig('XKBMODEL');
+        return model || 'pc105';
+    }
+    // Get all models
+    getModels() {
+        return this.models;
+    }
+    // Get current option
+    async getOption() {
+        return await this.readKeyboardConfig('XKBOPTIONS');
+    }
+    // Get all options
+    getOptions() {
+        return this.options;
+    }
+    // Get current variant
+    async getVariant() {
+        return await this.readKeyboardConfig('XKBVARIANT');
+    }
+    // Get variants for a specific layout
+    getVariants(layout) {
+        return this.variants.filter(v => v.lang === layout);
+    }
+}

package/dist/classes/locales.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ./src/classes/locales.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+export default class Locales {
+    /**
+     *
+     */
+    getDefault(): Promise<string>;
+    /**
+     * getSupported
+     */
+    getSupported(): Promise<string[]>;
+    /**
+     * getEnabled
+     */
+    getEnabled(): Promise<string[]>;
+}

package/dist/classes/locales.js

@@ -0,0 +1,77 @@
+/**
+ * ./src/classes/locales.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import fs from 'node:fs';
+import { exec } from '../lib/utils.js';
+import Distro from './distro.js';
+import Utils from './utils.js';
+export default class Locales {
+    /**
+     *
+     */
+    async getDefault() {
+        const cmd = `locale|grep LANG|cut -f2 -d=`;
+        let defaultLanguage = 'en_US.UTF-8';
+        const result = await exec(cmd, { capture: true, echo: false, ignore: false });
+        if (result.code === 0) {
+            defaultLanguage = result.data.trim();
+        }
+        return defaultLanguage;
+    }
+    /**
+     * getSupported
+     */
+    async getSupported() {
+        const distro = new Distro();
+        let supporteds = [];
+        switch (distro.familyId) {
+            case 'alpine': {
+                supporteds = await this.getEnabled();
+                break;
+            }
+            case 'archlinux': {
+                supporteds = await this.getEnabled();
+                break;
+            }
+            case 'debian': {
+                supporteds = fs.readFileSync('/usr/share/i18n/SUPPORTED', 'utf8').split('\n');
+                break;
+            }
+            case 'fedora': {
+                supporteds = await this.getEnabled();
+                break;
+            }
+            case 'opensuse': {
+                supporteds = await this.getEnabled();
+                break;
+            }
+        }
+        const elements = [];
+        for (const elem of supporteds) {
+            elements.push(elem.replace(' UTF-8', ''));
+        }
+        return elements;
+    }
+    /**
+     * getEnabled
+     */
+    async getEnabled() {
+        let cmd = "locale -a";
+        if (Utils.isSystemd()) {
+            cmd = "localectl list-locales";
+        }
+        const enabledLocales = [];
+        const result = await exec(cmd, { capture: true, echo: false, ignore: false });
+        if (result.code === 0) {
+            const lines = result.data.split('\n');
+            for (const line of lines) {
+                enabledLocales.push(line.trim());
+            }
+        }
+        return enabledLocales;
+    }
+}

package/dist/classes/network.d.ts

@@ -0,0 +1,37 @@
+/**
+ * ./src/classes/network.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import { Netmask } from 'netmask';
+/**
+ *
+ */
+export default class Network {
+    address: string;
+    cidr: string;
+    family: string;
+    internal: boolean;
+    mac: string;
+    netmask: string;
+    o: Netmask;
+    /**
+     *
+     */
+    constructor();
+    base(): string;
+    bitmask(): void;
+    broadcast(): string;
+    contains(): (address: string | Netmask | number) => boolean;
+    first(): string;
+    forEach(): (cb: (ip: string, long: number, index: number) => void) => void;
+    hostmask(): string;
+    last(): string;
+    maskLong(): number;
+    netLong(): number;
+    next(): (count?: number) => Netmask;
+    size(): number;
+    toString(): () => string;
+}

package/dist/classes/network.js

@@ -0,0 +1,98 @@
+/**
+ * ./src/classes/network.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import { Netmask } from 'netmask';
+import os from 'node:os';
+/**
+ *
+ */
+export default class Network {
+    address = '';
+    cidr = '';
+    family = '';
+    internal = false;
+    mac = '';
+    netmask = '';
+    o = {};
+    /**
+     *
+     */
+    constructor() {
+        const interfaces = os.networkInterfaces();
+        const address = '';
+        if (interfaces !== undefined) {
+            for (const devName in interfaces) {
+                const iface = interfaces[devName];
+                if (iface !== undefined) {
+                    for (const alias of iface) {
+                        if (alias.family === 'IPv4' && alias.address !== '127.0.0.1' && !alias.internal) {
+                            // take just the first!
+                            if (this.address === '') {
+                                this.address = alias.address;
+                            }
+                            if (this.cidr === '' && alias.cidr !== null) {
+                                this.cidr = alias.cidr;
+                            }
+                            if (this.family === '') {
+                                this.family = alias.family;
+                            }
+                            if (this.mac === '') {
+                                this.mac = alias.mac;
+                            }
+                            if (this.netmask === '') {
+                                this.netmask = alias.netmask;
+                            }
+                        }
+                    }
+                }
+            }
+            /**
+             * valori da netmask
+             */
+            this.o = new Netmask(this.cidr);
+        }
+    }
+    base() {
+        return this.o.base;
+    }
+    bitmask() {
+        this.o.bitmask;
+    }
+    broadcast() {
+        return this.o.broadcast;
+    }
+    contains() {
+        return this.o.contains;
+    }
+    first() {
+        return this.o.first;
+    }
+    forEach() {
+        return this.o.forEach;
+    }
+    hostmask() {
+        return this.o.hostmask;
+    }
+    last() {
+        return this.o.last;
+    }
+    maskLong() {
+        return this.o.maskLong;
+    }
+    netLong() {
+        return this.o.netLong;
+    }
+    next() {
+        return this.o.next;
+    }
+    size() {
+        return this.o.size;
+    }
+    toString() {
+        return this.o.toString;
+    }
+}

package/dist/classes/ovary.d/bind-live-fs.d.ts

@@ -0,0 +1,18 @@
+/**
+ * ./src/classes/ovary.d/bind-live-fs.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import Ovary from '../ovary.js';
+/**
+ * Esegue il bind del filesystem live e
+ * crea lo script bind
+ */
+export declare function bindLiveFs(this: Ovary): Promise<void>;
+/**
+ * ubind del fs live
+ * @param verbose
+ */
+export declare function uBindLiveFs(this: Ovary): Promise<void>;

package/dist/classes/ovary.d/bind-live-fs.js

@@ -0,0 +1,185 @@
+/**
+ * ./src/classes/ovary.d/bind-live-fs.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+// packages
+import fs from 'fs';
+import path from 'node:path';
+import os from 'os';
+// classes
+import { exec } from '../../lib/utils.js';
+import Utils from '../utils.js';
+// functions
+import rexec from './rexec.js';
+// _dirname
+const __dirname = path.dirname(new URL(import.meta.url).pathname);
+/**
+ * Esegue il bind del filesystem live e
+ * crea lo script bind
+ */
+export async function bindLiveFs() {
+    if (this.verbose) {
+        console.log('Ovary: bindLiveFs');
+    }
+    /**
+     * dirs = readdirsync /
+     */
+    const dirs = fs.readdirSync('/');
+    const startLine = '#############################################################';
+    const endLine = '#\n';
+    let lnkDest = '';
+    let cmd = '';
+    const cmds = [];
+    cmds.push('# NOTE: cdrom, dev, live, media, mnt, proc, run, sys and tmp', `#       need just a mkdir in ${this.settings.work_dir.merged}`);
+    cmds.push(`# host: ${os.hostname()} user: ${await Utils.getPrimaryUser()}\n`);
+    for (const dir of dirs) {
+        cmds.push(startLine);
+        let statDir = fs.lstatSync(`/${dir}`);
+        if (statDir.isSymbolicLink()) {
+            /**
+             * Link
+             */
+            cmds.push(`# /${dir} is a symbolic link to /${lnkDest}`);
+            lnkDest = fs.readlinkSync(`/${dir}`);
+            if (fs.existsSync(`${this.settings.work_dir.merged}/${dir}`)) {
+                cmds.push('# SymbolicLink exist... skip');
+            }
+            else if (fs.existsSync(lnkDest)) {
+                cmds.push(`ln -s ${this.settings.work_dir.merged}/${lnkDest} ${this.settings.work_dir.merged}/${lnkDest}`);
+            }
+            else {
+                cmds.push(await rexec(`cp -r /${dir} ${this.settings.work_dir.merged}`, this.verbose));
+            }
+        }
+        else if (statDir.isDirectory()) {
+            /**
+             * Directory
+             */
+            cmds.push(`# /${dir} is a directory`);
+            if (dir !== 'ci' && dir !== 'lost+found') {
+                if (this.copied(dir)) {
+                    cmds.push(`# /${dir} is copied if not exists on filesystem.squashfs`);
+                    let chkDir = path.join(this.settings.config.snapshot_mnt, 'filesystem.squashfs', dir);
+                    cmds.push(`if ! [ -d "${chkDir}" ]; then`);
+                    cmds.push(await rexec(`   cp -a /${dir} ${this.settings.config.snapshot_mnt}filesystem.squashfs`, this.verbose));
+                    cmds.push(`fi`);
+                    continue;
+                }
+                else if (this.mergedAndOverlay(dir)) {
+                    cmds.push(`# /${dir} mergedAndOverlay (rw)\n`, '# create mountpoint lower');
+                    cmds.push(await makeIfNotExist(`${this.settings.work_dir.lowerdir}/${dir}`), `# first: mount /${dir} rw in ${this.settings.work_dir.lowerdir}/${dir}`);
+                    cmds.push(await rexec(`mount --bind --make-slave /${dir} ${this.settings.work_dir.lowerdir}/${dir}`, this.verbose), '# now remount it ro');
+                    cmds.push(await rexec(`mount -o remount,bind,ro ${this.settings.work_dir.lowerdir}/${dir}`, this.verbose), `\n# second: create mountpoint upper, work and ${this.settings.work_dir.merged} and mount ${dir}`);
+                    cmds.push(await makeIfNotExist(`${this.settings.work_dir.upperdir}/${dir}`, this.verbose));
+                    cmds.push(await makeIfNotExist(`${this.settings.work_dir.workdir}/${dir}`, this.verbose));
+                    cmds.push(await makeIfNotExist(`${this.settings.work_dir.merged}/${dir}`, this.verbose), `\n# thirth: mount /${dir} rw in ${this.settings.work_dir.merged}`);
+                    cmds.push(await rexec(`mount -t overlay overlay -o lowerdir=${this.settings.work_dir.lowerdir}/${dir},upperdir=${this.settings.work_dir.upperdir}/${dir},workdir=${this.settings.work_dir.workdir}/${dir} ${this.settings.work_dir.merged}/${dir}`, this.verbose));
+                }
+                else if (this.merged(dir)) {
+                    cmds.push(`# /${dir} merged (ro)`);
+                    cmds.push(await makeIfNotExist(`${this.settings.work_dir.merged}/${dir}`, this.verbose));
+                    cmds.push(await rexec(`mount --bind --make-slave /${dir} ${this.settings.work_dir.merged}/${dir}`, this.verbose));
+                    cmds.push(await rexec(`mount -o remount,bind,ro ${this.settings.work_dir.merged}/${dir}`, this.verbose));
+                }
+                else {
+                    cmds.push(`# /${dir} just created`);
+                    cmds.push(await makeIfNotExist(`${this.settings.work_dir.merged}/${dir}`, this.verbose));
+                }
+            }
+            /**
+           * File
+           */
+        }
+        else if (statDir.isFile()) {
+            cmds.push(`# /${dir} is just a file`);
+            if (fs.existsSync(`${this.settings.work_dir.merged}/${dir}`)) {
+                cmds.push('# file exist... skip');
+            }
+            else {
+                cmds.push(await rexec(`cp -p /${dir} ${this.settings.work_dir.merged}`, this.verbose));
+            }
+        }
+        cmds.push(endLine);
+    }
+    // Utils.writeXs(`${this.settings.config.snapshot_dir}bind`, cmds)
+    Utils.writeXs(`${this.settings.work_dir.ovarium}bind`, cmds);
+}
+/**
+ * ubind del fs live
+ * @param verbose
+ */
+export async function uBindLiveFs() {
+    if (this.verbose) {
+        console.log('Ovary: uBindLiveFs');
+    }
+    const startLine = '#############################################################';
+    const endLine = '#\n';
+    const cmds = [];
+    cmds.push('# NOTE: home, cdrom, dev, live, media, mnt, proc, run, sys and tmp', `#       need just to be removed in ${this.settings.work_dir.merged}`);
+    cmds.push(`# host: ${os.hostname()} user: ${await Utils.getPrimaryUser()}\n`);
+    if (fs.existsSync(this.settings.work_dir.merged)) {
+        const bindDirs = fs.readdirSync(this.settings.work_dir.merged, {
+            withFileTypes: true
+        });
+        for (const dir of bindDirs) {
+            const dirname = dir.name;
+            cmds.push(startLine);
+            if (fs.statSync(`/${dirname}`).isDirectory()) {
+                cmds.push(`\n# directory: ${dirname}`);
+                if (this.copied(dirname)) {
+                    cmds.push(`\n# ${dirname} was copied, do nothings`);
+                    continue;
+                }
+                else if (this.mergedAndOverlay(dirname)) {
+                    cmds.push(`\n# ${dirname} has overlay`, `\n# First, umount it from ${this.settings.config.snapshot_dir}`);
+                    cmds.push(await rexec(`umount ${this.settings.work_dir.merged}/${dirname}`, this.verbose), `\n# Second, umount it from ${this.settings.work_dir.lowerdir}`);
+                    cmds.push(await rexec(`umount ${this.settings.work_dir.lowerdir}/${dirname}`, this.verbose));
+                }
+                else if (this.merged(dirname)) {
+                    cmds.push(await rexec(`umount ${this.settings.work_dir.merged}/${dirname}`, this.verbose));
+                }
+                cmds.push(`\n# remove in ${this.settings.work_dir.merged} and ${this.settings.work_dir.lowerdir}`);
+                /**
+                 * We can't remove the nest!!!
+                 */
+                const nest = this.settings.config.snapshot_dir.split('/');
+                // We can't remove first level nest
+                if (dirname !== nest[1]) {
+                    cmds.push(await rexec(`rm -rf ${this.settings.work_dir.merged}/${dirname}`, this.verbose));
+                }
+            }
+            else if (fs.statSync(`/${dirname}`).isFile()) {
+                cmds.push(`\n# ${dirname} = file`);
+                cmds.push(await rexec(`rm -f ${this.settings.work_dir.merged}/${dirname}`, this.verbose));
+            }
+            else if (fs.statSync(`/${dirname}`).isSymbolicLink()) {
+                cmds.push(`\n# ${dirname} = symbolicLink`);
+                cmds.push(await rexec(`rm -f ${this.settings.work_dir.merged}/${dirname}`, this.verbose));
+            }
+        }
+    }
+    if (this.clone || this.fullcrypt) {
+        cmds.push(await rexec(`umount ${this.settings.work_dir.merged}/home`, this.verbose));
+    }
+    // Utils.writeXs(`${this.settings.config.snapshot_dir}ubind`, cmds)
+    Utils.writeXs(`${this.settings.work_dir.ovarium}ubind`, cmds);
+}
+/**
+* Crea il path se non esiste
+* @param path
+*/
+async function makeIfNotExist(path, verbose = false) {
+    if (verbose) {
+        console.log(`Ovary: makeIfNotExist(${path})`);
+    }
+    const echo = Utils.setEcho(verbose);
+    let cmd = `# ${path} alreasy exist`;
+    if (!fs.existsSync(path)) {
+        cmd = `mkdir ${path} -p`;
+        await exec(cmd, echo);
+    }
+    return cmd;
+}

package/dist/classes/ovary.d/bind-vfs.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ./src/classes/ovary.d/bind-live-fs.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import Ovary from '../ovary.js';
+/**
+   * bind dei virtual file system
+   */
+export declare function bindVfs(this: Ovary): Promise<void>;
+/**
+ *
+ * @param verbose
+ */
+export declare function ubindVfs(this: Ovary): Promise<void>;