omegga 1.2.8 → 1.3.0

package/dist/webserver/backend/api.js

@@ -1,887 +1,797 @@
 "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.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const logger = require("../../logger.js");
+const steam = require("../../updater/steam.js");
+const version = require("../../version.js");
+const player = require("../../omegga/player.js");
+const chat = require("../../util/chat.js");
+const color = require("../../util/color.js");
+const time = require("../../util/time.js");
+const uuid = require("../../util/uuid.js");
+const express = require("express");
+const jsonRpc2_0 = require("json-rpc-2.0");
+const _ = require("lodash");
+const brdb = require("../../util/brdb.js");
+function setupApi(server, io) {
+  const { database, omegga } = server;
+  const openApi = express.Router();
+  const api = express.Router();
+  openApi.get(
+    "/first",
+    async (req, res) => res.json(await database.isFirstUser())
+  );
+  openApi.post("/auth", async (req, res) => {
+    if (typeof req.body !== "object" || typeof req.body.username !== "string" || typeof req.body.password !== "string") {
+      return res.status(422).json({ message: "invalid body" });
     }
-    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 () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
+    const { username, password } = req.body;
+    if (!username.match(/^\w{0,32}$/)) {
+      return res.status(422).json({ message: "invalid body" });
+    }
+    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" });
+    }
+  });
+  api.get("/logout", (req, res) => {
+    req.session.destroy((e) => {
+      res.status(e ? 500 : 200).json({});
+    });
+  });
+  api.all("*", (req, _res, next) => {
+    (async () => {
+      const user = await database.findUserById(req.session.userId);
+      if (!user || user.isBanned) return next(new Error("unauthorized"));
+      next();
+    })();
+  });
+  io.on("connection", (socket) => {
+    socket.join("user:" + socket.data.user._id);
+    database.getRoles().then((roles) => {
+      socket.emit("data", {
+        roles,
+        version: version.VERSION,
+        brickadiaVersion: omegga.version ?? null,
+        canLogOut: socket.data.user.username !== "",
+        now: Date.now(),
+        // this can be used for the frontend to anticipate drift
+        userless: !socket.data.user.username,
+        user: {
+          username: socket.data.user.username || "Admin",
+          isOwner: socket.data.user.isOwner,
+          roles: socket.data.user.roles
+        },
+        isSteam: Boolean(omegga.config.__STEAM),
+        update: {
+          canCheck: omegga.config.__STEAM && !omegga.config.server?.steambeta,
+          lastCheck: steam.getLastSteamUpdateCheck()?.result ?? null
+        }
+      });
+    });
+    const usernameText = `[${(socket.data.user.username || "Admin").brightMagenta}]`;
+    const log = (...args) => logger.default.logp(usernameText, ...args);
+    const error = (...args) => logger.default.errorp(usernameText, ...args);
+    const rpcServer = new jsonRpc2_0.JSONRPCServer();
+    const rpcClient = new jsonRpc2_0.JSONRPCClient(async (data) => {
+      socket.emit("rpc", data);
+    });
+    const rpc = new jsonRpc2_0.JSONRPCServerAndClient(rpcServer, rpcClient);
+    socket.on("rpc", (data) => {
+      if (data && typeof data === "object") {
+        try {
+          rpc.receiveAndSend(data);
+        } catch (e) {
+        }
+      }
+    });
+    rpc.addMethod("chat", async ([message]) => {
+      if (typeof message !== "string") return;
+      if (message.length > 140) message = message.slice(0, 140);
+      const user = {
+        name: socket.data.user.username || "Admin",
+        id: socket.data.user.playerId,
+        color: "ff00ff",
+        web: true
+      };
+      io.to("chat").emit(
+        "chat",
+        await database.addChatLog("msg", user, message)
+      );
+      omegga.broadcast(
+        `"[<b><color=\\"ff00ff\\">${user.name}</></>]: ${chat.parseLinks(
+          chat.sanitize(message)
+        )}"`
+      );
+      logger.default.log(`[${user.name.brightMagenta.underline}]: ${message}`);
+      return "ok";
+    });
+    rpc.addMethod("chat.recent", () => {
+      return database.getChats({ sameServer: true });
+    });
+    rpc.addMethod(
+      "chat.history",
+      ([{ after, before }] = [{}]) => {
+        return database.getChats({ after, before });
+      }
+    );
+    rpc.addMethod("chat.calendar", () => {
+      return database.calendar.years;
+    });
+    rpc.addMethod("plugins.list", () => {
+      return _.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()
+      );
+    });
+    rpc.addMethod("plugin.get", async ([shortPath]) => {
+      const plugin = omegga.pluginLoader.plugins.find(
+        (p) => p.shortPath === shortPath
+      );
+      if (!plugin) return null;
+      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()
+      };
+    });
+    rpc.addMethod(
+      "players.list",
+      async ([
+        {
+          page = 0,
+          search = "",
+          sort = "name",
+          direction = "1",
+          filter = ""
+        } = {}
+      ]) => {
+        const banList = (omegga.getBanList() || { banList: {} }).banList;
+        const now = Date.now();
+        let limitId;
+        if (filter === "banned") {
+          limitId = Object.keys(banList).filter(
+            (b) => banList[b].expires <= banList[b].created || time.parseBrickadiaTime(banList[b].expires) > Date.now()
+          );
+        }
+        const resp = await database.getPlayers({
+          page,
+          search,
+          sort,
+          direction,
+          limitId
+        });
+        for (const player2 of resp.players) {
+          player2.seenAgo = now - player2.lastSeen;
+          player2.createdAgo = now - player2.created;
+          const foundBan = banList[player2.id];
+          if (foundBan) {
+            const created = time.parseBrickadiaTime(foundBan.created);
+            const expires = time.parseBrickadiaTime(foundBan.expires);
+            let currentBan = {
+              ...foundBan,
+              // parse the times in the current ban
+              created,
+              expires,
+              duration: expires - created,
+              remainingTime: expires - now,
+              // lookup banner name
+              bannerName: _.get(
+                omegga.getNameCache(),
+                ["savedPlayerNames", foundBan.bannerId],
+                ""
+              )
+            };
+            if (currentBan.expires < now && currentBan.duration > 0)
+              currentBan = null;
+            player2.ban = currentBan;
+          }
+        }
+        return resp;
+      }
+    );
+    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;
+      const playerRoles = player.default.getRoles(omegga, id) || [];
+      const { roles: serverRoles = [] } = omegga.getRoleSetup() ?? {};
+      for (const b of entry.banHistory) {
+        b.duration = b.expires - b.created;
+        b.bannerName = _.get(
+          omegga.getNameCache(),
+          ["savedPlayerNames", b.bannerId],
+          ""
+        );
+      }
+      for (const b of entry.kickHistory) {
+        b.kickerName = _.get(
+          omegga.getNameCache(),
+          ["savedPlayerNames", b.kickerId],
+          ""
+        );
+      }
+      const foundBan = (omegga.getBanList() || { banList: {} }).banList[id];
+      let currentBan = null;
+      if (foundBan) {
+        const created = time.parseBrickadiaTime(foundBan.created);
+        const expires = time.parseBrickadiaTime(foundBan.expires);
+        currentBan = {
+          ...foundBan,
+          created,
+          expires,
+          duration: expires - created,
+          remainingTime: expires - now,
+          // lookup banner name
+          bannerName: _.get(
+            omegga.getNameCache(),
+            ["savedPlayerNames", foundBan.bannerId],
+            ""
+          )
         };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __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 });
-exports.default = default_1;
-const logger_1 = __importDefault(require("../../logger"));
-const updater_1 = require("../../updater");
-const steam_1 = require("../../updater/steam");
-const version_1 = require("../../version");
-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 brdb_1 = require("../../util/brdb");
-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' });
+        if (currentBan.expires < now && currentBan.duration > 0)
+          currentBan = null;
+      }
+      return {
+        // database results
+        ...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) => {
+          let color$1 = "ffffff";
+          const role = serverRoles.find(
+            (sr) => sr.name.toLowerCase() === r.toLowerCase()
+          );
+          if (role && role.bHasColor) color$1 = color.rgbToHex(role.color);
+          return {
+            name: r,
+            color: color$1
+          };
+        })
+      };
+    });
+    rpc.addMethod(
+      "player.ban",
+      async ([id, duration = -1, reason = "No Reason"]) => {
+        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",
+          omegga.getNameCache()?.savedPlayerNames?.[id].yellow ?? "with id " + id.yellow
+        );
+        omegga.writeln(`Chat.Command /Ban "${id}" ${duration} "${reason}"`);
+        let listener;
+        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: time.parseBrickadiaTime(banList[id].created),
+                    expires: time.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), 5e3))
+        ]);
+        database.off("update.bans", listener);
+        return ok;
+      }
+    );
+    rpc.addMethod(
+      "player.kick",
+      async ([id, reason = "No Reason"]) => {
+        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, "'");
+        const player2 = omegga.players.find((p) => p.id === id);
+        if (!player2) return false;
+        log("Kicking player", player2.name.yellow);
+        omegga.writeln(`Chat.Command /Kick "${id}" "${reason}"`);
+        const ok = await Promise.race([
+          new Promise((resolve) => {
+            omegga.once("leave", async (leavingPlayer) => {
+              if (leavingPlayer.id === id) {
+                resolve(true);
+                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), 5e3))
+        ]);
+        return ok;
+      }
+    );
+    rpc.addMethod("player.unban", async ([id]) => {
+      if (typeof id !== "string" || !uuid.match(id)) return false;
+      const banList = (omegga.getBanList() || { banList: {} }).banList;
+      if (!banList[id]) return false;
+      log(
+        "Unbanning player",
+        omegga.getNameCache()?.savedPlayerNames?.[id].yellow ?? "with id " + id.yellow
+      );
+      omegga.writeln(`Chat.Command /Unban "${id}"`);
+      let listener;
+      const ok = await Promise.race([
+        new Promise((resolve) => {
+          database.on(
+            "update.bans",
+            listener = () => {
+              const banList2 = (omegga.getBanList() || { banList: {} }).banList;
+              if (!banList2[id] || time.parseBrickadiaTime(banList2[id].expires) < Date.now())
+                resolve(true);
+            }
+          );
+        }),
+        new Promise((resolve) => setTimeout(() => resolve(false), 5e3))
+      ]);
+      database.off("update.bans", listener);
+      return ok;
+    });
+    rpc.addMethod("player.clearbricks", async ([id]) => {
+      if (typeof id !== "string" || !uuid.match(id)) return false;
+      log(
+        "Clearing bricks for player",
+        omegga.getNameCache()?.savedPlayerNames?.[id]?.yellow ?? "with id " + id.yellow
+      );
+      omegga.writeln(`Bricks.Clear "${id}"`);
+      return true;
+    });
+    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);
+        return true;
+      }
+    );
+    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;
+      }
+    });
+    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();
+    });
+    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();
+    });
+    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;
         }
-        const { username, password } = req.body;
-        // username regex
-        if (!username.match(/^\w{0,32}$/)) {
-            return res.status(422).json({ message: 'invalid body' });
+      }
+    );
+    rpc.addMethod("roles.list", () => {
+      return _.sortBy(
+        omegga.getRoleSetup()?.roles ?? [],
+        (p) => p.name.toLowerCase()
+      );
+    });
+    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(({ hash: _2, ...user }) => ({
+          ...user,
+          hash: "",
+          seenAgo: user.lastOnline ? now - user.lastOnline : Infinity,
+          createdAgo: now - user.created
+        }));
+        return resp;
+      }
+    );
+    rpc.addMethod(
+      "users.create",
+      async ([username, password]) => {
+        if (!socket.data.user.isOwner) return "missing permission";
+        if (typeof username !== "string" || typeof password !== "string")
+          return "username/password not a string";
+        if (!username.match(/^\w{0,32}$/)) return "username is not allowed";
+        if (password.length === 0 || password.length > 128)
+          return "invalid password size";
+        if (socket.data.user.isOwner && socket.data.user.username === "") {
+          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}"`);
+          return "";
         }
-        // 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);
+        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";
         }
-        else {
-            user = await database.authUser(username, password);
+        log(`created new user "${username.yellow}"`);
+        return "";
+      }
+    );
+    rpc.addMethod(
+      "users.passwd",
+      async ([username, password]) => {
+        if (!socket.data.user.isOwner && username !== socket.data.user.username)
+          return "missing permission";
+        if (typeof username !== "string" || typeof password !== "string")
+          return "username/password not a string";
+        if (!username.match(/^\w{0,32}$/)) return "username is not allowed";
+        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";
         }
-        if (user) {
-            req.session.userId = user._id;
-            req.session.save();
-            res.status(200).json({});
+        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",
+      playersEnabled: "boolean",
+      saveWorld: "boolean",
+      autoUpdateEnabled: "boolean",
+      autoUpdateIntervalMins: "number"
+    };
+    rpc.addMethod(
+      "server.autorestart.set",
+      async ([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;
+      }
+    );
+    rpc.addMethod("server.status", () => {
+      return server.lastReportedStatus;
+    });
+    rpc.addMethod("server.started", () => {
+      return {
+        started: omegga.started,
+        starting: omegga.starting,
+        stopping: omegga.stopping
+      };
+    });
+    rpc.addMethod("server.start", async () => {
+      if (omegga.starting || omegga.stopping || omegga.started) return;
+      log("Starting server...");
+      await omegga.start();
+    });
+    rpc.addMethod("server.stop", async () => {
+      if (omegga.starting || omegga.stopping || !omegga.started) return;
+      log("Stopping server...");
+      await omegga.stop();
+    });
+    rpc.addMethod("server.restart", async () => {
+      if (omegga.starting || omegga.stopping) return;
+      try {
+        const config = await database.getAutoRestartConfig();
+        await omegga.saveServer({
+          players: config.playersEnabled,
+          saveWorld: config.saveWorld ?? true,
+          announcement: config.announcementEnabled
+        });
+      } catch (err) {
+        error("Error while saving server setup", err);
+      }
+      database.addChatLog("server", {}, "Restarting in 5 seconds...");
+      logger.default.logp("Restarting in 5 seconds...");
+      omegga.broadcast(
+        `<size="20">Server restart in <b><color="ffffbb">${5} seconds</></></>`
+      );
+      await new Promise((resolve) => setTimeout(resolve, 5e3));
+      await omegga.restartServer();
+    });
+    rpc.addMethod("server.updatecheck", async () => {
+      if (!omegga.config.__STEAM) return null;
+      const lastUpdate = steam.getLastSteamUpdateCheck();
+      if (Date.now() - lastUpdate.attempt < 1e3 * 5) {
+        logger.default.verbose("[rpc] Using cached steam update check");
+        return lastUpdate.result;
+      }
+      logger.default.verbose("[rpc] Checking for steam update");
+      return await steam.hasSteamUpdate(omegga.config.server?.steambeta);
+    });
+    rpc.addMethod("server.update", async () => {
+      if (!omegga.config.__STEAM) return false;
+      if (omegga.stopping || omegga.starting) return false;
+      const wasStarted = omegga.started;
+      if (wasStarted) {
+        log("Stopping server to update...");
+        await omegga.stop();
+      }
+      log("Updating server...");
+      let ok = false;
+      try {
+        steam.steamcmdDownloadGame({
+          steambeta: omegga.config.server?.steambeta,
+          steambetaPassword: omegga.config.server?.steambetaPassword
+        });
+        ok = true;
+        log("Server updated successfully");
+      } catch (err) {
+        error("Error updating server", err);
+      }
+      if (wasStarted) {
+        log("Starting server...");
+        await omegga.start();
+      }
+      return ok;
+    });
+    rpc.addMethod("world.list", async () => {
+      const prefix = omegga.worldPath + "/";
+      return omegga.getWorlds().map((world) => world.replace(prefix, "").replace(/\.brdb$/, ""));
+    });
+    rpc.addMethod("world.revisions", async ([world]) => {
+      try {
+        return (await omegga.getWorldRevisions(world))?.map(
+          ({ date, ...r }) => ({ ...r, date: date.getTime() })
+        );
+      } catch (_err) {
+        return null;
+      }
+    });
+    rpc.addMethod("world.meta", async ([world]) => {
+      try {
+        const path = omegga.getWorldPath(world);
+        if (!path) return null;
+        return brdb.readBrdbMeta(path);
+      } catch (err) {
+        error("Error while getting world meta", err);
+        return null;
+      }
+    });
+    rpc.addMethod("world.next", async () => {
+      return omegga.getNextWorld();
+    });
+    rpc.addMethod("world.active", async () => {
+      return omegga.getActiveWorld();
+    });
+    rpc.addMethod(
+      "world.load",
+      async ([world, revision]) => {
+        try {
+          let res = false;
+          if (revision) {
+            log("Loading world revision", revision, "of", world.yellow);
+            res = await omegga.loadWorldRevision(world, revision);
+          } else {
+            log("Loading world", world.yellow);
+            res = await omegga.loadWorld(world);
+          }
+          if (res) {
+            log("World loaded successfully");
+          } else {
+            log("World load failed");
+          }
+          return res;
+        } catch (err) {
+          error("Error while loading world", err);
+          return false;
         }
-        else {
-            res.status(404).json({ message: 'no user found' });
+      }
+    );
+    rpc.addMethod("world.use", async ([world]) => {
+      try {
+        const ok = omegga.setActiveWorld(world || null);
+        if (ok) {
+          log("Set default world to", (world || "none").yellow);
         }
+        return ok;
+      } catch (err) {
+        error("Error while using world", err);
+        return false;
+      }
     });
-    // kill a session
-    api.get('/logout', (req, res) => {
-        req.session.destroy(e => {
-            res.status(e ? 500 : 200).json({});
-        });
+    rpc.addMethod(
+      "world.create",
+      async ([name, level]) => {
+        try {
+          log(
+            "Creating new world",
+            name.yellow,
+            "with level",
+            level?.yellow || "Plate"
+          );
+          const res = await omegga.createEmptyWorld(name, level);
+          if (res) {
+            log("World created successfully");
+          } else {
+            log("World creation failed");
+          }
+          return res;
+        } catch (err) {
+          error("Error while creating world", err);
+          return false;
+        }
+      }
+    );
+    rpc.addMethod("world.save", async ([name]) => {
+      try {
+        let res = false;
+        if (name) {
+          log("Saving world as", name.yellow);
+          res = await omegga.saveWorldAs(name);
+        } else {
+          log("Saving current world");
+          res = await omegga.saveWorld();
+        }
+        if (res) {
+          log("World saved successfully");
+        } else {
+          log("World save failed");
+        }
+        return res;
+      } catch (err) {
+        error("Error while saving world", err);
+        return false;
+      }
     });
-    // 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 => {
-            var _a, _b, _c, _d;
-            socket.emit('data', {
-                roles,
-                version: version_1.VERSION,
-                brickadiaVersion: (_a = omegga.version) !== null && _a !== void 0 ? _a : null,
-                canLogOut: socket.data.user.username !== '',
-                now: Date.now(), // this can be used for the frontend to anticipate drift
-                userless: !socket.data.user.username,
-                user: {
-                    username: socket.data.user.username || 'Admin',
-                    isOwner: socket.data.user.isOwner,
-                    roles: socket.data.user.roles,
-                },
-                isSteam: Boolean(omegga.config.__STEAM),
-                update: {
-                    canCheck: omegga.config.__STEAM && !((_b = omegga.config.server) === null || _b === void 0 ? void 0 : _b.steambeta),
-                    lastCheck: (_d = (_c = (0, steam_1.getLastSteamUpdateCheck)()) === null || _c === void 0 ? void 0 : _c.result) !== null && _d !== void 0 ? _d : null,
-                },
-            });
-        });
-        // 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
-            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 = {
-                        ...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]) => {
-            var _a;
-            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 = [] } = (_a = omegga.getRoleSetup()) !== null && _a !== void 0 ? _a : {};
-            // 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 = {
-                    ...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 {
-                // database results
-                ...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 => {
-                    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])
-                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', () => {
-            var _a, _b;
-            return lodash_1.default.sortBy((_b = (_a = omegga.getRoleSetup()) === null || _a === void 0 ? void 0 : _a.roles) !== null && _b !== void 0 ? _b : [], 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(({ hash: _, ...user }) => ({
-                ...user,
-                hash: '',
-                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',
-            playersEnabled: 'boolean',
-            saveWorld: 'boolean',
-            autoUpdateEnabled: 'boolean',
-            autoUpdateIntervalMins: 'number',
-        };
-        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 () => {
-            var _a;
-            if (omegga.starting || omegga.stopping)
-                return;
-            try {
-                const config = await database.getAutoRestartConfig();
-                await omegga.saveServer({
-                    players: config.playersEnabled,
-                    saveWorld: (_a = config.saveWorld) !== null && _a !== void 0 ? _a : true,
-                    announcement: config.announcementEnabled,
-                });
-            }
-            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));
-            await omegga.restartServer();
-        });
-        // check if the server has a steam update available
-        rpc.addMethod('server.updatecheck', async () => {
-            var _a;
-            if (!omegga.config.__STEAM)
-                return null;
-            const lastUpdate = (0, steam_1.getLastSteamUpdateCheck)();
-            if (Date.now() - lastUpdate.attempt < 1000 * 5) {
-                logger_1.default.verbose('[rpc] Using cached steam update check');
-                return lastUpdate.result;
-            }
-            logger_1.default.verbose('[rpc] Checking for steam update');
-            return await (0, steam_1.hasSteamUpdate)((_a = omegga.config.server) === null || _a === void 0 ? void 0 : _a.steambeta);
-        });
-        // check if the server has a steam update available
-        rpc.addMethod('server.update', async () => {
-            var _a, _b;
-            if (!omegga.config.__STEAM)
-                return false;
-            if (omegga.stopping || omegga.starting)
-                return false;
-            const wasStarted = omegga.started;
-            if (wasStarted) {
-                log('Stopping server to update...');
-                await omegga.stop();
-            }
-            log('Updating server...');
-            let ok = false;
-            try {
-                (0, updater_1.steamcmdDownloadGame)({
-                    steambeta: (_a = omegga.config.server) === null || _a === void 0 ? void 0 : _a.steambeta,
-                    steambetaPassword: (_b = omegga.config.server) === null || _b === void 0 ? void 0 : _b.steambetaPassword,
-                });
-                ok = true;
-                log('Server updated successfully');
-            }
-            catch (err) {
-                error('Error updating server', err);
-            }
-            if (wasStarted) {
-                log('Starting server...');
-                await omegga.start();
-            }
-            return ok;
-        });
-        // list available worlds
-        rpc.addMethod('world.list', async () => {
-            const prefix = omegga.worldPath + '/';
-            return omegga
-                .getWorlds()
-                .map(world => world.replace(prefix, '').replace(/\.brdb$/, ''));
-        });
-        // list a world's revisions (while the server is running)
-        rpc.addMethod('world.revisions', async ([world]) => {
-            var _a;
-            try {
-                return (_a = (await omegga.getWorldRevisions(world))) === null || _a === void 0 ? void 0 : _a.map(({ date, ...r }) => ({ ...r, date: date.getTime() }));
-            }
-            catch (_err) {
-                return null;
-            }
-        });
-        rpc.addMethod('world.meta', async ([world]) => {
-            try {
-                const path = omegga.getWorldPath(world);
-                if (!path)
-                    return null;
-                return (0, brdb_1.readBrdbMeta)(path);
-            }
-            catch (err) {
-                error('Error while getting world meta', err);
-                return null;
-            }
-        });
-        // get the next world to load
-        rpc.addMethod('world.next', async () => {
-            return omegga.getNextWorld();
-        });
-        // get the configured default world
-        rpc.addMethod('world.active', async () => {
-            return omegga.getActiveWorld();
-        });
-        // load a world or revision of a world
-        rpc.addMethod('world.load', async ([world, revision]) => {
-            try {
-                let res = false;
-                if (revision) {
-                    log('Loading world revision', revision, 'of', world.yellow);
-                    res = await omegga.loadWorldRevision(world, revision);
-                }
-                else {
-                    log('Loading world', world.yellow);
-                    res = await omegga.loadWorld(world);
-                }
-                if (res) {
-                    log('World loaded successfully');
-                }
-                else {
-                    log('World load failed');
-                }
-                return res;
-            }
-            catch (err) {
-                error('Error while loading world', err);
-                return false;
-            }
-        });
-        /// set or clear the default world
-        rpc.addMethod('world.use', async ([world]) => {
-            try {
-                const ok = omegga.setActiveWorld(world || null);
-                if (ok) {
-                    log('Set default world to', (world || 'none').yellow);
-                }
-                return ok;
-            }
-            catch (err) {
-                error('Error while using world', err);
-                return false;
-            }
-        });
-        // create a new world
-        rpc.addMethod('world.create', async ([name, level]) => {
-            try {
-                log('Creating new world', name.yellow, 'with level', (level === null || level === void 0 ? void 0 : level.yellow) || 'Plate');
-                const res = await omegga.createEmptyWorld(name, level);
-                if (res) {
-                    log('World created successfully');
-                }
-                else {
-                    log('World creation failed');
-                }
-                return res;
-            }
-            catch (err) {
-                error('Error while creating world', err);
-                return false;
-            }
-        });
-        // save a world or save as a world
-        rpc.addMethod('world.save', async ([name]) => {
-            try {
-                let res = false;
-                if (name) {
-                    log('Saving world as', name.yellow);
-                    res = await omegga.saveWorldAs(name);
-                }
-                else {
-                    log('Saving current world');
-                    res = await omegga.saveWorld();
-                }
-                if (res) {
-                    log('World saved successfully');
-                }
-                else {
-                    log('World save failed');
-                }
-                return res;
-            }
-            catch (err) {
-                error('Error while saving world', err);
-                return false;
-            }
-        });
-        // 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', () => { });
+    socket.on("subscribe", (room) => {
+      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);
+  });
+  server.app.use("/api/v1", openApi);
+  server.app.use("/api/v1", api);
 }
-//# sourceMappingURL=api.js.map
+exports.default = setupApi;
+//# sourceMappingURL=api.js.map