penguins-eggs 9.2.6 → 9.2.9

package/dist/classes/pxe.js

@@ -0,0 +1,337 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+/**
+ * penguins-eggs: pxe.ts
+ * author: Piero Proietti
+ * mail: piero.proietti@gmail.com
+ */
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const node_static_1 = tslib_1.__importDefault(require("node-static"));
+const http_1 = tslib_1.__importDefault(require("http"));
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+const utils_1 = tslib_1.__importDefault(require("./utils"));
+const distro_1 = tslib_1.__importDefault(require("./distro"));
+const settings_1 = tslib_1.__importDefault(require("./settings"));
+const utils_2 = require("../lib/utils");
+const tftp = require('tftp');
+const dhcpd = require('../dhcpd/dhcpd');
+/**
+* Pxe:
+*/
+class Pxe {
+    constructor() {
+        this.verbose = false;
+        this.echo = {};
+        this.settings = {};
+        this.bootLabel = '';
+        this.nest = ''; // cuckoo's nest
+        this.pxeRoot = '';
+        this.eggRoot = '';
+        this.vmlinuz = '';
+        this.initrd = '';
+        this.isos = [];
+    }
+    /**
+     * fertilization()
+     *
+     * cuckoo's nest
+     */
+    async fertilization() {
+        this.settings = new settings_1.default();
+        await this.settings.load();
+        if (utils_1.default.isLive()) {
+            this.eggRoot = this.settings.distro.liveMediumPath;
+        }
+        else {
+            this.eggRoot = node_path_1.default.dirname(this.settings.work_dir.path) + '/ovarium/iso/';
+        }
+        if (!utils_1.default.isLive() && !fs_1.default.existsSync(this.settings.work_dir.path)) {
+            console.log('no image available, build an image with: sudo eggs produce');
+            process.exit();
+        }
+        this.nest = '/home/eggs';
+        this.pxeRoot = this.nest + '/pxe';
+        console.log('nest: ' + this.nest);
+        console.log('pxeRoot: ' + this.pxeRoot);
+        console.log('eggRoot: ' + this.eggRoot);
+        /**
+         * se pxeRoot non esiste viene creato
+         */
+        if (!fs_1.default.existsSync(this.pxeRoot)) {
+            await (0, utils_2.exec)(`mkdir ${this.pxeRoot} -p`);
+        }
+        /**
+         * Ricerca delle uova
+         */
+        let isos = [];
+        if (!utils_1.default.isLive()) {
+            let isos = fs_1.default.readdirSync(this.nest);
+            for (const iso of isos) {
+                if (node_path_1.default.extname(iso) === ".iso") {
+                    this.isos.push(iso);
+                }
+                this.isos = this.isos.sort();
+            }
+        }
+        /**
+         * installed: /home/eggs/ovarium/iso/live
+         * live: this.iso/live
+         */
+        let pathFiles = this.eggRoot + '/live';
+        let files = fs_1.default.readdirSync(pathFiles);
+        for (const file of files) {
+            if (this.settings.distro.familyId === 'debian') {
+                if (node_path_1.default.basename(file).substring(0, 7) === 'vmlinuz') {
+                    this.vmlinuz = node_path_1.default.basename(file);
+                }
+                if (node_path_1.default.basename(file).substring(0, 6) === 'initrd') {
+                    this.initrd = node_path_1.default.basename(file);
+                }
+            }
+            else if (this.settings.distro.familyId === 'archlinux') {
+                if (node_path_1.default.basename(file).substring(0, 7) === 'vmlinuz') {
+                    this.vmlinuz = node_path_1.default.basename(file);
+                }
+                if (node_path_1.default.basename(file) === 'initramfs-linux.img') {
+                    this.initrd = node_path_1.default.basename(file);
+                }
+            }
+        }
+        /**
+         * bootLabel
+         */
+        const a = fs_1.default.readFileSync(this.eggRoot + '/.disk/mkisofs', "utf-8");
+        const b = a.substring(a.indexOf('-o ') + 3);
+        const c = b.substring(0, b.indexOf(' '));
+        this.bootLabel = c.substring(c.lastIndexOf('/') + 1);
+        console.log(this.bootLabel);
+        console.log(this.vmlinuz);
+        console.log(this.initrd);
+    }
+    /**
+     * build
+     */
+    async build() {
+        if (fs_1.default.existsSync(this.pxeRoot)) {
+            await this.tryCatch(`rm ${this.pxeRoot} -rf`);
+        }
+        await this.tryCatch(`mkdir ${this.pxeRoot} -p`);
+        await this.tryCatch(`mkdir ${this.pxeRoot} -p`);
+        await this.tryCatch(`ln -s ${this.eggRoot}/live ${this.pxeRoot}/live`);
+        await this.tryCatch(`ln -s ${this.nest}.disk ${this.pxeRoot}/.disk`);
+        if (fs_1.default.existsSync(this.eggRoot)) {
+            await this.tryCatch(`cp ${this.eggRoot}live/${this.vmlinuz} ${this.pxeRoot}/vmlinuz`);
+            await this.tryCatch(`chmod 777 ${this.pxeRoot}/vmlinuz`);
+            await this.tryCatch(`cp ${this.eggRoot}live/${this.initrd} ${this.pxeRoot}/initrd`);
+            await this.tryCatch(`chmod 777 ${this.pxeRoot}/initrd`);
+        }
+        // link iso images in pxe
+        for (const iso of this.isos) {
+            await this.tryCatch(`ln -s ${this.nest}/${iso} ${this.pxeRoot}/${iso}`);
+        }
+        await this.bios();
+        await this.ipxe();
+        await this.http();
+    }
+    /**
+     * configure PXE bios
+     */
+    async bios() {
+        console.log('creating cuckoo configuration pxe: BIOS');
+        await this.tryCatch(`cp ${__dirname}/../../addons/eggs/theme/livecd/isolinux.theme.cfg ${this.pxeRoot}/isolinux.theme.cfg`);
+        await this.tryCatch(`cp ${__dirname}/../../addons/eggs/theme/livecd/splash.png ${this.pxeRoot}/splash.png`);
+        /**
+         * ipxe.efi
+         */
+        await this.tryCatch(`ln -s ${__dirname}/../../ipxe/ipxe.efi ${this.pxeRoot}/ipxe.efi`);
+        // pxe
+        const distro = new distro_1.default();
+        await this.tryCatch(`ln -s ${distro.pxelinuxPath}pxelinux.0 ${this.pxeRoot}/pxelinux.0`);
+        await this.tryCatch(`ln -s ${distro.pxelinuxPath}lpxelinux.0 ${this.pxeRoot}/lpxelinux.0`);
+        // syslinux
+        await this.tryCatch(`ln -s ${distro.syslinuxPath}ldlinux.c32 ${this.pxeRoot}/ldlinux.c32`);
+        await this.tryCatch(`ln -s ${distro.syslinuxPath}vesamenu.c32 ${this.pxeRoot}/vesamenu.c32`);
+        await this.tryCatch(`ln -s ${distro.syslinuxPath}libcom32.c32 ${this.pxeRoot}/libcom32.c32`);
+        await this.tryCatch(`ln -s ${distro.syslinuxPath}libutil.c32 ${this.pxeRoot}/libutil.c32`);
+        await this.tryCatch(`ln -s ${distro.memdiskPath}memdisk ${this.pxeRoot}/memdisk`);
+        await this.tryCatch(`mkdir ${this.pxeRoot}/pxelinux.cfg`);
+        let content = ``;
+        content += `# eggs: pxelinux.cfg/default\n`;
+        content += `# search path for the c32 support libraries (libcom32, libutil etc.)\n`;
+        content += `path\n`;
+        content += `include isolinux.theme.cfg\n`;
+        content += `UI vesamenu.c32\n`;
+        content += `\n`;
+        content += `menu title cuckoo: when you need a flying PXE server! ${utils_1.default.address()}\n`;
+        content += `PROMPT 0\n`;
+        content += `TIMEOUT 0\n`;
+        content += `\n`;
+        content += `label egg\n`;
+        content += `menu label ${this.bootLabel}\n`;
+        let clid = this.settings.distro.codenameLikeId;
+        if (clid === 'bionic' || clid === 'stretch' || clid === 'jessie') {
+            content += `kernel vmlinuz\n`;
+            content += `append initrd=initrd boot=live config noswap noprompt fetch=http://${utils_1.default.address()}/live/filesystem.squashfs\n`;
+        }
+        else {
+            content += `kernel http://${utils_1.default.address()}/vmlinuz\n`;
+            content += `append initrd=http://${utils_1.default.address()}/initrd boot=live config noswap noprompt fetch=http://${utils_1.default.address()}/live/filesystem.squashfs\n`;
+        }
+        content += `SYSAPPEND 3\n`;
+        content += `\n`;
+        if (this.isos.length > 0) {
+            content += `menu separator\n`;
+            for (const iso of this.isos) {
+                content += `\n`;
+                content += `label ${iso}\n`;
+                content += `menu label ${iso}\n`;
+                content += `kernel http://${utils_1.default.address()}/memdisk\n`;
+                content += `initrd http://${utils_1.default.address()}/${iso}\n`;
+                content += `append  iso raw\n`;
+            }
+        }
+        let file = `${this.pxeRoot}/pxelinux.cfg/default`;
+        fs_1.default.writeFileSync(file, content);
+    }
+    /**
+    *
+    */
+    async ipxe() {
+        console.log('creating cuckoo configuration pxe: UEFI');
+        let content = "#!ipxe\n";
+        content += `dhcp\n`;
+        content += `set net0/ip=dhcp\n`;
+        content += `console --picture http://${utils_1.default.address()}/splash.png -x 1024 -y 768\n`;
+        content += "goto start ||\n";
+        content += "\n";
+        content += ':start\n';
+        content += `set server_root http://${utils_1.default.address()}:80/\n`;
+        const serverRootVars = '${server_root}';
+        content += `menu cuckoo: when you need a flying PXE server! ${utils_1.default.address()}\n`;
+        content += 'item --gap boot from ovarium\n';
+        content += `item egg-menu \${space} ${this.bootLabel.replaceAll('.iso', '')}\n\n`;
+        if (this.isos.length > 0) {
+            content += 'item --gap boot iso images\n';
+            for (const iso of this.isos) {
+                const menu = iso;
+                const label = menu;
+                content += `item ${menu} \${space} ${label}\n\n`;
+            }
+        }
+        content += 'item --gap boot from internet\n';
+        content += `item netboot \${space} netboot\n`;
+        content += 'choose target || goto start\n';
+        content += 'goto ${target}\n';
+        content += '\n';
+        content += `:egg-menu\n`;
+        content += `kernel http://${utils_1.default.address()}/vmlinuz\n`;
+        content += `initrd http://${utils_1.default.address()}/initrd\n`;
+        /**
+         * CORRECT:
+         * content += `imgargs vmlinuz fetch=http://${Utils.address()}/live/filesystem.squashfs boot=live dhcp initrd=initrd ro\n`
+         */
+        content += `imgargs vmlinuz fetch=http://${utils_1.default.address()}/live/filesystem.squashfs boot=live dhcp initrd=initrd ro\n`;
+        content += `sleep 10\n`;
+        content += `boot || goto start\n\n`;
+        if (this.isos.length > 0) {
+            for (const iso of this.isos) {
+                const menu = iso.replace('.iso', '');
+                content += `:${menu}\n`;
+                content += `sanboot ${serverRootVars}/${iso}\n`;
+                content += `boot || goto start\n\n`;
+            }
+        }
+        /**
+         * netboot.xyz
+         */
+        content += `:netboot\n`;
+        content += `ifopen net0\n`;
+        content += `set conn_type https\n`;
+        content += `chain --autofree https://boot.netboot.xyz/menu.ipxe || echo HTTPS failed... attempting HTTP...\n`;
+        content += `set conn_type http\n`;
+        content += `chain --autofree http://boot.netboot.xyz/menu.ipxe || echo HTTP failed, localbooting...\n`;
+        content += `goto start\n\n`;
+        let file = `${this.pxeRoot}/autoexec.ipxe`;
+        fs_1.default.writeFileSync(file, content);
+    }
+    /**
+     * configure PXE http server
+     */
+    async http() {
+        console.log('creating cuckoo configuration: PXE html');
+        let file = `${this.pxeRoot}/index.html`;
+        let content = ``;
+        content += `<html><title>Penguin's eggs PXE server</title>`;
+        content += `<div style="background-image:url('/splash.png');background-repeat:no-repeat;width: 640;height:480;padding:5px;border:1px solid black;">`;
+        content += `<h1>Cucko PXE server</h1>`;
+        content += `<body>address: <a href=http://${utils_1.default.address()}>${utils_1.default.address()}</a><br/>`;
+        if (!utils_1.default.isLive()) {
+            content += `Serving:<li>`;
+            for (const iso of this.isos) {
+                content += `<ul><a href='http://${utils_1.default.address()}/${iso}'>${iso}</a></ul>`;
+            }
+            content += `</li>`;
+        }
+        else {
+            content += `started from live iso image<br/>`;
+        }
+        content += `source: <a href='https://github.com/pieroproietti/penguins-eggs'>https://github.com/pieroproietti/penguins-eggs</a><br/>`;
+        content += `manual: <a href='https://penguins-eggs.net/book/italiano9.2.html'>italiano</a>, <a href='https://penguins--eggs-net.translate.goog/book/italiano9.2?_x_tr_sl=auto&_x_tr_tl=en&_x_tr_hl=en'>translated</a><br/>`;
+        content += `discuss: <a href='https://t.me/penguins_eggs'>Telegram group<br/></body</html>`;
+        fs_1.default.writeFileSync(file, content);
+    }
+    /**
+     *
+     * @param dhcpOptions
+     */
+    dhcpStart(dhcpOptions) {
+        let dhcpdProxy = new dhcpd(dhcpOptions);
+    }
+    /**
+    * start http server for images
+    *
+    */
+    async httpStart() {
+        const port = 80;
+        const httpRoot = this.pxeRoot + "/";
+        console.log(`http listening: 0.0.0.0:` + port);
+        var file = new (node_static_1.default.Server)(httpRoot);
+        http_1.default.createServer(function (req, res) {
+            file.serve(req, res);
+        }).listen(port);
+    }
+    /**
+     * start tftp
+     */
+    async tftpStart(tftpOptions) {
+        let tftpServer = tftp.createServer(tftpOptions);
+        tftpServer.on("error", function (error) {
+            // Errors from the main socket 
+            // The current transfers are not aborted 
+            console.error(error);
+        });
+        tftpServer.on("request", function (req, res) {
+            req.on("error", function (error) {
+                //Error from the request 
+                //The connection is already closed 
+                console.error("[" + req.stats.remoteAddress + ":" + req.stats.remotePort + "] (" + req.file + ") " + error.message);
+            });
+        });
+        tftpServer.listen();
+    }
+    /**
+     *
+     * @param cmd
+     */
+    async tryCatch(cmd = '') {
+        try {
+            await (0, utils_2.exec)(cmd, this.echo);
+        }
+        catch (error) {
+            console.log(`Error: ${error}`);
+            await utils_1.default.pressKeyToExit(cmd);
+        }
+    }
+}
+exports.default = Pxe;

package/{lib → dist}/classes/utils.js

@@ -18,6 +18,7 @@ const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const pacman_1 = tslib_1.__importDefault(require("./pacman"));
 // import { green, whiteBright } from 'chalk'
 const child_process_1 = require("child_process");
+const netmask_1 = require("netmask");
 const distro_1 = tslib_1.__importDefault(require("./distro"));
 const pjson = require('../../package.json');
 /**
@@ -554,35 +555,99 @@ class Utils {
     }
     /**
      * address
+     * ip a | grep -w inet |grep -v 127.0.0.1| awk '{print $2}' | cut -d "/" -f 1
+     * ifconfig | grep -w inet |grep -v 127.0.0.1| awk '{print $2}' | cut -d ":" -f 2`
+     *
      */
     static address() {
-        /**
-         * ip a | grep -w inet |grep -v 127.0.0.1| awk '{print $2}' | cut -d "/" -f 1
-         * ifconfig | grep -w inet |grep -v 127.0.0.1| awk '{print $2}' | cut -d ":" -f 2`
-         *
-        */
-        return shelljs_1.default.exec(`ip a | grep -w inet |grep -v 127.0.0.1| awk '{print $2}' | cut -d "/" -f 1`, { silent: true }).stdout.trim();
+        const interfaces = os_1.default.networkInterfaces();
+        let 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 (address === '') {
+                                address = alias.address;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return address;
+        //return shx.exec(`ip a | grep -w inet |grep -v 127.0.0.1| awk '{print $2}' | cut -d "/" -f 1`, { silent: true }).stdout.trim()
     }
     /**
      * netmask
+     * ip a | grep -w inet |grep -v 127.0.0.1| awk '{print $2}' | cut -d "/" -f 2
+     * ifconfig | grep -w inet |grep -v 127.0.0.1| awk '{print $4}' | cut -d ":" -f 2
      */
     static netmask() {
-        /**
-         * ip a | grep -w inet |grep -v 127.0.0.1| awk '{print $2}' | cut -d "/" -f 2
-         * ifconfig | grep -w inet |grep -v 127.0.0.1| awk '{print $4}' | cut -d ":" -f 2
-         */
-        return shelljs_1.default.exec(`ip a | grep -w inet |grep -v 127.0.0.1| awk '{print $2}' | cut -d "/" -f 2`, { silent: true }).stdout.trim();
+        const interfaces = os_1.default.networkInterfaces();
+        let netmask = '';
+        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 (netmask === '') {
+                                netmask = alias.netmask;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return netmask;
+        // return shx.exec(`ip a | grep -w inet |grep -v 127.0.0.1| awk '{print $2}' | cut -d "/" -f 2`, { silent: true }).stdout.trim()
+    }
+    /**
+     *
+     * @returns 192.169.1.2/24
+     */
+    static cidr() {
+        const interfaces = os_1.default.networkInterfaces();
+        let cidr = '';
+        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 (cidr === '') {
+                                if (alias.cidr !== null) {
+                                    cidr = alias.cidr;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return cidr;
     }
     /**
      *
      * @returns
-     */
+    * ip a | grep -w inet |grep -v 127.0.0.1| awk '{print $4}'
+    * ifconfig | grep -w inet |grep -v 127.0.0.1| awk '{print $6}' | cut -d ":" -f 2
+    */
     static broadcast() {
-        /**
-         * ip a | grep -w inet |grep -v 127.0.0.1| awk '{print $4}'
-         * ifconfig | grep -w inet |grep -v 127.0.0.1| awk '{print $6}' | cut -d ":" -f 2
-         */
-        return shelljs_1.default.exec(`ip a | grep -w inet |grep -v 127.0.0.1| awk '{print $4}'`, { silent: true }).stdout.trim();
+        let n = new netmask_1.Netmask(Utils.cidr());
+        return n.broadcast;
+        // return shx.exec(`ip a | grep -w inet |grep -v 127.0.0.1| awk '{print $4}'`, { silent: true }).stdout.trim()
     }
     /**
      * @returns dns

package/{lib → dist}/classes/xdg.js

@@ -89,13 +89,15 @@ class Xdg {
              * LIGHTDM
              */
             if (pacman_1.default.packageIsInstalled('lightdm')) {
-                let lightdmConf = `${chroot}/etc/lightdm/lightdm.conf`;
-                let lightdmConfAutologin = `${chroot}/etc/lightdm/lightdm.conf.d/lightdm-autologin-greeter.conf`;
-                if (node_fs_1.default.existsSync(lightdmConfAutologin)) {
-                    shelljs_1.default.sed('-i', `autologin-user=${olduser}`, `autologin-user=${newuser}`, lightdmConfAutologin);
-                }
-                else if (node_fs_1.default.existsSync(lightdmConf)) {
-                    shelljs_1.default.sed('-i', `autologin-user=${olduser}`, `autologin-user=${newuser}`, lightdmConf);
+                let dc = `${chroot}/etc/lightdm/`;
+                let files = node_fs_1.default.readdirSync(dc);
+                for (const elem of files) {
+                    const curFile = dc + elem;
+                    let content = node_fs_1.default.readFileSync(curFile, 'utf8');
+                    let find = `[Seat:*]`;
+                    if (content.includes(find)) {
+                        shelljs_1.default.sed('-i', `autologin-user=${olduser}`, `autologin-user=${newuser}`, curFile);
+                    }
                 }
             }
             /**
@@ -103,25 +105,23 @@ class Xdg {
              */
             if (pacman_1.default.packageIsInstalled('sddm')) {
                 let sddmChanged = false;
-                // Cerco configurazione nel file sddm.conf
-                const fileConf = `${chroot}/etc/sddm.conf`;
-                if (node_fs_1.default.existsSync(fileConf)) {
-                    const content = node_fs_1.default.readFileSync(fileConf);
-                    if (content.includes('[Autologin]')) {
-                        shelljs_1.default.sed('-i', `User=${olduser}`, `User=${newuser}`, fileConf);
-                        sddmChanged = true;
-                    }
+                let curFile = `${chroot}/etc/sddm.conf`;
+                let content = node_fs_1.default.readFileSync(curFile, 'utf8');
+                let find = `[Autologin]`;
+                if (content.includes(find)) {
+                    shelljs_1.default.sed('-i', `User=${olduser}`, `User=${newuser}`, curFile);
+                    sddmChanged = true;
                 }
-                // Se non l'ho trovato, modifico /etc/sddm.conf.d/autologin.conf
                 if (!sddmChanged) {
-                    const dirConf = `${chroot}/etc/sddm.conf.d`;
-                    const autologin = `${dirConf}/autologin.conf`;
-                    if (node_fs_1.default.existsSync(autologin)) {
-                        shelljs_1.default.sed('-i', `User=${olduser}`, `User=${newuser}`, autologin);
-                    }
-                    else {
-                        const content = `[Autologin]\nUser=${newuser}\n`;
-                        node_fs_1.default.writeFileSync(autologin, content, 'utf-8');
+                    let dc = `${chroot}/etc/sddm.conf.d/`;
+                    let files = node_fs_1.default.readdirSync(dc);
+                    for (const elem of files) {
+                        const curFile = dc + elem;
+                        let content = node_fs_1.default.readFileSync(curFile, 'utf8');
+                        if (content.includes(find)) {
+                            shelljs_1.default.sed('-i', `User=${olduser}`, `User=${newuser}`, curFile);
+                            sddmChanged = true;
+                        }
                     }
                 }
             }
@@ -148,8 +148,6 @@ class Xdg {
                 }
                 const content = `[daemon]\nAutomaticLoginEnable=true\nAutomaticLogin=${newuser}\n`;
                 utils_1.default.write(gdmConf, content);
-                // shx.sed('-i', 'AutomaticLoginEnable=False', 'AutomaticLoginEnable=True', gdmConf)
-                // shx.sed('-i', `AutomaticLogin=${olduser}`, `AutomaticLogin=${newuser}`, gdmConf)
             }
         }
     }

package/dist/commands/cuckoo.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * cuckoo: proxy
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const network_1 = tslib_1.__importDefault(require("../classes/network"));
+const utils_1 = tslib_1.__importDefault(require("../classes/utils"));
+const pxe_1 = tslib_1.__importDefault(require("../classes/pxe"));
+const tftp = require('tftp');
+class Cuckoo extends core_1.Command {
+    async run(nest = '/home/eggs') {
+        const { args, flags } = await this.parse(Cuckoo);
+        utils_1.default.titles(this.id + ' ' + this.argv);
+        if (utils_1.default.isRoot()) {
+            const pxeRoot = nest + '/pxe';
+            const pxe = new pxe_1.default();
+            await pxe.fertilization();
+            await pxe.build();
+            const n = new network_1.default();
+            /**
+             * service proxy-dhcp
+             */
+            let dhcpOptions = {
+                subnet: n.cidr,
+                host: n.address,
+                tftpserver: n.address,
+                bios_filename: 'lpxelinux.0',
+                efi32_filename: 'ipxe32.efi',
+                efi64_filename: 'ipxe.efi'
+            };
+            pxe.dhcpStart(dhcpOptions);
+            /**
+             * service tftp
+             */
+            let tftpOptions = {
+                "host": n.address,
+                "port": 69,
+                "root": pxeRoot,
+                "denyPUT": true
+            };
+            await pxe.tftpStart(tftpOptions);
+            /**
+             * service http
+             */
+            await pxe.httpStart();
+        }
+        else {
+            utils_1.default.useRoot(this.id);
+        }
+    }
+}
+exports.default = Cuckoo;
+Cuckoo.description = 'PXE start with proxy-dhcp';
+Cuckoo.examples = [
+    `$ sudo eggs cuckoo
+start a PXE server with dhcp-proxy (can coexists with a real dhcp server)
+`,
+];
+Cuckoo.flags = {
+    help: core_1.Flags.help({ char: 'h' }),
+};