penguins-eggs 10.1.1 → 25.7.10

package/dist/dhcpd-proxy/lib/utils.js

@@ -0,0 +1,255 @@
+/**
+ * util.ts
+ *
+ * used in dhcpd
+ *
+ */
+import sprintf from "./sprintf.js";
+/**
+ *
+ * @param _buffer
+ * @param byteArray
+ * @param offset
+ * @returns
+ */
+export const writeBytes = (_buffer, byteArray, offset) => {
+    let _bytesWritten = 0;
+    let i = 0;
+    while (i < byteArray.length) {
+        _buffer[offset++] = byteArray[i];
+        i++;
+    }
+    if (offset > _bytesWritten) {
+        _bytesWritten = offset;
+    }
+    return this;
+};
+/**
+ *
+ * @param _buffer
+ * @param integer
+ * @param offset
+ * @returns
+ */
+export function writeInt32(_buffer, integer, offset) {
+    _buffer[offset++] = integer >>> 24;
+    _buffer[offset++] = integer >>> 16;
+    _buffer[offset++] = integer >>> 8;
+    _buffer[offset++] = integer;
+    return offset;
+}
+/**
+ *
+ * @param _buffer
+ * @param integer
+ * @param offset
+ * @returns
+ */
+export function writeInt16(_buffer, integer, offset) {
+    _buffer[offset++] = integer >>> 8;
+    _buffer[offset++] = integer;
+    return offset;
+}
+/**
+ *
+ * @param _buffer
+ * @param integer
+ * @param offset
+ * @returns
+ */
+export function writeInt8(_buffer, integer, offset) {
+    _buffer[offset++] = integer;
+    return offset;
+}
+/**
+ *
+ * @param _buffer
+ * @param length
+ * @param copy
+ * @param offset
+ * @returns
+ */
+export function readBytes(_buffer, length, copy, offset) {
+    let bufCopy;
+    if (copy) {
+        bufCopy = new Buffer(length);
+        _buffer.copy(bufCopy, 0, offset, (offset += length));
+        return bufCopy;
+    }
+    else {
+        return _buffer.slice(offset, (offset += length));
+    }
+}
+/**
+ *
+ * @param _buffer
+ * @param offset
+ * @returns
+ */
+export function readInt32(_buffer, offset) {
+    return ((_buffer[offset++] << 24) |
+        (_buffer[offset++] << 16) |
+        (_buffer[offset++] << 8) |
+        _buffer[offset++]);
+}
+/**
+ *
+ * @param _buffer
+ * @param offset
+ * @returns
+ */
+export function readInt16(_buffer, offset) {
+    return (_buffer[offset++] << 8) | _buffer[offset++];
+}
+/**
+ *
+ * @param _buffer
+ * @param offset
+ * @returns
+ */
+export function readInt8(_buffer, offset) {
+    return _buffer[offset++];
+}
+/**
+ *
+ * @param buf
+ * @returns
+ */
+export function readString(buf) {
+    let j, s;
+    s = "";
+    j = 0;
+    while (j < buf.length) {
+        s += String.fromCharCode(buf[j]);
+        j++;
+    }
+    return s;
+}
+/**
+ *
+ * @param buf
+ * @returns
+ */
+export function readHex(buf) {
+    let j, s;
+    s = "";
+    j = 0;
+    while (j < buf.length) {
+        // check was b not buf
+        s += sprintf("%02x", buf[j]);
+        j++;
+    }
+    return s;
+}
+/**
+ *
+ * @param buf
+ * @returns
+ */
+export function readHexAddress(buf) {
+    let j, s;
+    s = [];
+    j = 0;
+    while (j < buf.length) {
+        s.push(sprintf("%02d", buf[j]));
+        j++;
+    }
+    return s.join(":");
+}
+/**
+ *
+ * @param buffer
+ * @param offset
+ * @returns
+ */
+export function readIp(buffer, offset) {
+    let stop;
+    if (offset === null) {
+        offset = 0;
+    }
+    if (offset > buffer.length) {
+        return undefined;
+    }
+    if (0 === buffer.readUInt8(offset)) {
+        return undefined;
+    }
+    else {
+        stop = offset + 4;
+        return (function () {
+            const _results = [];
+            while (offset < stop) {
+                _results.push(buffer.readUInt8(offset++));
+            }
+            return _results;
+        })().join(".");
+    }
+}
+/**
+ *
+ * @param buffer
+ * @returns
+ */
+export function readMacAddress(buffer) {
+    let byte;
+    return (function () {
+        let _i, _len;
+        const _results = [];
+        for (_i = 0, _len = buffer.length; _i < _len; _i++) {
+            byte = buffer[_i];
+            _results.push((byte + 0x100).toString(16).substr(-2));
+        }
+        return _results;
+    })().join(":");
+}
+/**
+ *
+ * @param buf
+ * @param num
+ * @param offsetHours
+ * @param offset
+ * @returns
+ */
+export function writeTimeOffset(buf, num, offsetHours, offset) {
+    buf[offset++] = 0;
+    return offset;
+}
+/**
+ *
+ * @param buf
+ * @param num
+ * @param ip
+ * @param offset
+ * @returns
+ */
+export function writeIp(buf, num, ip, offset) {
+    buf[offset++] = num;
+    buf[offset++] = 4;
+    if ((typeof ip !== "string" && !(ip instanceof String)) ||
+        ip.indexOf(".") === -1) {
+        ip = "0.0.0.0";
+    }
+    ip.split(".").forEach(function (item) {
+        buf[offset++] = item;
+    });
+    return offset;
+}
+/**
+ *
+ * @param buf
+ * @param num
+ * @param hostname
+ * @param offset
+ * @returns
+ */
+export function writeString(buf, num, hostname, offset) {
+    let charArr;
+    charArr = hostname.split("");
+    buf[offset++] = num;
+    buf[offset++] = charArr.length;
+    charArr.forEach(function (chr) {
+        // charCodeAt(index: number): number
+        //buf[offset++] = chr.charCodeAt() original
+        buf[offset++] = chr.charCodeAt(0);
+    });
+    return offset;
+}

package/dist/dhcpd-proxy/simple-proxy.d.ts

@@ -0,0 +1,11 @@
+/**
+ * simple-proxy.ts
+ * Un proxy DHCP minimale che agisce come un mini-server DHCP completo
+ * solo per i client PXE, per aggirare le protezioni di rete.
+ */
+import type { IDhcpOptions } from '../dhcpd-proxy//interfaces/i-pxe.js';
+/**
+ * La nostra unica funzione. Prende le opzioni e avvia il proxy.
+ * @param options Le opzioni di configurazione PXE
+ */
+export declare function startSimpleProxy(options: IDhcpOptions): void;

package/dist/dhcpd-proxy/simple-proxy.js

@@ -0,0 +1,118 @@
+/**
+ * simple-proxy.ts
+ * Un proxy DHCP minimale che agisce come un mini-server DHCP completo
+ * solo per i client PXE, per aggirare le protezioni di rete.
+ */
+import { createSocket } from 'dgram';
+import ansis from 'ansis';
+import { Packet } from '../dhcpd-proxy/classes/packet.js';
+import { DhcpMessageType } from '../dhcpd-proxy//lib/packet/message-types.js';
+// Un semplice Map in memoria per tracciare gli IP offerti
+const offeredIPs = new Map();
+/**
+ * La nostra unica funzione. Prende le opzioni e avvia il proxy.
+ * @param options Le opzioni di configurazione PXE
+ */
+export function startSimpleProxy(options) {
+    const socket = createSocket({ type: 'udp4', reuseAddr: true });
+    socket.on('error', (err) => {
+        console.error(ansis.red.bold(`ERRORE SOCKET: ${err.stack}`));
+        socket.close();
+    });
+    socket.on('listening', () => {
+        const address = socket.address();
+        socket.setBroadcast(true);
+        console.log(ansis.green.inverse(`\n Proxy DHCP listening su ${address.address}:${address.port}. CTRL-C to end!\n`));
+    });
+    socket.on('message', (buffer, rinfo) => {
+        try {
+            const packet = Packet.fromBuffer(buffer);
+            packet.remote = rinfo;
+            const messageType = packet.options[53] || 0;
+            if (packet.op === 1 && messageType === DhcpMessageType.DHCPDISCOVER) {
+                handleDiscover(packet, options);
+            }
+            else if (packet.op === 1 && messageType === DhcpMessageType.DHCPREQUEST) {
+                handleRequest(packet, options);
+            }
+        }
+        catch (err) {
+            // Ignoriamo errori di parsing
+        }
+    });
+    socket.bind(67, '0.0.0.0');
+    // --- Funzioni Helper Interne ---
+    function setBootFilename(packet, opts) {
+        const isIpxe = packet.options[77] && packet.options[77].toString().includes('iPXE');
+        const arch = packet.options[93] || packet.options[60];
+        const isUefi64 = arch && (String(arch).includes('00007') || String(arch).includes('00009'));
+        // LOGICA DI ASSEGNAZIONE PRECISA
+        if (isIpxe && isUefi64) {
+            // CASO 1: Il client è iPXE e anche UEFI. Offriamo lo script!
+            console.log(ansis.magenta.bold(`<- Rilevato client iPXE su UEFI! Offro script autoexec...`));
+            return `http://${opts.host}/autoexec.ipxe`;
+        }
+        else if (isUefi64) {
+            // CASO 2: Il client è UEFI ma non è ancora iPXE. Offriamo il bootloader iPXE per UEFI.
+            return opts.efi64_filename;
+        }
+        else {
+            // CASO 3: Il client è BIOS. Offriamo il bootloader iPXE per BIOS.
+            // (Aggiunta logica per altri tipi di architettura se necessario)
+            return opts.bios_filename;
+        }
+    }
+    function handleDiscover(packet, opts) {
+        console.log(ansis.blue.bold(`\n-> DISCOVER Ricevuto`));
+        console.log(ansis.dim(`   └─ Da MAC: ${ansis.white(packet.chaddr)}`));
+        if (packet.options[60]?.includes('PXEClient')) {
+            console.log(ansis.cyan.bold(`<- Rilevato PXEClient! Preparo un'offerta completa...`));
+            const offerPacket = new Packet(packet);
+            offerPacket.op = 2; // BOOTREPLY
+            const ipParts = opts.host.split('.');
+            ipParts[3] = (parseInt(ipParts[3]) + 10).toString();
+            const offeredIp = ipParts.join('.');
+            offeredIPs.set(packet.chaddr, offeredIp);
+            offerPacket.yiaddr = offeredIp;
+            offerPacket.siaddr = opts.tftpserver;
+            offerPacket.options[53] = DhcpMessageType.DHCPOFFER;
+            offerPacket.options[54] = opts.host;
+            // Imposta il filename usando la nuova funzione logica
+            offerPacket.fname = setBootFilename(packet, opts);
+            console.log(ansis.dim(`   ├─ Offro IP: ${ansis.green(offeredIp)}`));
+            console.log(ansis.dim(`   ├─ Next-Server: ${ansis.white(offerPacket.siaddr)}`));
+            console.log(ansis.dim(`   └─ Filename: ${ansis.white(offerPacket.fname)}`));
+            send(offerPacket, opts.broadcast, 68);
+        }
+    }
+    function handleRequest(packet, opts) {
+        const offeredIp = offeredIPs.get(packet.chaddr);
+        if (!offeredIp || (packet.options[50] && packet.options[50] !== offeredIp)) {
+            return;
+        }
+        console.log(ansis.yellow.bold(`-> REQUEST per la nostra offerta ricevuto!`));
+        console.log(ansis.dim(`   └─ Da MAC: ${ansis.white(packet.chaddr)}`));
+        const ackPacket = new Packet(packet);
+        ackPacket.op = 2;
+        ackPacket.yiaddr = offeredIp;
+        ackPacket.siaddr = opts.tftpserver;
+        ackPacket.options[53] = DhcpMessageType.DHCPACK;
+        ackPacket.options[54] = opts.host;
+        // Imposta il filename usando la stessa logica
+        ackPacket.fname = setBootFilename(packet, opts);
+        console.log(ansis.cyan.bold(`<- Invio ACK finale...`));
+        send(ackPacket, opts.broadcast, 68);
+    }
+    function send(packet, ip, port) {
+        const buffer = packet.toBuffer();
+        const typeName = DhcpMessageType[packet.options[53]] || 'UNKNOWN';
+        socket.send(buffer, 0, buffer.length, port, ip, (err, bytes) => {
+            if (err) {
+                console.error(ansis.red.bold(`[PROXY-ERROR] Errore invio ${typeName}:`), err);
+            }
+            else {
+                console.log(ansis.green(`   ✔︎ ${typeName} inviata a ${ip}:${port} (${bytes} bytes)`));
+            }
+        });
+    }
+}

package/dist/interfaces/i-pxe.d.ts

@@ -1,24 +1,24 @@
 export interface ITftpOptions {
-    denyPUT: boolean;
     host: string;
     port: number;
     root: string;
+    denyPUT: boolean;
 }
 export interface IDhcpOptions {
+    subnet: string;
+    host: string;
+    tftpserver: string;
     bios_filename: string;
     efi32_filename: string;
     efi64_filename: string;
-    host: string;
-    subnet: string;
-    tftpserver: string;
+    broadcast: string;
 }
 export interface IDhcpd {
-    constructor(opts: IDhcpOptions): void;
+    pre_init: (pkt: IPacket) => void;
     discover: (pkt: IPacket) => void;
+    request: (pkt: IPacket) => void;
     inform: (pkt: IPacket) => void;
-    pre_init: (pkt: IPacket) => void;
     proxy_request: (pkt: IPacket) => IPacket;
-    request: (pkt: IPacket) => void;
 }
 export interface IProxy {
     bind: (port: number, addr: string, cb: any) => IPacket;
@@ -27,19 +27,19 @@ export interface IServer {
     bind: (port: number, addr: string, cb: any) => IPacket;
 }
 export interface IPacket {
-    chaddr: (chaddr: any) => IPacket;
-    ciaddr: (ciaddr: string) => IPacket;
-    flags: (flags: any) => IPacket;
-    fname: (fname: any) => IPacket;
     getRequestedIPAddress: () => string;
-    giaddr: (giaddr: string) => IPacket;
+    op: (op: any) => IPacket;
+    htype: (htype: any) => IPacket;
     hlen: (hlen: any) => IPacket;
     hops: (hops: any) => IPacket;
-    htype: (htype: any) => IPacket;
-    op: (op: any) => IPacket;
-    options: (options: any) => IPacket;
+    xid: (xid: any) => IPacket;
     secs: (secs: any) => IPacket;
+    flags: (flags: any) => IPacket;
+    ciaddr: (ciaddr: string) => IPacket;
     siaddr: (siaddr: string) => IPacket;
+    giaddr: (giaddr: string) => IPacket;
+    chaddr: (chaddr: any) => IPacket;
     sname: (sname: any) => IPacket;
-    xid: (xid: any) => IPacket;
+    fname: (fname: any) => IPacket;
+    options: (options: any) => IPacket;
 }

package/dist/krill/classes/sequence.d/add_user.d.ts

@@ -10,11 +10,11 @@ import Sequence from '../sequence.js';
 /**
  *
  * @param this
- * @param name
+ * @param username
  * @param password
- * @param fullName
+ * @param fullusername
  * @param roomNumber
  * @param workPhone
  * @param homePhone
  */
-export default function addUser(this: Sequence, name?: string, password?: string, fullName?: string, roomNumber?: string, workPhone?: string, homePhone?: string): Promise<void>;
+export default function addUser(this: Sequence, username?: string, password?: string, fullusername?: string, roomNumber?: string, workPhone?: string, homePhone?: string): Promise<void>;

package/dist/krill/classes/sequence.d/add_user.js

@@ -6,61 +6,66 @@
  * license: MIT
  * https://stackoverflow.com/questions/23876782/how-do-i-split-a-typescript-class-into-multiple-files
  */
+import Utils from '../../../classes/utils.js';
 import fs from 'fs';
 import yaml from 'js-yaml';
 import { exec } from '../../../lib/utils.js';
 /**
  *
  * @param this
- * @param name
+ * @param username
  * @param password
- * @param fullName
+ * @param fullusername
  * @param roomNumber
  * @param workPhone
  * @param homePhone
  */
-export default async function addUser(name = 'live', password = 'evolution', fullName = '', roomNumber = '', workPhone = '', homePhone = '') {
+export default async function addUser(username = 'live', password = 'evolution', fullusername = '', roomNumber = '', workPhone = '', homePhone = '') {
     // adduser user
-    let cmd = `chroot ${this.installTarget} adduser ${name} --home /home/${name} --shell /bin/bash --disabled-password --gecos "${fullName},${roomNumber},${workPhone},${homePhone}" ${this.toNull}`;
+    let cmd = `chroot ${this.installTarget} adduser ${username} --home /home/${username} --shell /bin/bash --disabled-password --gecos "${fullusername},${roomNumber},${workPhone},${homePhone}" ${this.toNull}`;
     if (this.distro.familyId === 'archlinux') {
-        cmd = `chroot ${this.installTarget} useradd --create-home --shell /bin/bash ${name} ${this.toNull}`;
+        cmd = `chroot ${this.installTarget} useradd --create-home --shell /bin/bash ${username} ${this.toNull}`;
     }
     else if (this.distro.familyId === 'fedora') {
-        cmd = `chroot ${this.installTarget} adduser ${name} --create-home --shell /bin/bash --comment "${fullName},${roomNumber},${workPhone},${homePhone}" ${this.toNull}`;
+        cmd = `chroot ${this.installTarget} adduser ${username} --create-home --shell /bin/bash --comment "${fullusername},${roomNumber},${workPhone},${homePhone}" ${this.toNull}`;
     }
     else if (this.distro.familyId === 'opensuse') {
-        cmd = `chroot ${this.installTarget} useradd ${name} --create-home --shell /bin/bash --comment "${fullName},${roomNumber},${workPhone},${homePhone}" ${this.toNull}`;
+        cmd = `chroot ${this.installTarget} useradd ${username} --create-home --shell /bin/bash --comment "${fullusername},${roomNumber},${workPhone},${homePhone}" ${this.toNull}`;
     }
     await exec(cmd, this.echo);
-    // chpasswd user
-    cmd = `echo ${name}:${password} | chroot ${this.installTarget} chpasswd ${this.toNull}`;
+    cmd = `echo ${username}:${password} | chroot ${this.installTarget} chpasswd ${this.toNull}`;
     await exec(cmd, this.echo);
     let group = 'wheel';
     if (this.distro.familyId === 'debian') {
-        /**
-         * look to calamares/modules/users.yml for groups
-         */
-        let usersConf = '/etc/calamares/modules/users.conf';
-        if (!fs.existsSync(usersConf)) {
-            usersConf = '/etc/penguins-eggs.d/krill/modules/users.conf';
-        }
-        if (fs.existsSync(usersConf)) {
-            const o = yaml.load(fs.readFileSync(usersConf, 'utf8'));
-            for (const group of o.defaultGroups) {
-                cmd = `chroot ${this.installTarget} usermod -aG ${group} ${name} ${this.toNull}`;
-                await exec(cmd, this.echo);
-            }
-        }
-        else {
-            group = 'sudo';
-        }
-        cmd = `chroot ${this.installTarget} usermod -aG ${group} ${name} ${this.toNull}`;
-        await exec(cmd, this.echo);
+        group = 'sudo';
     }
+    cmd = `chroot ${this.installTarget} usermod -aG ${group} ${username} ${this.toNull}`;
+    await exec(cmd, this.echo);
     // add autologin group in archlinux
     await exec(cmd, this.echo);
     if (this.distro.familyId === 'archlinux') {
         await exec(`chroot ${this.installTarget} getent group autologin || groupadd autologin`);
-        await exec(`chroot ${this.installTarget} gpasswd -a ${this.settings.config.user_opt} autologin`);
+        await exec(`chroot ${this.installTarget} usermod -aG autologin ${username}`);
+    }
+    /**
+     * look to calamares/modules/users.conf for groups
+     */
+    let usersConf = '/etc/calamares/modules/users.conf';
+    if (!fs.existsSync(usersConf)) {
+        usersConf = '/etc/penguins-eggs.d/krill/modules/users.conf';
+    }
+    if (fs.existsSync(usersConf)) {
+        const o = yaml.load(fs.readFileSync(usersConf, 'utf8'));
+        for (const group of o.defaultGroups) {
+            const groupExists = await exec(`getent group ${group}`);
+            if (groupExists.code == 0) {
+                let addGroup = `chroot ${this.installTarget} usermod -aG ${group} ${username}`;
+                await exec(addGroup);
+            }
+        }
+    }
+    else {
+        console.log(`cannot find: ${usersConf}!`);
+        await Utils.pressKeyToExit();
     }
 }

package/dist/krill/classes/sequence.d/bootloader_config.js

@@ -15,32 +15,9 @@ import { exec } from '../../../lib/utils.js';
 export default async function bootloaderConfig() {
     let cmd = '';
     /**
-       * aldos
-       */
-    if (this.distro.familyId === 'aldos') {
-        if (this.efi) {
-            try {
-                cmd = `chroot ${this.installTarget} yum install grub2 grub2-efi-x64 efibootmgr} ${this.toNull}`;
-                await exec(cmd, this.echo);
-            }
-            catch (error) {
-                await showError(cmd, error);
-            }
-        }
-        else {
-            try {
-                cmd = `chroot ${this.installTarget} yum install grub2 grub2-pc ${this.toNull}`;
-                await exec(cmd, this.echo);
-            }
-            catch (error) {
-                await showError(cmd, error);
-            }
-        }
-        /**
-       * alpine
-       */
-    }
-    else if (this.distro.familyId === 'alpine') {
+    * alpine
+    */
+    if (this.distro.familyId === 'alpine') {
         if (this.efi) {
             try {
                 cmd = `chroot ${this.installTarget} apk add grub grub-efi efibootmgr} ${this.toNull}`;

package/dist/krill/classes/sequence.d/fstab.js

@@ -8,7 +8,6 @@
  */
 import shx from 'shelljs';
 import { InstallationMode } from '../krill_enums.js';
-import Pacman from '../../../classes/pacman.js';
 import Utils from '../../../classes/utils.js';
 import { SwapChoice } from '../krill_enums.js';
 /**
@@ -42,9 +41,6 @@ export default async function fstab(installDevice, crypted = false) {
     /**
      * fstab
      */
-    if (!Pacman.packageIsInstalled('btrfs-progs')) {
-        this.partitions.filesystemType === 'ext4';
-    }
     const fstab = this.installTarget + '/etc/fstab';
     /**
       boot: IDevice
@@ -144,27 +140,19 @@ export default async function fstab(installDevice, crypted = false) {
             text += `# swap undefined\n`;
         }
         /**
-         * brtfs: TUTTO da rivedere!
+         * btrfs
          */
     }
     else if (this.partitions.filesystemType === 'btrfs') {
-        const base = '/        btrfs  subvol=/@,defaults 0 0';
-        const snapshots = '/.snapshots               btrfs  subvol=/@snapshots,defaults 0 0';
-        const home = '/home                     btrfs  subvol=/@home,defaults 0 0';
-        const root = '/root                     btrfs  subvol=/@root,defaults 0 0';
-        const var_log = '/var/log                  btrfs  subvol=/@var@log,defaults 0 0';
-        const var_lib_AccountsService = '/var/lib/AccountsService  btrfs  subvol=/@var@lib@AccountsService,defaults 0 0';
-        const var_lib_blueman = '/var/lib/blueman          btrfs  subvol=/@var@lib@blueman,defaults 0 0';
-        const tmp = '/tmp                      btrfs  subvol=/@tmp,defaults 0 0';
-        text += `# ${this.devices.root.name}  btrfs ${this.devices.root.mountPoint} subvol\n`;
-        text += `UUID=${Utils.uuid(this.devices.root.name)} ${base}\n`;
-        text += `# UUID=${Utils.uuid(this.devices.root.name)} ${snapshots}\n`;
-        text += `# UUID=${Utils.uuid(this.devices.root.name)} ${home}\n`;
-        text += `# UUID=${Utils.uuid(this.devices.root.name)} ${root}\n`;
-        text += `# UUID=${Utils.uuid(this.devices.root.name)} ${var_log}\n`;
-        text += `# UUID=${Utils.uuid(this.devices.root.name)} ${var_lib_AccountsService}\n`;
-        text += `# UUID=${Utils.uuid(this.devices.root.name)} ${var_lib_blueman}\n`;
-        text += `# UUID=${Utils.uuid(this.devices.root.name)} ${tmp}\n`;
+        const rootMountPoint = this.devices.root.mountPoint;
+        const rootUuid = Utils.uuid(this.devices.root.name);
+        text += `# ${this.devices.root.name}  btrfs ${rootMountPoint} subvol\n`;
+        text += `UUID=${rootUuid} /               btrfs       subvol=/@,defaults 0 0\n`;
+        text += `UUID=${rootUuid} /home           btrfs       /@home,defaults 0 0\n`;
+        text += `UUID=${rootUuid} /var/cache      btrfs       /@cache,defaults 0 0\n`;
+        text += `UUID=${rootUuid} /var/log        btrfs       /@log,defaults 0 0\n`;
+        text += `# swapfile\n`;
+        text += `/swapfile   none  swap  sw  0  0`;
     }
     Utils.write(fstab, text);
 }

package/dist/krill/classes/sequence.d/grubcfg.js

@@ -8,7 +8,6 @@
  */
 import fs from 'node:fs';
 import Utils from '../../../classes/utils.js';
-import { SwapChoice } from '../krill_enums.js';
 import { InstallationMode } from '../krill_enums.js';
 /**
  * grubcfg
@@ -22,9 +21,12 @@ export default async function grubcfg() {
     let content = '';
     const grubs = fs.readFileSync(file, 'utf8').split('\n');
     for (let i = 0; i < grubs.length; i++) {
+        // RESUME
         if (grubs[i].includes('GRUB_CMDLINE_LINUX_DEFAULT=')) {
-            if (this.partitions.userSwapChoice != SwapChoice.File) {
-                grubs[i] = this.partitions.installationMode === InstallationMode.Luks ? `GRUB_CMDLINE_LINUX_DEFAULT="resume=UUID=${Utils.uuid(this.devices.swap.name)}"` : `GRUB_CMDLINE_LINUX_DEFAULT="quiet splash resume=UUID=${Utils.uuid(this.devices.swap.name)}"`;
+            if (this.partitions.filesystemType === 'btrfs') {
+                // userSwapChoice != SwapChoice.File) {
+                // grubs[i] = this.partitions.installationMode === InstallationMode.Luks ? `GRUB_CMDLINE_LINUX_DEFAULT="resume=UUID=${Utils.uuid(this.devices.swap.name)}"` : `GRUB_CMDLINE_LINUX_DEFAULT="quiet splash resume=UUID=${Utils.uuid(this.devices.swap.name)}"`
+                grubs[i] = this.partitions.installationMode === InstallationMode.Luks ? `GRUB_CMDLINE_LINUX_DEFAULT="resume=UUID=${Utils.uuid(this.devices.swap.name)}"` : `GRUB_CMDLINE_LINUX_DEFAULT="quiet splash rootflags=subvol=@"`;
             }
         }
         content += grubs[i] + '\n';

package/dist/krill/classes/sequence.d/mkfs.d.ts

@@ -10,6 +10,6 @@ import Sequence from '../../classes/sequence.js';
 /**
  * mkfs
  *
- * mke2fs - create an ext2/ext3/ext4 file system -F force, -t type
+ * mkfs - create an ext2/ext3/ext4/btrfs
  */
 export default function mkfs(this: Sequence): Promise<boolean>;