penguins-eggs 25.10.23 → 25.10.24

package/dist/commands/wardrobe/wear.js

@@ -0,0 +1,84 @@
+/**
+ * ./src/commands/wardrobe/wear.ts
+ * penguins-eggs v.25.7.x / ecmascript 2020
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+import { Args, Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import fs from 'node:fs';
+import path from 'node:path';
+import Tailor from '../../classes/tailor.js';
+import Utils from '../../classes/utils.js';
+import { exec } from '../../lib/utils.js';
+/**
+ *
+ */
+export default class Wear extends Command {
+    static args = {
+        repo: Args.string({ description: 'costume to wear', name: 'costume', required: false })
+    };
+    static description = 'wear costume/accessories from wardrobe';
+    static examples = ['sudo eggs wardrobe wear duck', 'sudo eggs wardrobe wear accessories/firmwares', 'sudo eggs wardrobe wear wagtail/waydroid'];
+    static flags = {
+        help: Flags.help({ char: 'h' }),
+        no_accessories: Flags.boolean({ char: 'a', description: 'not install accessories' }),
+        no_firmwares: Flags.boolean({ char: 'f', description: 'not install firmwares' }),
+        verbose: Flags.boolean({ char: 'v' }),
+        wardrobe: Flags.string({ char: 'w', description: 'wardrobe' })
+    };
+    async run() {
+        const { argv, flags } = await this.parse(Wear);
+        const { verbose } = flags;
+        Utils.titles(this.id + ' ' + this.argv);
+        let no_accessories = false;
+        if (flags.no_accessories) {
+            no_accessories = true;
+        }
+        let no_firmwares = false;
+        if (flags.no_firmwares) {
+            no_firmwares = true;
+        }
+        let wardrobe = await Utils.wardrobe();
+        if (flags.wardrobe !== undefined) {
+            wardrobe = flags.wardrobe;
+        }
+        wardrobe = `${path.resolve(process.cwd(), wardrobe)}/`;
+        if (!fs.existsSync(wardrobe)) {
+            Utils.warning(`wardrobe: ${wardrobe} not found!`);
+            process.exit();
+        }
+        console.log(chalk.green('wardrobe: ') + wardrobe);
+        /**
+         * costume
+         */
+        let costume = 'costumes/colibri';
+        if (this.argv['0'] !== undefined) {
+            costume = this.argv['0']; // 12345678                               12345678901                              1234567
+            if (costume.slice(0, 8) !== 'costumes' && costume.slice(0, 11) !== 'accessories' && costume.slice(0, 7) !== 'servers') {
+                costume = `costumes/${costume}`;
+            }
+        }
+        costume = wardrobe + costume;
+        console.log(costume);
+        if (!fs.existsSync(costume)) {
+            Utils.warning(`costume not found in : ${costume}!`);
+            process.exit();
+        }
+        if (await Utils.customConfirm(`Prepare your costume: ${costume}? Select yes to continue...`)) {
+            if (Utils.isRoot()) {
+                const tailor = new Tailor(costume);
+                // delete previous log
+                await exec(`rm -f ${path.dirname(wardrobe)}/wardrobe.log`);
+                await tailor.prepare(verbose, no_accessories, no_firmwares);
+            }
+            else {
+                Utils.useRoot(this.id);
+            }
+        }
+        else {
+            console.log('costume ' + chalk.cyan(costume) + ' not found in wardrobe: ' + chalk.green(wardrobe));
+        }
+    }
+}

package/dist/dhcpd-proxy/classes/packet.d.ts

@@ -0,0 +1,36 @@
+import { Buffer } from 'buffer';
+interface DhcpOptions {
+    [key: number]: any;
+}
+export declare class Packet {
+    op: number;
+    htype: number;
+    hlen: number;
+    hops: number;
+    xid: number;
+    secs: number;
+    flags: number;
+    ciaddr: string;
+    yiaddr: string;
+    siaddr: string;
+    giaddr: string;
+    chaddr: string;
+    sname: string;
+    fname: string;
+    options: DhcpOptions;
+    constructor(init: Partial<Packet>);
+    /**
+     * Crea un oggetto Packet da un Buffer
+     * @param b Il Buffer da cui leggere
+     * @returns Un'istanza di Packet
+     */
+    static fromBuffer(b: Buffer): Packet;
+    getRequestedIPAddress(): string;
+    op_set(op: number): this;
+    /**
+     * Converte l'oggetto Packet in un Buffer
+     * @returns Il Buffer DHCP
+     */
+    toBuffer(): Buffer;
+}
+export {};

package/dist/dhcpd-proxy/classes/packet.js

@@ -0,0 +1,124 @@
+/* packet.ts
+ *
+ * author: Piero Proietti <piero.proietti@gmail.com>
+ * refactored for modern TypeScript
+ */
+import { readIp, readMacAddress } from "../lib/utils.js";
+import get_convert from "../lib/packet/converters.js";
+import { Buffer } from 'buffer'; // Import Buffer type
+// Mettiamo 'export' direttamente davanti alla classe
+export class Packet {
+    // Aggiunto '!' per il "Definite Assignment Assertion"
+    op;
+    htype;
+    hlen;
+    hops;
+    xid;
+    secs;
+    flags;
+    ciaddr;
+    yiaddr;
+    siaddr;
+    giaddr;
+    chaddr;
+    sname;
+    fname;
+    options;
+    constructor(init) {
+        Object.assign(this, init);
+    }
+    // --- METODI STATICI (prima erano funzioni esterne) ---
+    /**
+     * Crea un oggetto Packet da un Buffer
+     * @param b Il Buffer da cui leggere
+     * @returns Un'istanza di Packet
+     */
+    static fromBuffer(b) {
+        const ret = {
+            op: b[0],
+            htype: b[1],
+            hlen: b.readUInt8(2),
+            hops: b.readUInt8(3),
+            xid: b.readUInt32BE(4),
+            secs: b.readUInt16BE(8),
+            flags: b.readUInt16BE(10),
+            ciaddr: readIp(b, 12),
+            yiaddr: readIp(b, 16),
+            siaddr: readIp(b, 20),
+            giaddr: readIp(b, 24),
+            chaddr: readMacAddress(b.slice(28, 28 + b.readUInt8(2))),
+            sname: stripBinNull(b.toString("ascii", 44, 108)),
+            fname: stripBinNull(b.toString("ascii", 108, 236)),
+            options: {},
+        };
+        let i = 240;
+        while (i < b.length && b[i] !== 255) {
+            const optNum = b[i++];
+            const optLen = b[i++];
+            if (i + optLen > b.length)
+                break; // Evita errori di out-of-bounds
+            const converter = get_convert(optNum);
+            const optVal = converter.decode(b.slice(i, i + optLen), optNum);
+            ret.options[optNum] = optVal;
+            i += optLen;
+        }
+        return new Packet(ret);
+    }
+    // --- METODI DI ISTANZA (quelli che restituiscono 'this' e toBuffer) ---
+    getRequestedIPAddress() {
+        return this.options[50];
+    }
+    // ... tutti i tuoi metodi "builder" che restituiscono 'this' vanno qui
+    // Esempio:
+    op_set(op) {
+        this.op = op;
+        return this;
+    }
+    // ...e così via per htype, hlen, xid, etc.
+    /**
+     * Converte l'oggetto Packet in un Buffer
+     * @returns Il Buffer DHCP
+     */
+    toBuffer() {
+        const buffer = Buffer.alloc(512); // Usare Buffer.alloc è più sicuro
+        buffer.fill(0);
+        buffer[0] = this.op;
+        buffer[1] = this.htype;
+        buffer.writeUInt8(this.hlen, 2);
+        buffer.writeUInt8(this.hops, 3);
+        buffer.writeUInt32BE(this.xid, 4);
+        buffer.writeUInt16BE(this.secs, 8);
+        buffer.writeUInt16BE(this.flags, 10);
+        let pos = 12;
+        [this.ciaddr, this.yiaddr, this.siaddr, this.giaddr].forEach(addr => {
+            (addr || "0.0.0.0").split(".").forEach(octet => {
+                buffer.writeUInt8(parseInt(octet, 10), pos++);
+            });
+        });
+        this.chaddr.split(":").forEach(hex => {
+            buffer[pos++] = parseInt(hex, 16);
+        });
+        buffer.fill(0, pos, 236); // Pulisce il resto dell'header
+        buffer.write(this.sname || '', 44, 64, "ascii");
+        buffer.write(this.fname || '', 108, 128, "ascii");
+        pos = 236;
+        [99, 130, 83, 99].forEach(magicCookieByte => {
+            buffer[pos++] = magicCookieByte;
+        });
+        pos = 240;
+        for (const opt in this.options) {
+            if (this.options.hasOwnProperty(opt)) {
+                const value = this.options[opt];
+                const converter = get_convert(parseInt(opt));
+                pos = converter.encode(buffer, parseInt(opt), value, pos);
+            }
+        }
+        buffer[pos++] = 255; // End Option
+        return buffer.slice(0, pos);
+    }
+}
+// Funzione helper, può rimanere qui o essere spostata in un file di utility
+function stripBinNull(str) {
+    const pos = str.indexOf("\u0000");
+    return pos === -1 ? str : str.substr(0, pos);
+}

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

@@ -0,0 +1,4 @@
+export {};
+/**
+ * intetionally blank
+ */ 

package/dist/dhcpd-proxy/index.js

@@ -0,0 +1,4 @@
+export {};
+/**
+ * intetionally blank
+ */ 

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

@@ -0,0 +1,45 @@
+export interface ITftpOptions {
+    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;
+    broadcast: string;
+}
+export interface IDhcpd {
+    pre_init: (pkt: IPacket) => void;
+    discover: (pkt: IPacket) => void;
+    request: (pkt: IPacket) => void;
+    inform: (pkt: IPacket) => void;
+    proxy_request: (pkt: IPacket) => IPacket;
+}
+export interface IProxy {
+    bind: (port: number, addr: string, cb: any) => IPacket;
+}
+export interface IServer {
+    bind: (port: number, addr: string, cb: any) => IPacket;
+}
+export interface IPacket {
+    getRequestedIPAddress: () => string;
+    op: (op: any) => IPacket;
+    htype: (htype: any) => IPacket;
+    hlen: (hlen: any) => IPacket;
+    hops: (hops: 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;
+    fname: (fname: any) => IPacket;
+    options: (options: any) => IPacket;
+}

package/dist/dhcpd-proxy/interfaces/i-pxe.js

@@ -0,0 +1 @@
+export {};

package/dist/dhcpd-proxy/lib/packet/converters.d.ts

@@ -0,0 +1,11 @@
+export default function (i: any): any;
+/**
+ * error TS7053: Element implicitly has an 'any' type because expression
+ * of type 'any' can't be used to index type:
+{
+  '1': { encode: [Function: writeIp], decode: [Function: readIp] },
+  '2': { encode: [Function: encode], decode: [Function: decode] },
+  ...
+  '255': { encode: [Function: encode], decode: [Function: decode] }
+}
+*/