const path = require('path');
const express = require('express');
const expressWs = require('express-ws');
const asyncHandler = require('express-async-handler');
const logger = require('cyber-express-logger');
const sftp = require('ssh2-sftp-client');
const crypto = require('crypto');
const mime = require('mime');
const cors = require('cors'); // Added CORS package
const bodyParser = require('body-parser');
const archiver = require('archiver');
const rawBodyParser = bodyParser.raw({
    limit: '16mb',
    type: '*/*'
});
const dayjs = require('dayjs');
const dayjsAdvancedFormat = require('dayjs/plugin/advancedFormat');
dayjs.extend(dayjsAdvancedFormat);
const utils = require('web-resources');
const Electron = require('electron');
const config = require('./config.json');

const normalizeRemotePath = remotePath => {
    remotePath = path.normalize(remotePath).replace(/\\/g, '/');
    const split = remotePath.split('/').filter(String);
    const joined = `/${split.join('/')}`;
    return joined;
};

const sessions = {};
const sessionActivity = {};
const connections = {}; // Store connection details

const getObjectHash = obj => {
    const hash = crypto.createHash('sha256');
    hash.update(JSON.stringify(obj));
    return hash.digest('hex');
}

/**
 * @param {sftp.ConnectOptions} opts
 * @returns {Promise<sftp>|null}
 * */
const getSession = async (res, opts) => {
    const hash = getObjectHash(opts);
    const address = `${opts.username}@${opts.host}:${opts.port}`;
    if (sessions[hash]) {
        console.log(`Using existing connection to ${address}`);
        sessionActivity[hash] = Date.now();
        return sessions[hash];
    }
    console.log(`Creating new connection to ${address}`);
    const session = new sftp();
    sessions[hash] = session;
    session.on('end', () => delete sessions[hash]);
    session.on('close', () => delete sessions[hash]);
    try {
        await session.connect(opts);
        sessionActivity[hash] = Date.now();
    } catch (error) {
        delete sessions[hash];
        console.log(`Connection to ${address} failed`);
        return res ? res.sendError(error) : null;
    }
    return session;
};

const srv = express();
expressWs(srv, undefined, {
    wsOptions: {
        maxPayload: 1024 * 1024 * 4
    }
});

// Enable CORS for all routes
srv.use(cors({
    origin: '*', // Allow all origins; can be restricted to specific origins if needed
    methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'], // Allow necessary methods
    allowedHeaders: ['Content-Type', 'sftp-host', 'sftp-port', 'sftp-username', 'sftp-password', 'sftp-key'], // Allow relevant headers
    credentials: false // Set to true if cookies or auth headers are needed
}));
srv.use(logger());
const staticDir = path.join(__dirname, 'web');
srv.use(express.static(staticDir));
console.log(`Serving static files from ${staticDir}`);

const initApi = asyncHandler(async (req, res, next) => {
    res.sendData = (status = 200) => res.status(status).json(res.data);
    res.sendError = (error, status = 400) => {
        res.data.success = false;
        res.data.error = `${error}`.replace('Error: ', '');
        res.sendData(status);
    }
    res.data = {
        success: true
    };
    req.connectionOpts = {
        host: req.headers['sftp-host'],
        port: req.headers['sftp-port'] || 22,
        username: req.headers['sftp-username'],
        password: decodeURIComponent(req.headers['sftp-password'] || '') || undefined,
        privateKey: decodeURIComponent(req.headers['sftp-key'] || '') || undefined,
    };
    if (!req.connectionOpts.host)
        return res.sendError('Missing host header');
    if (!req.connectionOpts.username)
        return res.sendError('Missing username header');
    if (!req.connectionOpts.password && !req.connectionOpts.privateKey)
        return res.sendError('Missing password or key header');
    req.session = await getSession(res, req.connectionOpts);
    if (!req.session) return;
    next();
});

// API endpoint to fetch connection details by connectionId
srv.get('/api/connect/:connectionId', asyncHandler(async (req, res) => {
    const connectionId = req.params.connectionId;
    const connection = connections[connectionId];
    if (!connection) {
        return res.status(404).json({ success: false, error: 'Connection not found' });
    }
    res.json({
        success: true,
        connection: {
            host: connection.host,
            port: connection.port,
            username: connection.username,
            password: connection.password,
            privateKey: connection.privateKey
        }
    });
}));

// Auto-connection endpoint
srv.post('/auto-connection', bodyParser.json(), asyncHandler(async (req, res) => {
    const connectionDetails = {
        host: req.body.host,
        port: req.body.port || 22,
        username: req.body.username,
        password: req.body.password || undefined,
        privateKey: req.body.privateKey || undefined
    };

    // Validate required fields
    if (!connectionDetails.host) {
        return res.status(400).json({ success: false, error: 'Missing host' });
    }
    if (!connectionDetails.username) {
        return res.status(400).json({ success: false, error: 'Missing username' });
    }
    if (!connectionDetails.password && !connectionDetails.privateKey) {
        return res.status(400).json({ success: false, error: 'Missing password or key' });
    }

    // Generate connection ID
    const connectionId = utils.randomHex(32);

    // Store connection details
    connections[connectionId] = {
        ...connectionDetails,
        created: Date.now()
    };

    // Test connection
    const session = await getSession(res, connectionDetails);
    if (!session) {
        delete connections[connectionId];
        return res.status(400).json({ success: false, error: 'Failed to establish connection' });
    }
    session.end();

    // Return connection URL
    const connectionUrl = `https://${req.get('host')}/connect/${connectionId}`;
    res.json({
        success: true,
        connectionId,
        connectionUrl
    });
}));

// Handle connection URL access
srv.get('/connect/:connectionId', asyncHandler(async (req, res) => {
    const connectionId = req.params.connectionId;
    if (!connections[connectionId]) {
        return res.status(404).send('Connection not found');
    }
    // Serve the main application page (index.html)
    res.sendFile(path.join(staticDir, 'index.html'));
}));

const keyedRequests = {};
srv.get('/api/sftp/key', initApi, async (req, res) => {
    res.data.key = utils.randomHex(32);
    keyedRequests[res.data.key] = req;
    res.sendData();
});
srv.get('/api/sftp/directories/list', initApi, async (req, res) => {
    /** @type {sftp} */
    const session = req.session;
    res.data.path = normalizeRemotePath(req.query.path);
    res.data.includesFiles = req.query.dirsOnly === 'true' ? false : true;
    if (!res.data.path) return res.sendError('Missing path', 400);
    try {
        res.data.list = await session.list(res.data.path);
        if (res.data.list && !res.data.includesFiles) {
            res.data.list = res.data.list.filter(item => item.type === 'd');
        }
        res.sendData();
    } catch (error) {
        res.sendError(error);
    }
});
srv.ws('/api/sftp/directories/search', async (ws, wsReq) => {
    if (!wsReq.query.key) return ws.close();
    const req = keyedRequests[wsReq.query.key];
    if (!req) return ws.close();
    // Add uniqueness to the connection opts
    // This forces a new connection to be created
    req.connectionOpts.ts = Date.now();
    // Create the session and throw an error if it fails
    /** @type {sftp} */
    const session = await getSession(null, req.connectionOpts);
    const sessionHash = getObjectHash(req.connectionOpts);
    if (!session) {
        ws.send(JSON.stringify({
            success: false,
            error: 'Failed to create session!'
        }));
        return ws.close();
    }
    // Normalize the file path or throw an error if it's missing
    const filePath = normalizeRemotePath(wsReq.query.path);
    if (!filePath) {
        ws.send(JSON.stringify({
            success: false,
            error: 'Missing path'
        }));
        return ws.close();
    }
    // Get the query
    const query = wsReq.query.query;
    if (!query) {
        ws.send(JSON.stringify({
            success: false,
            error: 'Missing query'
        }));
        return ws.close();
    }
    // Update the session activity periodically
    let interval;
    const updateActivity = () => {
        sessionActivity[sessionHash] = Date.now();
    };
    interval = setInterval(updateActivity, 1000 * 1);
    // Handle websocket closure
    let isClosed = false;
    ws.on('close', () => {
        console.log(`Directory search websocket closed`);
        session.end();
        clearInterval(interval);
        delete sessionActivity[sessionHash];
        isClosed = true;
    });
    // Listen for messages
    console.log(`Websocket opened to search directory ${req.connectionOpts.username}@${req.connectionOpts.host}:${req.connectionOpts.port} ${filePath}`);
    // Function to get a directory listing
    const scanDir = async (dirPath) => {
        try {
            const list = await session.list(dirPath);
            return [...list].sort((a, b) => {
                // Sort by name
                if (a.name < b.name) return -1;
                if (a.name > b.name) return 1;
                return 0;
            });
        } catch (error) {
            return null;
        }
    };
    // Function to send a list when there are enough files
    let matchedFiles = [];
    let lastSend = 0;
    const sendList = () => {
        if (matchedFiles.length > 0) {
            ws.send(JSON.stringify({
                success: true,
                status: 'list',
                list: matchedFiles
            }));
            matchedFiles = [];
            lastSend = Date.now();
        }
    };
    // Function to recursively search a directory
    const recurse = async dirPath => {
        if (isClosed) return;
        ws.send(JSON.stringify({
            success: true,
            status: 'scanning',
            path: dirPath
        }));
        const list = await scanDir(dirPath);
        if (!list) {
            ws.send(JSON.stringify({
                success: false,
                error: `Failed to scan directory ${dirPath}`
            }));
            return;
        }
        for (const file of list) {
            if (isClosed) return;
            file.path = `${dirPath}/${file.name}`;
            if (file.name.toLowerCase().includes(query.toLowerCase())) {
                matchedFiles.push(file);
            }
            if ((Date.now() - lastSend) > 1000) sendList();
            if (file.type == 'd') {
                await recurse(file.path);
            }
        }
    };
    // Start the search
    await recurse(filePath);
    if (isClosed) return;
    sendList();
    // Send a complete message
    ws.send(JSON.stringify({ success: true, status: 'complete' }));
    // Close the websocket
    ws.close();
});
srv.post('/api/sftp/directories/create', initApi, async (req, res) => {
    /** @type {sftp} */
    const session = req.session;
    res.data.path = normalizeRemotePath(req.query.path);
    if (!res.data.path) return res.sendError('Missing path', 400);
    try {
        await session.mkdir(res.data.path);
        res.sendData();
    } catch (error) {
        res.sendError(error);
    }
});
srv.delete('/api/sftp/directories/delete', initApi, async (req, res) => {
    /** @type {sftp} */
    const session = req.session;
    res.data.path = normalizeRemotePath(req.query.path);
    if (!res.data.path) return res.sendError('Missing path', 400);
    try {
        await session.rmdir(res.data.path, true);
        res.sendData();
    } catch (error) {
        res.sendError(error);
    }
});
srv.get('/api/sftp/files/exists', initApi, async (req, res) => {
    /** @type {sftp} */
    const session = req.session;
    res.data.path = normalizeRemotePath(req.query.path);
    if (!res.data.path) return res.sendError('Missing path', 400);
    try {
        const type = await session.exists(res.data.path);
        res.data.exists = type !== false;
        res.data.type = type;
        res.sendData();
    } catch (error) {
        res.sendError(error);
    }
});
srv.post('/api/sftp/files/create', initApi, rawBodyParser, async (req, res) => {
    /** @type {sftp} */
    const session = req.session;
    res.data.path = normalizeRemotePath(req.query.path);
    if (!res.data.path) return res.sendError('Missing path', 400);
    try {
        await session.put(req.body, res.data.path);
        res.sendData();
    } catch (error) {
        res.sendError(error);
    }
});
srv.put('/api/sftp/files/append', initApi, rawBodyParser, async (req, res) => {
    /** @type {sftp} */
    const session = req.session;
    res.data.path = normalizeRemotePath(req.query.path);
    if (!res.data.path) return res.sendError('Missing path', 400);
    try {
        await session.append(req.body, res.data.path);
        res.sendData();
    } catch (error) {
        res.sendError(error);
    }
});
srv.ws('/api/sftp/files/append', async (ws, wsReq) => {
    if (!wsReq.query.key) return ws.close();
    const req = keyedRequests[wsReq.query.key];
    if (!req) return ws.close();
    // Add uniqueness to the connection opts
    // This forces a new connection to be created
    req.connectionOpts.ts = Date.now();
    // Create the session and throw an error if it fails
    /** @type {sftp} */
    const session = await getSession(null, req.connectionOpts);
    const sessionHash = getObjectHash(req.connectionOpts);
    if (!session) {
        ws.send(JSON.stringify({
            success: false,
            error: 'Failed to create session!'
        }));
        return ws.close();
    }
    // Normalize the file path or throw an error if it's missing
    const filePath = normalizeRemotePath(wsReq.query.path);
    if (!filePath) {
        ws.send(JSON.stringify({
            success: false,
            error: 'Missing path'
        }));
        return ws.close();
    }
    // Handle websocket closure
    ws.on('close', () => {
        console.log(`File append websocket closed`);
        session.end();
        delete sessionActivity[sessionHash];
    });
    // Listen for messages
    console.log(`Websocket opened to append to ${req.connectionOpts.username}@${req.connectionOpts.host}:${req.connectionOpts.port} ${filePath}`);
    let isWriting = false;
    ws.on('message', async (data) => {
        // If we're already writing, send an error
        if (isWriting) {
            return ws.send(JSON.stringify({
                success: false,
                error: 'Writing in progress'
            }));
        }
        try {
            // Append the data to the file
            isWriting = true;
            await session.append(data, filePath);
            ws.send(JSON.stringify({ success: true }));
        } catch (error) {
            ws.send(JSON.stringify({
                success: false,
                error: error.toString()
            }));
            return ws.close();
        }
        isWriting = false;
        // Update the session activity
        sessionActivity[sessionHash] = Date.now();
    });
    // Send a ready message
    ws.send(JSON.stringify({ success: true, status: 'ready' }));
});
srv.delete('/api/sftp/files/delete', initApi, async (req, res) => {
    /** @type {sftp} */
    const session = req.session;
    res.data.path = normalizeRemotePath(req.query.path);
    if (!res.data.path) return res.sendError('Missing path', 400);
    try {
        await session.delete(res.data.path);
        res.sendData();
    } catch (error) {
        res.sendError(error);
    }
});
srv.put('/api/sftp/files/move', initApi, async (req, res) => {
    /** @type {sftp} */
    const session = req.session;
    res.data.pathOld = normalizeRemotePath(req.query.pathOld);
    res.data.pathNew = normalizeRemotePath(req.query.pathNew);
    if (!res.data.pathOld) return res.sendError('Missing source path', 400);
    if (!res.data.pathNew) return res.sendError('Missing destination path', 400);
    try {
        await session.rename(res.data.pathOld, res.data.pathNew);
        res.sendData();
    } catch (error) {
        res.sendError(error);
    }
});
srv.put('/api/sftp/files/copy', initApi, async (req, res) => {
    /** @type {sftp} */
    const session = req.session;
    res.data.pathSrc = normalizeRemotePath(req.query.pathSrc);
    res.data.pathDest = normalizeRemotePath(req.query.pathDest);
    if (!res.data.pathSrc) return res.sendError('Missing source path', 400);
    if (!res.data.pathDest) return res.sendError('Missing destination path', 400);
    try {
        await session.rcopy(res.data.pathSrc, res.data.pathDest);
        res.sendData();
    } catch (error) {
        res.sendError(error);
    }
});
srv.put('/api/sftp/files/chmod', initApi, async (req, res) => {
    /** @type {sftp} */
    const session = req.session;
    res.data.path = normalizeRemotePath(req.query.path);
    if (!res.data.path) return res.sendError('Missing path', 400);
    res.data.mode = req.query.mode;
    try {
        await session.chmod(res.data.path, res.data.mode);
        res.sendData();
    } catch (error) {
        res.sendError(error);
    }
});
srv.get('/api/sftp/files/stat', initApi, async (req, res) => {
    /** @type {sftp} */
    const session = req.session;
    res.data.path = normalizeRemotePath(req.query.path);
    if (!res.data.path) return res.sendError('Missing path', 400);
    let stats = null;
    try {
        stats = await session.stat(res.data.path);
    } catch (error) {
        return res.sendError(error, 404);
    }
    res.data.stats = stats;
    res.sendData();
});
const downloadSingleFileHandler = async (connectionOpts, res, remotePath, stats) => {
    let interval;
    // Gracefully handle any errors
    try {
        // Throw an error if it's not a file
        if (!stats.isFile) throw new Error('Not a file');
        // Add uniqueness to the connection opts
        // This forces a new connection to be created
        connectionOpts.ts = Date.now();
        // Create the session and throw an error if it fails
        const session = await getSession(res, connectionOpts);
        if (!session) throw new Error('Failed to create session');
        // Continuously update the session activity
        interval = setInterval(() => {
            const hash = getObjectHash(connectionOpts);
            sessionActivity[hash] = Date.now();
        }, 1000 * 1);
        // When the response closes, end the session
        const handleClose = () => {
            clearInterval(interval);
            session.end();
        };
        res.on('end', handleClose);
        res.on('close', handleClose);
        res.on('error', handleClose);
        // Set response headers
        res.setHeader('Content-Type', mime.getType(remotePath) || 'application/octet-stream');
        res.setHeader('Content-Disposition', `attachment; filename="${path.basename(remotePath)}"`);
        res.setHeader('Content-Length', stats.size);
        // Start the download
        console.log(`Starting download: ${connectionOpts.username}@${connectionOpts.host}:${connectionOpts.port} ${remotePath}`);
        await session.get(remotePath, res);
        // Force-end the response
        res.end();
        // On error, clear the interval and send a 400 response
    } catch (error) {
        clearInterval(interval);
        res.status(400).end();
    }
};
const downloadMultiFileHandler = async (connectionOpts, res, remotePaths, rootPath = '/') => {
    rootPath = normalizeRemotePath(rootPath);
    let interval;
    // Gracefully handle any errors
    try {
        // Add uniqueness to the connection opts
        // This forces a new connection to be created
        connectionOpts.ts = Date.now();
        // Create the session and throw an error if it fails
        const session = await getSession(res, connectionOpts);
        if (!session) throw new Error('Failed to create session');
        // Continuously update the session activity
        setInterval(() => {
            const hash = getObjectHash(connectionOpts);
            sessionActivity[hash] = Date.now();
        }, 1000 * 1);
        // Set response headers
        let fileName = `Files (${path.basename(rootPath) || 'Root'})`;
        if (remotePaths.length == 1)
            fileName = path.basename(remotePaths[0]);
        res.setHeader('Content-Disposition', `attachment; filename="${encodeURIComponent(fileName)}.zip"`);
        // Create the archive and start piping to the response
        const archive = archiver('zip');
        archive.pipe(res);
        // When the response closes, end the session
        const handleClose = () => {
            clearInterval(interval);
            archive.end();
            session.end();
        };
        res.on('end', handleClose);
        res.on('close', handleClose);
        res.on('error', handleClose);
        // Add file to the archive
        const addToArchive = async (remotePath) => {
            const archivePath = normalizeRemotePath(remotePath.replace(rootPath, ''));
            console.log(`Zipping: ${connectionOpts.username}@${connectionOpts.host}:${connectionOpts.port} ${remotePath}`);
            // Get file read stream
            const stream = session.createReadStream(remotePath);
            const waitToEnd = new Promise(resolve => {
                stream.on('end', resolve);
            });
            // Add file to archive
            archive.append(stream, {
                name: archivePath
            });
            // Wait for the stream to end
            await waitToEnd;
        };
        // Recurse through directories and archive files
        const recurse = async (remotePath) => {
            try {
                const stats = await session.stat(remotePath);
                if (stats.isFile) {
                    await addToArchive(remotePath);
                } else if (stats.isDirectory) {
                    const list = await session.list(remotePath);
                    for (const item of list) {
                        const subPath = `${remotePath}/${item.name}`;
                        if (item.type === '-') {
                            await addToArchive(subPath);
                        } else {
                            await recurse(subPath);
                        }
                    }
                }
            } catch (error) { }
        };
        for (const remotePath of remotePaths) {
            await recurse(remotePath);
        }
        // Finalize the archive
        archive.on('close', () => res.end());
        archive.finalize();
        // On error, clear the interval and send a 400 response
    } catch (error) {
        clearInterval(interval);
        res.status(400).end();
    }
};
srv.get('/api/sftp/files/get/single', initApi, async (req, res) => {
    /** @type {sftp} */
    const session = req.session;
    // Get the normalized path and throw an error if it's missing
    const remotePath = normalizeRemotePath(req.query.path);
    if (!remotePath) return res.sendError('Missing path', 400);
    try {
        const stats = await session.stat(remotePath);
        // Handle the download
        await downloadSingleFileHandler(req.connectionOpts, res, remotePath, stats);
    } catch (error) {
        res.status(400).end();
    }
});
const rawDownloads = {};
srv.get('/api/sftp/files/get/single/url', initApi, async (req, res) => {
    /** @type {sftp} */
    const session = req.session;
    // Get the normalized path and throw an error if it's missing
    res.data.path = normalizeRemotePath(req.query.path);
    if (!res.data.path) return res.sendError('Missing path', 400);
    // Get path stats and throw an error if it's not a file
    let stats = null;
    try {
        stats = await session.stat(res.data.path);
        if (!stats?.isFile) throw new Error('Not a file');
    } catch (error) {
        return res.sendError(error);
    }
    // Generate download URL
    const id = utils.randomHex(8);
    res.data.download_url = `https://${req.get('host')}/dl/${id}`;
    // Create download handler
    rawDownloads[id] = {
        created: Date.now(),
        paths: [res.data.path],
        handler: async (req2, res2) => {
            // Handle the download
            await downloadSingleFileHandler(req.connectionOpts, res2, res.data.path, stats);
        }
    }
    res.sendData();
});
srv.get('/api/sftp/files/get/multi/url', initApi, async (req, res) => {
    try {
        // Get the normalized path and throw an error if it's missing
        res.data.paths = JSON.parse(req.query.paths);
        if (!res.data.paths) throw new Error('Missing path(s)');
    } catch (error) {
        return res.sendError(error);
    }
    // Generate download URL
    const id = utils.randomHex(8);
    res.data.download_url = `https://${req.get('host')}/dl/${id}`;
    // Create download handler
    rawDownloads[id] = {
        created: Date.now(),
        paths: res.data.paths,
        isZip: true,
        handler: async (req2, res2) => {
            // Handle the download
            await downloadMultiFileHandler(req.connectionOpts, res2, res.data.paths, req.query.rootPath);
        }
    }
    res.sendData();
});
srv.get('/dl/:id', async (req, res) => {
    // Get the download handler
    const entry = rawDownloads[req.params.id];
    if (!entry) return res.status(404).end();
    // If the user agent looks like a bot
    if (req.get('user-agent').match(/(bot|scrape)/)) {
        // Send some HTML
        res.setHeader('Content-Type', 'text/html');
        const html = /*html*/`
            <html>
                <head>
                    <title>Download shared files</title>
                    <meta property="og:site_name" content="SFTP Browser" />
                    <meta property="og:title" content="Shared ${entry.isZip ? 'files' : 'file'}" />
                    <meta property="og:description" content="Click to download ${entry.isZip ? `these files compressed into a zip.` : `${path.basename(entry.paths[0])}.`} This link will expire on ${dayjs(entry.created + (1000 * 60 * 60 * 24)).format('YYYY-MM-DD [at] hh:mm:ss ([GMT]Z)')}." />
                    <meta name="theme-color" content="#1f2733">
                    <meta property="og:image" content="https://${req.get('host')}/icon.png" />
                </head>
                <body>
                    <p>Click <a href="${req.originalUrl}">here</a> to download the file.</p>
                </body>
            </html>
        `;
        res.send(html);
    } else {
        entry.handler(req, res);
    }
});

srv.use((req, res) => res.status(404).end());

setInterval(() => {
    // Delete inactive sessions
    for (const hash in sessions) {
        const lastActive = sessionActivity[hash];
        if (!lastActive) continue;
        if ((Date.now() - lastActive) > 1000 * 60 * 5) {
            console.log(`Deleting inactive session`);
            sessions[hash].end();
            delete sessions[hash];
            delete sessionActivity[hash];
        }
    }
    // Delete unused downloads
    for (const id in rawDownloads) {
        const download = rawDownloads[id];
        if ((Date.now() - download.created) > 1000 * 60 * 60 * 12) {
            console.log(`Deleting unused download`);
            delete rawDownloads[id];
        }
    }
    // Delete expired connections
    for (const id in connections) {
        const connection = connections[id];
        if ((Date.now() - connection.created) > 1000 * 60 * 60 * 12) {
            console.log(`Deleting expired connection ${id}`);
            delete connections[id];
        }
    }
}, 1000 * 30);

if (Electron.app) {
    Electron.app.whenReady().then(async () => {
        // Start the server
        let port = 8001 + Math.floor(Math.random() * 999);
        await new Promise(resolve => {
            srv.listen(port, () => {
                console.log(`App server listening on port ${port}`)
                resolve();
            });
        });
        // Open the window
        const window = new Electron.BrowserWindow({
            width: 1100,
            height: 720,
            autoHideMenuBar: true,
            minWidth: 320,
            minHeight: 200
        });
        window.loadURL(`http://localhost:${port}`);
        // Quit the app when all windows are closed
        // unless we're on macOS
        Electron.app.on('window-all-closed', () => {
            if (process.platform !== 'darwin') Electron.app.quit();
        });
    });
} else {
    srv.listen(config.port, () => console.log(`Standalone server listening on port ${config.port}`));
}