useNetServer = (ui, options) => new Promise((resolve, reject) => {
    const net = require('net');
    const {useV4Boot} = options;

    let waitTimeout = null;
    let ghostSocket = null;
    let started = false;
    let nodeCheck = false;

    const server = net.createServer((socket) => {
        ghostSocket = socket;

        socket.on('data', (data) => {
            let message;

            try {
                message = JSON.parse(data);
            } catch (err) {
                message = {started: false, ready: false, error: err};
            }

            const nodeVersion = getNodeVersion(message);
            if (!nodeCheck && nodeVersion && nodeVersion !== process.versions.node) {
                nodeCheck = true;
                ui.log(
                    `Warning: Ghost is running with node v${nodeVersion}.\n` +
                    `Your current node version is v${process.versions.node}.`,
                    'yellow'
                );
            }

            ui.logVerbose(`Received message from Ghost: ${util.inspect(message)}`, 'green');

            if (useV4Boot && message.started) {
                started = true;
                socket.destroy();
                ghostSocket = null;
                return;
            }

            /* istanbul ignore else */
            if (waitTimeout) {
                clearTimeout(waitTimeout);
            }

            socket.destroy();
            ghostSocket = null;

            server.close(() => {
                if ((!useV4Boot && message.started) || (useV4Boot && message.ready)) {
                    resolve();
                } else {
                    let {message: errMsg} = message.error;
                    if (useV4Boot && started) {
                        errMsg = `Ghost was able to start, but errored during boot with: ${errMsg}`;
                    }

                    reject(new errors.GhostError({
                        message: errMsg,
                        help: message.error.help,
                        suggestion: options.logSuggestion
                    }));
                }
            });
        });
    });

    waitTimeout = setTimeout(() => {
        if (ghostSocket) {
            ghostSocket.destroy();
        }

        ghostSocket = null;

        server.close(() => {
            reject(new errors.GhostError({
                message: 'Could not communicate with Ghost',
                suggestion: options.logSuggestion
            }));
        });
    }, options.netServerTimeoutInMS);

    server.listen({host: options.socketAddress.host, port: options.socketAddress.port});
})
@TODO: in theory it could happen that other clients connect, but tbh even with the port polling it was possible: you
       could just start a server on the Ghost port