penguins-eggs 25.10.28 → 25.10.30

package/dist/classes/incubation/customize/customize-partitions.js

@@ -0,0 +1,37 @@
+/**
+ * ./src/classes/incubation/customize/customize-partitions.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 Pacman from '../../pacman.js';
+import yaml from 'js-yaml';
+import { exec } from '../../../lib/utils.js';
+/**
+ * customize module partition
+ * add/remove filesystem available
+ */
+export async function customizePartitions() {
+    const filePartition = '/etc/calamares/modules/partition.conf';
+    const partition = yaml.load(fs.readFileSync(filePartition, 'utf8'));
+    // detect filesystem type
+    let test = await exec(`df -T / | awk 'NR==2 {print $2}'`, { capture: true, echo: false });
+    partition.defaultFileSystemType = test.data.trim();
+    /**
+     * Determino i filesystem disponibili
+     */
+    partition.availableFileSystemTypes = ['ext4'];
+    if (Pacman.packageIsInstalled('progs') ||
+        Pacman.packageIsInstalled('btrfsprogs')) {
+        partition.availableFileSystemTypes.push('btrfs');
+    }
+    if (Pacman.packageIsInstalled('xfsprogs')) {
+        partition.availableFileSystemTypes.push('xfs');
+    }
+    if (Pacman.packageIsInstalled('f2fs-tools')) {
+        partition.availableFileSystemTypes.push('f2fs');
+    }
+    fs.writeFileSync(filePartition, yaml.dump(partition), 'utf-8');
+}

package/dist/classes/incubation/fisherman-helper/initcpio.d.ts

@@ -0,0 +1 @@
+export declare function initcpio(): Promise<string>;

package/dist/classes/incubation/fisherman-helper/initcpio.js

@@ -0,0 +1,69 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { access } from 'fs/promises';
+const execAsync = promisify(exec);
+export async function initcpio() {
+    try {
+        const { stdout: kernelVersion } = await execAsync('uname -r');
+        const version = kernelVersion.trim();
+        // Manjaro
+        if (version.includes('MANJARO')) {
+            try {
+                // Estrai major e minor version. Es: da "6.12.48-1-MANJARO" -> ["6", "12", "48-1-MANJARO"]
+                const parts = version.split('.');
+                // Costruisci il nome del preset come "linux" + "6" + "12" -> "linux612"
+                const kernelName = `linux${parts[0]}${parts[1]}`;
+                const manjaroPreset = `/etc/mkinitcpio.d/${kernelName}.preset`;
+                await access(manjaroPreset); // Verifica se esiste /etc/mkinitcpio.d/linux612.preset
+                return manjaroPreset; // Se esiste, lo restituisce e la funzione termina
+            }
+            catch {
+                // Se anche questa logica fallisce, lascia che proceda al fallback per Arch
+                // console.warn('Logica Manjaro fallita, si tenta il fallback per Arch...');
+            }
+        }
+        else if (version.includes('cachyos')) {
+            try {
+                let kernelType = 'linux-cachyos'; // default
+                if (version.includes('lts')) {
+                    kernelType = 'linux-cachyos-lts';
+                }
+                else if (version.includes('zen')) {
+                    kernelType = 'linux-cachyos-zen';
+                }
+                else if (version.includes('hardened')) {
+                    kernelType = 'linux-hardened';
+                }
+                const cachyPreset = `/etc/mkinitcpio.d/${kernelType}.preset`;
+                await access(cachyPreset);
+                return cachyPreset;
+            }
+            catch {
+                // Se anche questa logica fallisce, lascia che proceda al fallback per Arch
+                // console.warn('Logica Manjaro fallita, si tenta il fallback per Arch...');
+            }
+        }
+        /**
+         * FALLBACK ARCH
+         */
+        // Determina il tipo di kernel
+        let kernelType = 'linux'; // default
+        if (version.includes('lts')) {
+            kernelType = 'linux-lts';
+        }
+        else if (version.includes('zen')) {
+            kernelType = 'linux-zen';
+        }
+        else if (version.includes('hardened')) {
+            kernelType = 'linux-hardened';
+        }
+        const archPreset = `/etc/mkinitcpio.d/${kernelType}.preset`;
+        // Verifica che esista
+        await access(archPreset);
+        return archPreset;
+    }
+    catch (error) {
+        // Rimuoviamo l'errore originale dalla stringa per un messaggio più pulito
+        throw new Error(`Impossibile trovare un file .preset valido in /etc/mkinitcpio.d/`);
+    }
+}

package/dist/classes/incubation/fisherman-helper/packages.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ./src/classes/incubation/fisherman-helper/packages.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import { IDistro } from '../../../interfaces/index.js';
+/**
+ *
+ * @param distro
+ * @returns yaml-string
+ */
+export declare function remove(distro: IDistro): string;
+/**
+ *
+ * @param distro
+ * @returns yaml-string
+ */
+export declare function tryInstall(distro: IDistro): string;

package/dist/classes/incubation/fisherman-helper/packages.js

@@ -0,0 +1,72 @@
+/**
+ * ./src/classes/incubation/fisherman-helper/packages.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import Pacman from '../../pacman.js';
+/**
+ *
+ * @param distro
+ * @returns yaml-string
+ */
+export function remove(distro) {
+    const packages = ['calamares-eggs', 'calamares'];
+    if (distro.familyId === 'archlinux') {
+        packages.push('penguins-eggs');
+    }
+    if (distro.familyId === 'debian') {
+        packages.push('penguins-eggs', 'live-boot', 'live-boot-doc', 'live-boot-initramfs-tools', 'live-tools');
+    }
+    const installedPackages = [];
+    for (const elem of packages) {
+        if (Pacman.packageIsInstalled(elem)) {
+            installedPackages.push(elem);
+        }
+    }
+    installedPackages.sort();
+    let yaml = '';
+    for (const elem of installedPackages) {
+        yaml += `  - ${elem.trim()}\n`;
+    }
+    if (yaml !== '') {
+        yaml = '- try_remove:\n' + yaml;
+    }
+    return yaml;
+}
+/**
+ *
+ * @param distro
+ * @returns yaml-string
+ */
+export function tryInstall(distro) {
+    let yaml = '';
+    /**
+     * Depending on the distro
+     */
+    if (distro.distroLike === 'Ubuntu') {
+        yaml += '  - language-pack-$LOCALE\n';
+    }
+    // Da localizzare se presenti
+    if (Pacman.packageIsInstalled('hunspell')) {
+        yaml += '  - hunspell-$LOCALE\n';
+    }
+    if (Pacman.packageIsInstalled('libreoffice-base-core')) {
+        yaml += '  - libreoffice-l10n-$LOCALE\n';
+        yaml += '  - libreoffice-help-$LOCALE\n';
+    }
+    if (Pacman.packageIsInstalled('firefox-esr')) {
+        yaml += '  - firefox-esr-$LOCALE\n';
+    }
+    if (Pacman.packageIsInstalled('firefox')) {
+        yaml += '  - firefox-$LOCALE\n';
+    }
+    if (Pacman.packageIsInstalled('thunderbird')) {
+        yaml += '  - thunderbird-locale-$LOCALE\n';
+    }
+    if (yaml !== '') {
+        yaml = '- try_install:\n' + yaml;
+    }
+    return yaml;
+}

package/dist/classes/incubation/fisherman-helper/settings.d.ts

@@ -0,0 +1,15 @@
+/**
+ * ./src/classes/incubation/fisherman-helper/settings.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+/**
+ *
+ * @param src
+ * @param dest
+ * @param theme
+ * @param isClone
+ */
+export declare function settings(src: string, dest: string, theme?: string, isClone?: boolean): Promise<void>;

package/dist/classes/incubation/fisherman-helper/settings.js

@@ -0,0 +1,116 @@
+/**
+ * ./src/classes/incubation/fisherman-helper/settings.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+/**
+ *
+ * @param theme
+ * @param isClone
+ */
+import yaml from 'js-yaml';
+import fs from 'node:fs';
+import shx from 'shelljs';
+import Utils from '../../utils.js';
+import { installer } from '../installer.js';
+/**
+ *
+ * @param src
+ * @param dest
+ * @param theme
+ * @param isClone
+ */
+export async function settings(src, dest, theme = 'eggs', isClone = false) {
+    let branding = theme;
+    const settingsSrc = src + 'settings.yml';
+    if (theme.includes('/')) {
+        branding = theme.slice(Math.max(0, theme.lastIndexOf('/') + 1));
+    }
+    const settingsDest = dest + 'settings.conf';
+    const contentSrc = fs.readFileSync(settingsSrc, "utf-8");
+    const yamlDest = yaml.load(contentSrc);
+    // Trova gli elementi in modo sicuro
+    const showSequenceItem = yamlDest.sequence.find(item => item.show);
+    const execSequenceItem = yamlDest.sequence.find(item => item.exec);
+    if (!showSequenceItem || !execSequenceItem) {
+        throw new Error("Impossibile trovare le sezioni 'show' o 'exec' nel file settings.yml");
+    }
+    // Il '!' dice a TS: "sono sicuro che non è undefined"
+    let showModules = showSequenceItem.show;
+    let execModules = execSequenceItem.exec;
+    // Filtra la lista (ora con type safety)
+    if (!Utils.isSystemd()) {
+        execModules = execModules.filter(module => module !== 'machineid' && module !== 'services-systemd');
+    }
+    // if (displaymanager()) {
+    //   execModules = execModules.filter(module => module !== 'displaymanager')
+    // }
+    if (isClone) {
+        execModules = execModules.filter(module => module !== 'users');
+        showModules = showModules.filter(module => module !== 'users');
+    }
+    // Riassegna gli array
+    showSequenceItem.show = showModules;
+    execSequenceItem.exec = execModules;
+    yamlDest.branding = branding;
+    const contentDeest = yaml.dump(yamlDest);
+    fs.writeFileSync(settingsDest, contentDeest);
+    /*
+    shx.cp(settingsSrc, settingsDest)
+    let hasSystemd = '# '
+    if (Utils.isSystemd()) {
+      hasSystemd = '- '
+    }
+  
+    let createUsers = '- '
+    if (isClone) {
+      createUsers = '# '
+    }
+  
+    let hasDisplaymanager = '# '
+    if (displaymanager().length > 0) {
+      hasDisplaymanager = '- '
+    }
+  
+    shx.sed('-i', '{{hasSystemd}}', hasSystemd, settingsDest)
+    shx.sed('-i', '{{hasDisplaymanager}}', hasDisplaymanager, settingsDest)
+    shx.sed('-i', '{{branding}}', branding, settingsDest)
+    shx.sed('-i', '{{createUsers}}', createUsers, settingsDest)
+  
+    */
+    /**
+     * cfsAppend
+     */
+    const cfsPath = `${theme}/theme/calamares/cfs.yml`;
+    if (fs.existsSync(cfsPath)) {
+        cfsAppend(cfsPath);
+    }
+}
+/**
+ *
+ */
+function cfsAppend(cfs) {
+    const configRoot = installer().configRoot + 'settings.conf';
+    const soContent = fs.readFileSync(configRoot, 'utf8');
+    const so = yaml.load(soContent);
+    const cfsContent = fs.readFileSync(cfs, 'utf8');
+    const cfsSteps = yaml.load(cfsContent);
+    const execSteps = so.sequence[1].exec;
+    for (const execStep of execSteps) {
+        if (execStep.includes('umount')) {
+            so.sequence[1].exec.pop(); // OK remove umount
+            /**
+             * insert cfsStep
+             */
+            for (const cfsStep of cfsSteps) {
+                so.sequence[1].exec.push(cfsStep);
+            }
+            so.sequence[1].exec.push('end-cfs'); // we will replace with umount
+        }
+    }
+    // ***
+    fs.writeFileSync(configRoot, yaml.dump(so), 'utf-8');
+    shx.sed('-i', 'end-cfs', 'umount', configRoot);
+}

package/dist/classes/incubation/fisherman.d.ts

@@ -0,0 +1,71 @@
+import { IDistro, IInstaller } from '../../interfaces/index.js';
+export default class Fisherman {
+    distro: IDistro;
+    installer: IInstaller;
+    verbose: boolean;
+    constructor(distro: IDistro, installer: IInstaller, verbose?: boolean);
+    /**
+     *
+     * @param name
+     * @param isScript
+     */
+    buildCalamaresModule(name: string, isScript?: boolean, theme?: string): Promise<string>;
+    /**
+     *
+     * @param name
+     */
+    buildCalamaresPy(name: string): Promise<void>;
+    /**
+     *
+     * @param name
+     * @param replaces [['search','replace']]
+     */
+    buildModule(name: string, vendor?: string): Promise<void>;
+    /**
+     *
+     * @param name
+     */
+    contextualprocess(name: string): Promise<void>;
+    /**
+     * write settings
+     */
+    createCalamaresSettings(theme?: string, isClone?: boolean): Promise<void>;
+    /**
+     *
+     * @param name
+     */
+    shellprocess(name: string): Promise<void>;
+    /**
+     *
+     * @param module
+     * @param type
+     * @param path
+     */
+    show(name: string, type: string, path: string): void;
+    /**
+    * ====================================================================================
+    * buildModule...
+    * ====================================================================================
+    */
+    /**
+     * buildModuleDracut
+     */
+    buildModuleDracut(initrd: string): Promise<void>;
+    buildModuleInitcpio(): Promise<void>;
+    /**
+     * buildModuleFinished
+     */
+    buildModuleFinished(): Promise<void>;
+    /**
+     * buildModulePackages
+     */
+    buildModulePackages(distro: IDistro, release?: boolean): Promise<void>;
+    /**
+     * buildModuleRemoveuser
+     */
+    buildModuleRemoveuser(username: string): Promise<void>;
+    /**
+     * buildModuleUnpackfs
+     */
+    buildModuleUnpackfs(): Promise<void>;
+}

package/dist/classes/incubation/fisherman.js

@@ -0,0 +1,281 @@
+/**
+ * ./src/classes/incubation/fisherman.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import chalk from 'chalk';
+import mustache from 'mustache';
+import fs from 'node:fs';
+import path from 'node:path';
+import shx from 'shelljs';
+import yaml from 'js-yaml';
+import { exec } from '../../lib/utils.js';
+import { settings } from './fisherman-helper/settings.js';
+// _dirname
+const __dirname = path.dirname(new URL(import.meta.url).pathname);
+// pjson
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const pjson = require('../../../package.json');
+import { remove as removePackages, tryInstall } from './fisherman-helper/packages.js';
+export default class Fisherman {
+    distro;
+    installer = {};
+    verbose = false;
+    constructor(distro, installer, verbose = false) {
+        this.distro = distro;
+        this.installer = installer;
+        this.verbose = verbose;
+    }
+    /**
+     *
+     * @param name
+     * @param isScript
+     */
+    async buildCalamaresModule(name, isScript = true, theme = 'eggs') {
+        let moduleTemplate = path.resolve(__dirname, this.installer.templateMultiarch + name);
+        if (theme !== 'eggs') {
+            moduleTemplate = theme + '/theme/calamares/calamares-modules/' + name;
+        }
+        const moduleDest = this.installer.multiarchModules + name;
+        const moduleScript = `/usr/sbin/${name}.sh`;
+        if (this.verbose)
+            this.show(name, 'module', moduleDest);
+        if (!fs.existsSync(moduleDest)) {
+            fs.mkdirSync(moduleDest);
+        }
+        shx.cp(`${moduleTemplate}/module.yml`, `${moduleDest}/module.desc`);
+        if (isScript) {
+            shx.cp(`${moduleTemplate}/${name}.sh`, moduleScript);
+            await exec(`chmod +x ${moduleScript}`);
+        }
+        return moduleScript;
+    }
+    /**
+     *
+     * @param name
+     */
+    async buildCalamaresPy(name) {
+        const moduleSource = path.resolve(__dirname, this.installer.templateMultiarch + '/' + name);
+        const moduleDest = this.installer.multiarchModules + name;
+        if (this.verbose)
+            this.show(name, 'python', moduleDest);
+        if (!fs.existsSync(moduleDest)) {
+            fs.mkdirSync(moduleDest);
+        }
+        shx.cp(`${moduleSource}/module.yml`, `${moduleDest}/module.desc`);
+        shx.cp(`${moduleSource}/${name}.yml`, `${moduleDest}/${name}.conf`);
+        shx.cp(`${moduleSource}/main.py`, moduleDest);
+        await exec(`chmod +x ${moduleSource}/main.py`);
+    }
+    /**
+     *
+     * @param name
+     * @param replaces [['search','replace']]
+     */
+    async buildModule(name, vendor = 'eggs') {
+        let moduleSource = path.resolve(__dirname, this.installer.templateModules + name + '.yml');
+        /**
+         * We need vendor here to have possibility to load custom modules for calamares
+         * the custom modules live in: /addons/vendor/theme/calamares/modules
+         * and - if exist - take priority on distro modules on /conf/distros/calamares/modules
+         *
+         * example:
+         *
+         * ./addons/openos/theme/calamares/modules/partition.yml
+         * take place of:
+         * ./conf/distros/bullseye/calamares/modules/partition.yml
+         * and end in:
+         * /etc/calamares/modules/partition.conf
+         *
+         * And we solve the issue of Sebastien who need btrfs
+         *
+         */
+        if (vendor !== 'eggs') {
+            let customModuleSource = path.resolve(__dirname, `../../../addons/${vendor}/theme/calamares/modules/${name}.yml`);
+            if (vendor.includes('/')) {
+                customModuleSource = `${vendor}/theme/calamares/modules/${name}.yml`;
+            }
+            if (fs.existsSync(customModuleSource)) {
+                moduleSource = customModuleSource;
+            }
+        }
+        let moduleDest = this.installer.modules + name + '.conf';
+        if (fs.existsSync(moduleSource)) {
+            shx.cp(moduleSource, moduleDest);
+            if (this.verbose) {
+                this.show(name, 'module', moduleDest);
+            }
+        }
+        else if (this.verbose) {
+            console.log('unchanged: ' + chalk.greenBright(name));
+        }
+    }
+    /**
+     *
+     * @param name
+     */
+    async contextualprocess(name) {
+        const moduleSource = path.resolve(__dirname, this.installer.templateModules + name + '_context.yml');
+        const moduleDest = this.installer.modules + name + '_context.conf';
+        if (fs.existsSync(moduleSource)) {
+            if (this.verbose)
+                this.show(name, 'contextualprocess', moduleDest);
+            shx.cp(moduleSource, moduleDest);
+        }
+        else if (this.verbose) {
+            console.log(`calamares: ${name} contextualprocess, nothing to do!`);
+        }
+    }
+    /**
+     * write settings
+     */
+    async createCalamaresSettings(theme = 'eggs', isClone = false) {
+        await settings(this.installer.template, this.installer.configRoot, theme, isClone);
+    }
+    /**
+     *
+     * @param name
+     */
+    async shellprocess(name) {
+        const moduleSource = path.resolve(__dirname, this.installer.templateModules + 'shellprocess@' + name + '.yml');
+        const moduleDest = this.installer.modules + 'shellprocess@' + name + '.conf';
+        if (fs.existsSync(moduleSource)) {
+            if (this.verbose)
+                this.show(name, 'shellprocess', moduleDest);
+            shx.cp(moduleSource, moduleDest);
+        }
+        else if (this.verbose) {
+            console.log(`calamares: ${name} shellprocess, nothing to do`);
+        }
+    }
+    /**
+     *
+     * @param module
+     * @param type
+     * @param path
+     */
+    show(name, type, path) {
+        switch (type) {
+            case 'module': {
+                console.log('fisherman: ' + chalk.yellow(name) + ' module in ' + chalk.yellow(path));
+                break;
+            }
+            case 'calamares_module': {
+                console.log('fisherman: ' + chalk.cyanBright(name) + ' calamares_module in ' + chalk.cyanBright(path));
+                break;
+            }
+            case 'shellprocess': {
+                console.log('fisherman: ' + chalk.green(name) + ' shellprocess in ' + chalk.green(path));
+                break;
+            }
+            case 'contextualprocess': {
+                console.log('fisherman: ' + chalk.cyanBright(name) + ' shellprocess in ' + chalk.cyanBright(path));
+                break;
+            }
+            // No default
+        }
+    }
+    /**
+    * ====================================================================================
+    * buildModule...
+    * ====================================================================================
+    */
+    /**
+     * buildModuleDracut
+     */
+    async buildModuleDracut(initrd) {
+        const name = 'dracut';
+        let moduleSource = path.resolve(__dirname, this.installer.templateModules + name + '.mustache');
+        let moduleDest = this.installer.modules + name + '.conf';
+        let template = fs.readFileSync(moduleSource, 'utf8');
+        const view = { initrd: initrd };
+        fs.writeFileSync(moduleDest, mustache.render(template, view));
+    }
+    async buildModuleInitcpio() {
+        const { initcpio } = await import('./fisherman-helper/initcpio.js');
+        const preset = await initcpio();
+        const name = 'initcpio';
+        let moduleSource = path.resolve(__dirname, this.installer.templateModules + name + '.mustache');
+        let moduleDest = this.installer.modules + name + '.conf';
+        let template = fs.readFileSync(moduleSource, 'utf8');
+        const view = { preset: preset };
+        fs.writeFileSync(moduleDest, mustache.render(template, view));
+    }
+    /**
+     * buildModuleFinished
+     */
+    async buildModuleFinished() {
+        const name = 'finished';
+        await this.buildModule(name);
+        let file = this.installer.modules + name + '.conf';
+        let fileContent = fs.readFileSync(file, 'utf8');
+        let values = yaml.load(fileContent);
+        values.restartNowCommand = 'reboot';
+        let destContent = `# ${name}.conf, created by penguins-eggs ${pjson.version}\n`;
+        destContent += '---\n';
+        destContent += yaml.dump(values);
+        fs.writeFileSync(file, destContent, 'utf8');
+    }
+    /**
+     * buildModulePackages
+     */
+    async buildModulePackages(distro, release = false) {
+        let backend = 'apt';
+        if (distro.familyId === 'alpine') {
+            backend = 'apk';
+        }
+        else if (distro.familyId === 'archlinux') {
+            backend = 'pacman';
+        }
+        else if (distro.familyId === 'fedora') {
+            backend = 'dnf';
+        }
+        else if (distro.familyId === 'fedora') {
+            backend = 'zypper';
+        }
+        const yamlInstall = tryInstall(distro);
+        let yamlRemove = '';
+        if (release) {
+            yamlRemove = removePackages(distro);
+        }
+        let operations = '';
+        if (yamlRemove !== '' || yamlInstall !== '') {
+            operations = 'operations:\n' + yamlRemove + yamlInstall;
+        }
+        const name = 'packages';
+        let moduleSource = path.resolve(__dirname, this.installer.templateModules + name + '.mustache');
+        let moduleDest = this.installer.modules + name + '.conf';
+        let template = fs.readFileSync(moduleSource, 'utf8');
+        const view = {
+            backend: backend,
+            operations: operations
+        };
+        fs.writeFileSync(moduleDest, mustache.render(template, view));
+    }
+    /**
+     * buildModuleRemoveuser
+     */
+    async buildModuleRemoveuser(username) {
+        const name = 'removeuser';
+        let moduleSource = path.resolve(__dirname, this.installer.templateModules + name + '.mustache');
+        let moduleDest = this.installer.modules + name + '.conf';
+        let template = fs.readFileSync(moduleSource, 'utf8');
+        const view = { username: username };
+        fs.writeFileSync(moduleDest, mustache.render(template, view));
+    }
+    /**
+     * buildModuleUnpackfs
+     */
+    async buildModuleUnpackfs() {
+        const name = 'unpackfs';
+        let moduleSource = path.resolve(__dirname, this.installer.templateModules + name + '.mustache');
+        let moduleDest = this.installer.modules + name + '.conf';
+        let template = fs.readFileSync(moduleSource, 'utf8');
+        let source = path.join(this.distro.liveMediumPath, this.distro.squashfs);
+        const view = { source: source };
+        fs.writeFileSync(moduleDest, mustache.render(template, view));
+    }
+}