index.mjs

#!/usr/bin/env node
import axios from 'axios';
import { spawn } from 'child_process';
import kill from 'kill-port';
import net from 'net';
import open from "open";
import yargs from 'yargs';
import { hideBin } from 'yargs/helpers';

const snifferManagerAxios = axios.create({ baseURL: "http://localhost:5012" });

function checkAdminPort(port = 5012) {
    return new Promise((resolve) => {
        const tester = net.createConnection({ port }, () => {
            tester.end();
            resolve(true);
        });

        tester.on('error', () => {
            resolve(false);
        });
    });
}

async function startAdmin() {
    const isAdminPortAvailable = await checkAdminPort();
    console.log("Admin port available: " + isAdminPortAvailable);

    if (isAdminPortAvailable) {
        console.log("Port 5012 is already taken");
        return;
    }

    const childProcess = spawn('npm', ['run', "sniffer"], {
        detached: true,
        stdio: 'ignore',
    });

    childProcess.unref();
}

async function killAdmin(port = 5012) {
    kill(port, 'tcp')
        .then(() => console.log("Admin is killed"))
        .catch((e) => {
            console.log("Failed to kill admin");
            console.error(e.message);
        })
}

function startDashboard() {
    const childProcess = spawn('node', ['dashboard-main.mjs'], {
        detached: true,
        stdio: 'ignore',
    });

    childProcess.unref();
}

function openDashboard(port = 3000) {
    open(`http://localhost:${port}`);
}

async function killDashboard(port = 3000) {
    kill(port, 'tcp')
        .then(() => console.log("Dashboard is killed"))
        .catch((e) => {
            console.log("Failed to kill the dashboard");
            console.error(e.message);
        })
}

async function createSniffer(port, downstreamUrl, name) {
    const sniffers = await snifferManagerAxios.post("/sharkio/sniffer", {
        name,
        port,
        downstreamUrl
    }, {
        headers: {
            'Content-Type': "application/json"
        }
    }).then((res) => res.data);

    console.log(JSON.stringify(sniffers));
}

async function listSniffers() {
    await snifferManagerAxios.get("/sharkio/sniffer").then((res) => {
        console.log(JSON.stringify(res.data));
    });
}

async function startSniffer(port) {
    await snifferManagerAxios.post(`sharkio/sniffer/${port}/actions/start`).then((res) => {
        console.log(JSON.stringify(res.data));
    }).catch((e) => {
        console.error("Failed to start sniffer");
    });
}

async function stopSniffer(port) {
    await snifferManagerAxios.post(`sharkio/sniffer/${port}/actions/stop`).then((res) => {
        console.log(JSON.stringify(res.data));
    }).catch((e) => {
        console.error("Failed to stop sniffer");
    });
}

async function removeSniffer(port) {
    await snifferManagerAxios.delete(`sharkio/sniffer/${port}`).then((res) => {
        console.log(JSON.stringify(res.data));
    }).catch((e) => {
        console.error("Failed to remove sniffer");
    });
}

yargs(hideBin(process.argv))
    .demandCommand()
    .scriptName("")
    .command('start', 'Start dashboard and proxy manager', (yargs) => {
        return yargs
    }, async (argv) => {
        await startAdmin();
        await startDashboard();
        await openDashboard();
    })
    .command('dashboard [command]', 'Dashboard server', (yargs) => {
        return yargs
            .command("start", 'Starting dashboard server', (yargs) => {
                return yargs
            }, () => {
                console.log("Starting dashboard server");
                startDashboard();
            })
            .command("open", 'Open the dashboard', (yargs) => {
                return yargs
            }, () => {
                console.log("Opening dashboard server");
                openDashboard();
            })
            .command('kill', 'Kill the dashboard server', (yargs) => {
                return yargs
            }, (argv) => {
                console.log("Killing the dashboard server")
                killDashboard();
            }).demandCommand()
    })
    .command('admin [command]', 'Proxy admin server', (yargs) => {
        return yargs
            .command('sniffer [command]', 'Proxy manager commands', (yargs) => {
                return yargs
                    .command("create [port] [downstreamUrl] [name]", 'Create a new sniffer', (yargs) => {
                        return yargs
                            .option("port")
                            .option("downstreamUrl")
                            .option("name")
                            .demandOption("port")
                            .demandOption("downstreamUrl")
                            .demandOption("name")
                    }, async (argv) => {
                        console.log("Creating a new sniffer")

                        await createSniffer(argv.port, argv.downstreamUrl, argv.name);
                    })
                    .command("list", 'List sniffers', (yargs) => {
                        return yargs
                    }, async (argv) => {
                        await listSniffers();
                    })
                    .command("start [port]", "Start a sniffer", (yargs) => {
                        return yargs
                            .option("port")
                            .demandOption("port");
                    }, async (argv) => {
                        await startSniffer(argv.port);
                    })
                    .command("stop [port]", "Stop a sniffer", (yargs) => {
                        return yargs
                            .option("port")
                            .demandOption("port");
                    }, async (argv) => {
                        await stopSniffer(argv.port);
                    })
                    .command("remove [port]", "Stop a sniffer", (yargs) => {
                        return yargs
                            .option("port")
                            .demandOption("port");
                    }, async (argv) => {
                        await removeSniffer(argv.port);
                    })
            },
                (argv) => {
                }
            )
            .command("start", 'Start admin server', (yargs) => {
                return yargs
            }, () => {
                console.log("Starting admin servers");
                startAdmin();
            })
            .command('kill', 'Kill the admin server', (yargs) => {
                return yargs
            }, (argv) => {
                console.log("Killing the admin server");
                killAdmin();
            }).demandCommand()
            .demandCommand()
    })
    .parse()