omegga 0.1.85 → 1.0.2

package/dist/webserver/backend/api.js

@@ -0,0 +1,685 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = __importDefault(require("../../logger"));
+const player_1 = __importDefault(require("../../omegga/player"));
+const chat_1 = require("../../util/chat");
+const color_1 = require("../../util/color");
+const time_1 = require("../../util/time");
+const uuid = __importStar(require("../../util/uuid"));
+const express_1 = __importDefault(require("express"));
+const json_rpc_2_0_1 = require("json-rpc-2.0");
+const lodash_1 = __importDefault(require("lodash"));
+const pkg = require('../../../package.json');
+function default_1(server, io) {
+    const { database, omegga } = server;
+    // open API is accessible without auth
+    const openApi = express_1.default.Router();
+    const api = express_1.default.Router();
+    // check if this is the first user in the database
+    openApi.get('/first', async (req, res) => res.json(await database.isFirstUser()));
+    // login / create admin user route
+    openApi.post('/auth', async (req, res) => {
+        // body is username and password
+        if (typeof req.body !== 'object' ||
+            typeof req.body.username !== 'string' ||
+            typeof req.body.password !== 'string') {
+            return res.status(422).json({ message: 'invalid body' });
+        }
+        const { username, password } = req.body;
+        // username regex
+        if (!username.match(/^\w{0,32}$/)) {
+            return res.status(422).json({ message: 'invalid body' });
+        }
+        // if this is the first user, create it as the admin user
+        const isFirst = await database.isFirstUser();
+        let user;
+        if (isFirst) {
+            user = await database.createAdminUser(username, username === '' ? '' : password);
+        }
+        else {
+            user = await database.authUser(username, password);
+        }
+        if (user) {
+            req.session.userId = user._id;
+            req.session.save();
+            res.status(200).json({});
+        }
+        else {
+            res.status(404).json({ message: 'no user found' });
+        }
+    });
+    // kill a session
+    api.get('/logout', (req, res) => {
+        req.session.destroy(e => {
+            res.status(e ? 500 : 200).json({});
+        });
+    });
+    // authentication middleware for api
+    api.all('*', (req, _res, next) => {
+        (async () => {
+            const user = await database.findUserById(req.session.userId);
+            if (!user || user.isBanned)
+                return next(new Error('unauthorized'));
+            // req.user = user;
+            next();
+        })();
+    });
+    // websocket data
+    io.on('connection', socket => {
+        // let this user receive messages directed to this user
+        socket.join('user:' + socket.data.user._id);
+        database.getRoles().then(roles => {
+            socket.emit('data', {
+                roles,
+                version: pkg.version,
+                canLogOut: socket.data.user.username !== '',
+                now: Date.now(),
+                userless: !socket.data.user.username,
+                user: {
+                    username: socket.data.user.username || 'Admin',
+                    isOwner: socket.data.user.isOwner,
+                    roles: socket.data.user.roles,
+                },
+            });
+        });
+        // logging for this user in the console for web ui actions
+        const usernameText = `[${(socket.data.user.username || 'Admin').brightMagenta}]`;
+        const log = (...args) => logger_1.default.logp(usernameText, ...args);
+        const error = (...args) => logger_1.default.errorp(usernameText, ...args);
+        // rpc connection
+        const rpcServer = new json_rpc_2_0_1.JSONRPCServer();
+        const rpcClient = new json_rpc_2_0_1.JSONRPCClient(async (data) => {
+            socket.emit('rpc', data);
+        });
+        const rpc = new json_rpc_2_0_1.JSONRPCServerAndClient(rpcServer, rpcClient);
+        socket.on('rpc', data => {
+            if (data && typeof data === 'object') {
+                try {
+                    rpc.receiveAndSend(data);
+                }
+                catch (e) {
+                    // silently discard broken rpc requests
+                }
+            }
+        });
+        // send chat message from web ui
+        // TODO: check if this user has a role with permission to chat
+        rpc.addMethod('chat', async ([message]) => {
+            if (typeof message !== 'string')
+                return;
+            if (message.length > 140)
+                message = message.slice(0, 140);
+            // create fake user
+            const user = {
+                name: socket.data.user.username || 'Admin',
+                id: socket.data.user.playerId,
+                color: 'ff00ff',
+                web: true,
+            };
+            // create database entry, send to web ui
+            io.to('chat').emit('chat', await database.addChatLog('msg', user, message));
+            // broadcast to chat
+            server.omegga.broadcast(`"[<b><color=\\"ff00ff\\">${user.name}</></>]: ${(0, chat_1.parseLinks)((0, chat_1.sanitize)(message))}"`);
+            // broadcast to terminal
+            logger_1.default.log(`[${user.name.brightMagenta.underline}]: ${message}`);
+            return 'ok';
+        });
+        // read recent chat messages
+        // TODO: add permission check
+        rpc.addMethod('chat.recent', () => {
+            return database.getChats({ sameServer: true });
+        });
+        // find chat messages after a certain time
+        // TODO: add permission check
+        rpc.addMethod('chat.history', ([{ after, before }]) => {
+            return database.getChats({ after, before });
+        });
+        // see what days chat messages were sent
+        // TODO: add permission check
+        rpc.addMethod('chat.calendar', () => {
+            return database.calendar.years;
+        });
+        // get the list of plugins
+        // TODO: add permission check
+        rpc.addMethod('plugins.list', () => {
+            return lodash_1.default.sortBy(omegga.pluginLoader.plugins.map(p => ({
+                name: p.getName(),
+                documentation: p.getDocumentation(),
+                path: p.shortPath,
+                isLoaded: p.isLoaded(),
+                isEnabled: p.isEnabled(),
+            })), p => p.name.toLowerCase());
+        });
+        // get information on a specific plugin
+        // TODO: add permission check
+        rpc.addMethod('plugin.get', async ([shortPath]) => {
+            const plugin = omegga.pluginLoader.plugins.find(p => p.shortPath === shortPath);
+            if (!plugin)
+                return null;
+            // get the plugin configs
+            const [defaultConfig, config, objCount] = await Promise.all([
+                plugin.storage.getDefaultConfig(),
+                plugin.storage.getConfig(),
+                plugin.storage.count(),
+            ]);
+            return {
+                name: plugin.getName(),
+                format: plugin.constructor.getFormat(),
+                info: plugin.getInfo(),
+                documentation: plugin.getDocumentation(),
+                config,
+                defaultConfig,
+                objCount,
+                path: plugin.shortPath,
+                isLoaded: plugin.isLoaded(),
+                isEnabled: plugin.isEnabled(),
+            };
+        });
+        // get a paginated list of players
+        // TODO: add permission check
+        rpc.addMethod('players.list', async ([{ page = 0, search = '', sort = 'name', direction = '1', filter = '', } = {},]) => {
+            const banList = (omegga.getBanList() || { banList: {} }).banList;
+            // get the ban list
+            const now = Date.now();
+            let limitId;
+            // if the filter is set to banned players only, limit player results by ids in the current ban list
+            if (filter === 'banned') {
+                limitId = Object.keys(banList).filter(b => banList[b].expires <= banList[b].created ||
+                    (0, time_1.parseBrickadiaTime)(banList[b].expires) > Date.now());
+            }
+            const resp = await database.getPlayers({
+                page,
+                search,
+                sort,
+                direction,
+                limitId,
+            });
+            for (const player of resp.players) {
+                player.seenAgo = now - player.lastSeen;
+                player.createdAgo = now - player.created;
+                const foundBan = banList[player.id];
+                if (foundBan) {
+                    const created = (0, time_1.parseBrickadiaTime)(foundBan.created);
+                    const expires = (0, time_1.parseBrickadiaTime)(foundBan.expires);
+                    // create a clone of the object
+                    let currentBan = Object.assign(Object.assign({}, foundBan), { 
+                        // parse the times in the current ban
+                        created,
+                        expires, duration: expires - created, remainingTime: expires - now, 
+                        // lookup banner name
+                        bannerName: lodash_1.default.get(omegga.getNameCache(), ['savedPlayerNames', foundBan.bannerId], '') });
+                    // if the ban is expired, it should not be listed
+                    if (currentBan.expires < now && currentBan.duration > 0)
+                        currentBan = null;
+                    player.ban = currentBan;
+                }
+            }
+            return resp;
+        });
+        // get a specific player's info
+        // TODO: add permission check
+        rpc.addMethod('player.get', async ([id]) => {
+            const entry = await database.getPlayer(id);
+            if (!entry)
+                return null;
+            const now = Date.now();
+            entry.seenAgo = now - entry.lastSeen;
+            entry.createdAgo = now - entry.created;
+            for (const n of entry.nameHistory)
+                n.ago = now - n.date;
+            // combine player roles with server roles
+            const playerRoles = player_1.default.getRoles(omegga, id) || [];
+            const { roles: serverRoles } = omegga.getRoleSetup();
+            // Get banner name and duration from list of bans
+            for (const b of entry.banHistory) {
+                b.duration = b.expires - b.created;
+                // lookup banner name
+                b.bannerName = lodash_1.default.get(omegga.getNameCache(), ['savedPlayerNames', b.bannerId], '');
+            }
+            // Get kicker name from list of kicks
+            for (const b of entry.kickHistory) {
+                // lookup banner name
+                b.kickerName = lodash_1.default.get(omegga.getNameCache(), ['savedPlayerNames', b.kickerId], '');
+            }
+            const foundBan = (omegga.getBanList() || { banList: {} }).banList[id];
+            let currentBan = null;
+            if (foundBan) {
+                // parse the times in the current ban
+                const created = (0, time_1.parseBrickadiaTime)(foundBan.created);
+                const expires = (0, time_1.parseBrickadiaTime)(foundBan.expires);
+                // create a clone of the object
+                currentBan = Object.assign(Object.assign({}, foundBan), { created,
+                    expires, duration: expires - created, remainingTime: expires - now, 
+                    // lookup banner name
+                    bannerName: lodash_1.default.get(omegga.getNameCache(), ['savedPlayerNames', foundBan.bannerId], '') });
+                // if the ban is expired, it should not be listed
+                if (currentBan.expires < now && currentBan.duration > 0)
+                    currentBan = null;
+            }
+            return Object.assign(Object.assign({}, entry), { 
+                // player is host
+                isHost: omegga.getHostId() === id, isOnline: omegga.players.some(p => p.id === id), 
+                // player's current ban state
+                currentBan, 
+                // all player's roles  w/ colors
+                roles: playerRoles.map(r => {
+                    // default role color is white
+                    let color = 'ffffff';
+                    // find the role (if it exists) and get the color
+                    const role = serverRoles.find(sr => sr.name.toLowerCase() === r.toLowerCase());
+                    if (role && role.bHasColor)
+                        color = (0, color_1.rgbToHex)(role.color);
+                    return {
+                        name: r,
+                        color: color,
+                    };
+                }) });
+        });
+        rpc.addMethod('player.ban', async ([id, duration = -1, reason = 'No Reason']) => {
+            var _a, _b, _c;
+            // validate inputs
+            if (typeof duration !== 'number')
+                return false;
+            if (typeof id !== 'string' || !uuid.match(id))
+                return false;
+            if (typeof reason !== 'string' || reason.length > 128)
+                return false;
+            reason = reason.replace(/\n/g, ' ').replace(/"/g, "'");
+            log('Banning player', (_c = (_b = (_a = omegga.getNameCache()) === null || _a === void 0 ? void 0 : _a.savedPlayerNames) === null || _b === void 0 ? void 0 : _b[id].yellow) !== null && _c !== void 0 ? _c : 'with id ' + id.yellow);
+            // ban the user
+            omegga.writeln(`Chat.Command /Ban "${id}" ${duration} "${reason}"`);
+            let listener;
+            // wait for the ban to update
+            const ok = await Promise.race([
+                new Promise(resolve => {
+                    database.on('update.bans', (listener = () => {
+                        const banList = (omegga.getBanList() || { banList: {} })
+                            .banList;
+                        if (banList[id]) {
+                            const entry = {
+                                type: 'banHistory',
+                                banned: id,
+                                bannerId: null,
+                                created: (0, time_1.parseBrickadiaTime)(banList[id].created),
+                                expires: (0, time_1.parseBrickadiaTime)(banList[id].expires),
+                                reason: banList[id].reason,
+                            };
+                            database.stores.players.update(entry, { $set: entry }, { upsert: true });
+                            resolve(true);
+                        }
+                    }));
+                }),
+                new Promise(resolve => setTimeout(() => resolve(false), 5000)),
+            ]);
+            database.off('update.bans', listener);
+            return ok;
+        });
+        rpc.addMethod('player.kick', async ([id, reason = 'No Reason']) => {
+            // validate inputs
+            if (typeof id !== 'string' || !uuid.match(id))
+                return false;
+            if (typeof reason !== 'string' || reason.length > 128)
+                return false;
+            reason = reason.replace(/\n/g, ' ').replace(/"/g, "'");
+            // ensure player exists
+            const player = omegga.players.find(p => p.id === id);
+            if (!player)
+                return false;
+            log('Kicking player', player.name.yellow);
+            // kick the user
+            omegga.writeln(`Chat.Command /Kick "${id}" "${reason}"`);
+            // wait for the player to disconnect
+            const ok = await Promise.race([
+                new Promise(resolve => {
+                    this.omegga.once('leave', async (leavingPlayer) => {
+                        if (leavingPlayer.id === id) {
+                            resolve(true);
+                            // add kick to database
+                            const entry = {
+                                type: 'kickHistory',
+                                kicked: id,
+                                kickerId: null,
+                                created: Date.now(),
+                                reason,
+                            };
+                            await database.stores.players.update(entry, { $set: entry }, { upsert: true });
+                        }
+                    });
+                }),
+                new Promise(resolve => setTimeout(() => resolve(false), 5000)),
+            ]);
+            return ok;
+        });
+        rpc.addMethod('player.unban', async ([id]) => {
+            var _a, _b, _c;
+            // validate inputs
+            if (typeof id !== 'string' || !uuid.match(id))
+                return false;
+            // check if user is banned
+            const banList = (omegga.getBanList() || { banList: {} }).banList;
+            if (!banList[id] || (0, time_1.parseBrickadiaTime)(banList[id].expires) < Date.now())
+                return false;
+            log('Unbanning player', (_c = (_b = (_a = omegga.getNameCache()) === null || _a === void 0 ? void 0 : _a.savedPlayerNames) === null || _b === void 0 ? void 0 : _b[id].yellow) !== null && _c !== void 0 ? _c : 'with id ' + id.yellow);
+            // unban the user
+            omegga.writeln(`Chat.Command /Unban "${id}"`);
+            let listener;
+            // wait for the ban to update
+            const ok = await Promise.race([
+                new Promise(resolve => {
+                    database.on('update.bans', (listener = () => {
+                        const banList = (omegga.getBanList() || { banList: {} }).banList;
+                        if (!banList[id] ||
+                            (0, time_1.parseBrickadiaTime)(banList[id].expires) < Date.now())
+                            resolve(true);
+                    }));
+                }),
+                new Promise(resolve => setTimeout(() => resolve(false), 5000)),
+            ]);
+            database.off('update.bans', listener);
+            return ok;
+        });
+        rpc.addMethod('player.clearbricks', async ([id]) => {
+            var _a, _b, _c, _d;
+            // validate inputs
+            if (typeof id !== 'string' || !uuid.match(id))
+                return false;
+            log('Clearing bricks for player', (_d = (_c = (_b = (_a = omegga.getNameCache()) === null || _a === void 0 ? void 0 : _a.savedPlayerNames) === null || _b === void 0 ? void 0 : _b[id]) === null || _c === void 0 ? void 0 : _c.yellow) !== null && _d !== void 0 ? _d : 'with id ' + id.yellow);
+            // unban the user
+            omegga.writeln(`Bricks.Clear "${id}"`);
+            return true;
+        });
+        // set plugin config
+        // TODO: add permission check
+        rpc.addMethod('plugin.config', async ([shortPath, config]) => {
+            const plugin = omegga.pluginLoader.plugins.find(p => p.shortPath === shortPath);
+            if (!plugin)
+                return null;
+            await plugin.storage.setConfig(config);
+            // TODO: validate configs
+            return true;
+        });
+        // reload all plugins (and scan for new ones)
+        // TODO: add permission check
+        rpc.addMethod('plugins.reload', async () => {
+            if (!omegga.pluginLoader) {
+                error('Omegga is not using plugins');
+                return false;
+            }
+            log('Unloading current plugins');
+            let success = await omegga.pluginLoader.unload();
+            if (!success) {
+                error('Could not unload all plugins');
+                return false;
+            }
+            log('Scanning for new plugins');
+            success = await omegga.pluginLoader.scan();
+            if (!success) {
+                error('Could not scan for plugins');
+                return false;
+            }
+            log('Starting plugins');
+            success = await omegga.pluginLoader.reload();
+            if (success) {
+                const plugins = omegga.pluginLoader.plugins
+                    .filter(p => p.isLoaded())
+                    .map(p => p.getName());
+                log('Loaded', (plugins.length + '').yellow, 'plugins:', plugins);
+                return true;
+            }
+            else {
+                error('Could not load all plugins');
+                return false;
+            }
+        });
+        // unload a plugin
+        // TODO: add permission check
+        rpc.addMethod('plugin.unload', async ([shortPath]) => {
+            const plugin = omegga.pluginLoader.plugins.find(p => p.shortPath === shortPath);
+            if (!plugin)
+                return false;
+            if (!plugin.isLoaded())
+                return false;
+            log('Unloading'.red, 'plugin', plugin.getName().yellow);
+            return await plugin.unload();
+        });
+        // load a plugin
+        // TODO: add permission check
+        rpc.addMethod('plugin.load', async ([shortPath]) => {
+            const plugin = omegga.pluginLoader.plugins.find(p => p.shortPath === shortPath);
+            if (!plugin)
+                return false;
+            if (plugin.isLoaded() || !plugin.isEnabled())
+                return false;
+            log('Loading'.green, 'plugin', plugin.getName().yellow);
+            return await plugin.load();
+        });
+        // enable/disable a plugin
+        // TODO: add permission check
+        rpc.addMethod('plugin.toggle', ([shortPath, enabled]) => {
+            if (typeof enabled !== 'boolean')
+                return;
+            const plugin = omegga.pluginLoader.plugins.find(p => p.shortPath === shortPath);
+            if (!plugin)
+                return false;
+            try {
+                plugin.setEnabled(enabled);
+                log(enabled ? 'Enabled'.green : 'Disabled'.red, 'plugin', plugin.getName().yellow);
+                return true;
+            }
+            catch (e) {
+                error('Error', enabled ? 'enabling'.green : 'disabling'.red, 'plugin', plugin.getName().yellow);
+                return false;
+            }
+        });
+        // get a list of roles
+        // TODO: add permission check
+        rpc.addMethod('roles.list', () => {
+            return lodash_1.default.sortBy(omegga.getRoleSetup().roles, p => p.name.toLowerCase());
+        });
+        // get a paginated list of users
+        // TODO: add permission check
+        rpc.addMethod('users.list', async ([{ page = 0, search = '', sort = 'name', direction = '1' } = {}]) => {
+            const resp = await database.getUsers({ page, search, sort, direction });
+            const now = Date.now();
+            resp.users = resp.users.map(user => (Object.assign(Object.assign({}, user), { seenAgo: user.lastOnline ? now - user.lastOnline : Infinity, createdAgo: now - user.created })));
+            return resp;
+        });
+        // create a new user (host only at the moment)
+        // TODO: add permission check
+        rpc.addMethod('users.create', async ([username, password]) => {
+            if (!socket.data.user.isOwner)
+                return 'missing permission';
+            // body is username and password
+            if (typeof username !== 'string' || typeof password !== 'string')
+                return 'username/password not a string';
+            // validate username
+            if (!username.match(/^\w{0,32}$/))
+                return 'username is not allowed';
+            // this validation is here for _those_ people
+            if (password.length === 0 || password.length > 128)
+                return 'invalid password size';
+            // set owner's credential as the first user
+            if (socket.data.user.isOwner && socket.data.user.username === '') {
+                // set the owner's username and password
+                try {
+                    await database.stores.users.update({ _id: socket.data.user._id }, {
+                        username,
+                        hash: await database.hash(password),
+                    });
+                }
+                catch (e) {
+                    error('error setting owner password', e);
+                    return 'error setting owner password';
+                }
+                log(`created account as "${username.yellow}"`);
+                // update
+                return '';
+            }
+            // check if user exists
+            if (await database.userExists(username))
+                return 'user already exists';
+            try {
+                await database.createUser(username, password);
+            }
+            catch (e) {
+                error('error creating new user', e);
+                return 'error creating new user';
+            }
+            log(`created new user "${username.yellow}"`);
+            return '';
+        });
+        // change a user's password
+        // TODO: add permission check
+        rpc.addMethod('users.passwd', async ([username, password]) => {
+            // the owner can change names and the user can change their own name
+            if (!socket.data.user.isOwner && username !== socket.data.user.username)
+                return 'missing permission';
+            // body is username and password
+            if (typeof username !== 'string' || typeof password !== 'string')
+                return 'username/password not a string';
+            // validate username
+            if (!username.match(/^\w{0,32}$/))
+                return 'username is not allowed';
+            // check if user exists
+            if (!(await database.userExists(username)))
+                return 'user does not exist';
+            try {
+                await database.userPasswd(username, password);
+            }
+            catch (e) {
+                error('error setting user password', e);
+                return "error setting user's password";
+            }
+            log(`changed password for "${username.yellow}"`);
+            return '';
+        });
+        rpc.addMethod('server.autorestart.get', async () => {
+            return await database.getAutoRestartConfig();
+        });
+        const autorestartConfigFields = {
+            type: 'string',
+            maxUptime: 'number',
+            maxUptimeEnabled: 'boolean',
+            emptyUptime: 'number',
+            emptyUptimeEnabled: 'boolean',
+            dailyHour: 'number',
+            dailyHourEnabled: 'boolean',
+            announcementEnabled: 'boolean',
+            bricksEnabled: 'boolean',
+            minigamesEnabled: 'boolean',
+            environmentEnabled: 'boolean',
+            playersEnabled: 'boolean',
+        };
+        rpc.addMethod('server.autorestart.set', async ([config]) => {
+            // validate the autorestart config
+            if (typeof config !== 'object' ||
+                !Object.entries(autorestartConfigFields).every(([k, v]) => k in config && typeof config[k] === v && !Number.isNaN(v)) ||
+                config.type !== 'autoRestartConfig')
+                return false;
+            await database.setAutoRestartConfig(config);
+            return true;
+        });
+        // send server status at request
+        // TODO: server status permission check
+        rpc.addMethod('server.status', () => {
+            return server.lastReportedStatus;
+        });
+        // get server run status
+        // TODO: server status permission check
+        rpc.addMethod('server.started', () => {
+            return {
+                started: omegga.started,
+                starting: omegga.starting,
+                stopping: omegga.stopping,
+            };
+        });
+        // start the server if it's not already started
+        // TODO: server status permission check
+        rpc.addMethod('server.start', async () => {
+            if (omegga.starting || omegga.stopping || omegga.started)
+                return;
+            log('Starting server...');
+            await omegga.start();
+        });
+        // stop the server if it's not already stopped
+        // TODO: server status permission check
+        rpc.addMethod('server.stop', async () => {
+            if (omegga.starting || omegga.stopping || !omegga.started)
+                return;
+            log('Stopping server...');
+            await omegga.stop();
+        });
+        // restart the server if it's running, start the server if it's stopped
+        // TODO: server status permission check
+        rpc.addMethod('server.restart', async () => {
+            if (omegga.starting || omegga.stopping)
+                return;
+            try {
+                const config = await database.getAutoRestartConfig();
+                await omegga.saveServer({
+                    players: config.playersEnabled,
+                    bricks: config.bricksEnabled,
+                    announcement: config.announcementEnabled,
+                    minigames: config.minigamesEnabled,
+                    environment: config.environmentEnabled,
+                });
+            }
+            catch (err) {
+                error('Error while saving server setup', err);
+            }
+            database.addChatLog('server', {}, 'Restarting in 5 seconds...');
+            logger_1.default.logp('Restarting in 5 seconds...');
+            omegga.broadcast(`<size="20">Server restart in <b><color="ffffbb">${5} seconds</></></>`);
+            await new Promise(resolve => setTimeout(resolve, 5000));
+            omegga.changeMap(omegga.currentMap);
+            await new Promise(resolve => setTimeout(resolve, 100));
+            if (omegga.started)
+                await omegga.stop();
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            await omegga.start();
+        });
+        // subscribe and unsubscribe to events
+        socket.on('subscribe', room => {
+            // TODO: permission check for certain rooms
+            if (server.rooms.includes(room)) {
+                socket.join(room);
+            }
+        });
+        socket.on('unsubscribe', room => {
+            if (server.rooms.includes(room))
+                socket.leave(room);
+        });
+        socket.on('disconnect', () => { });
+    });
+    // register routes
+    server.app.use('/api/v1', openApi);
+    server.app.use('/api/v1', api);
+}
+exports.default = default_1;
+//# sourceMappingURL=api.js.map