omegga 1.2.9 → 1.4.0

package/dist/omegga/plugin/plugin_jsonrpc_stdio.js

@@ -1,447 +1,596 @@
 "use strict";
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-var _RpcPlugin_child, _RpcPlugin_rpc, _RpcPlugin_errInterface, _RpcPlugin_outInterface;
-Object.defineProperty(exports, "__esModule", { value: true });
-const logger_1 = __importDefault(require("../../logger"));
-const child_process_1 = require("child_process");
-const fs_1 = __importDefault(require("fs"));
-const json_rpc_2_0_1 = require("json-rpc-2.0");
-const path_1 = __importDefault(require("path"));
-const readline_1 = __importDefault(require("readline"));
-const interface_1 = require("./interface");
-const proxyOmegga_1 = require("./plugin_node_safe/proxyOmegga");
-// TODO: check if version is compatible (v1 -> v2) from file
-// TODO: write jsonrpc wrappers in a few languages, implement a few simple plugins
-// TODO: languages: [ python, go ]
-const MAIN_FILE = 'omegga_plugin';
-const DOC_FILE = 'doc.json';
-const PLUGIN_FILE = 'plugin.json';
-class RpcPlugin extends interface_1.Plugin {
-    // all RPC plugins require a main (binary) file and a doc file
-    static canLoad(pluginPath) {
-        return (fs_1.default.existsSync(path_1.default.join(pluginPath, MAIN_FILE)) &&
-            fs_1.default.existsSync(path_1.default.join(pluginPath, DOC_FILE)));
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const logger = require("../../logger.js");
+const jsonRpc2_0 = require("json-rpc-2.0");
+const node_child_process = require("node:child_process");
+const fs = require("node:fs");
+const path = require("node:path");
+const readline = require("readline");
+const _interface = require("./interface.js");
+const proxyOmegga = require("./plugin_node_safe/proxyOmegga.js");
+const MAIN_FILE = "omegga_plugin";
+const DOC_FILE = "doc.json";
+const PLUGIN_FILE = "plugin.json";
+class RpcPlugin extends _interface.Plugin {
+  #child;
+  #rpc;
+  #errInterface;
+  #outInterface;
+  // all RPC plugins require a main (binary) file and a doc file
+  static canLoad(pluginPath) {
+    return fs.existsSync(path.join(pluginPath, MAIN_FILE)) && fs.existsSync(path.join(pluginPath, DOC_FILE));
+  }
+  // websocket rpc plugin type
+  static getFormat() {
+    return "jsonrpc_stdio";
+  }
+  // documentation is based on doc.json file
+  getDocumentation() {
+    return this.documentation;
+  }
+  constructor(pluginPath, omegga) {
+    super(pluginPath, omegga);
+    this.messageCounter = 0;
+    this.documentation = _interface.Plugin.readJSON(path.join(pluginPath, DOC_FILE));
+    this.pluginConfig = _interface.Plugin.readJSON(path.join(pluginPath, PLUGIN_FILE));
+    this.pluginFile = path.join(pluginPath, MAIN_FILE);
+    this.eventPassthrough = this.eventPassthrough.bind(this);
+    this.commands = [];
+    this.initRPC();
+  }
+  isLoaded() {
+    return !!this.#child && !this.#child.exitCode;
+  }
+  // determing if a command is registered
+  isCommand(cmd) {
+    return this.commands.includes(cmd);
+  }
+  // spawn the plugin as a child process
+  async load() {
+    const name = this.getName();
+    const verbose = (...msg) => logger.default.verbose(name.underline, ...msg);
+    verbose("Load method invoked");
+    let frozen = true, timed = false;
+    this.commands = [];
+    if (this.#child) {
+      verbose("Plugin already has child process");
+      return false;
     }
-    // websocket rpc plugin type
-    static getFormat() {
-        return 'jsonrpc_stdio';
+    let config;
+    try {
+      verbose("Getting plugin config");
+      config = await this.storage.getConfig();
+    } catch (e) {
+      return false;
     }
-    // documentation is based on doc.json file
-    getDocumentation() {
-        return this.documentation;
+    try {
+      if (this.pluginConfig?.emitConfig) {
+        verbose("Emitting plugin config");
+        await fs.promises.writeFile(
+          path.join(this.path, this.pluginConfig.emitConfig),
+          JSON.stringify(config)
+        );
+      }
+      verbose("Spawning child process");
+      this.#child = node_child_process.spawn(this.pluginFile);
+      this.#child.stdin.setDefaultEncoding("utf8");
+      this.#outInterface = readline.createInterface({
+        input: this.#child.stdout,
+        terminal: false
+      });
+      this.#errInterface = readline.createInterface({
+        input: this.#child.stderr,
+        terminal: false
+      });
+      this.attachListeners();
+    } catch (err) {
+      logger.default.errorp(
+        "error loading stdio rpc plugin",
+        name.brightRed.underline,
+        err
+      );
+      await this.kill();
+      this.emitStatus();
+      return false;
     }
-    constructor(pluginPath, omegga) {
-        super(pluginPath, omegga);
-        _RpcPlugin_child.set(this, void 0);
-        _RpcPlugin_rpc.set(this, void 0);
-        _RpcPlugin_errInterface.set(this, void 0);
-        _RpcPlugin_outInterface.set(this, void 0);
-        this.messageCounter = 0;
-        // TODO: validate documentation
-        this.documentation = interface_1.Plugin.readJSON(path_1.default.join(pluginPath, DOC_FILE));
-        this.pluginConfig = interface_1.Plugin.readJSON(path_1.default.join(pluginPath, PLUGIN_FILE));
-        this.pluginFile = path_1.default.join(pluginPath, MAIN_FILE);
-        this.eventPassthrough = this.eventPassthrough.bind(this);
-        this.commands = [];
-        this.initRPC();
-    }
-    isLoaded() {
-        return !!__classPrivateFieldGet(this, _RpcPlugin_child, "f") && !__classPrivateFieldGet(this, _RpcPlugin_child, "f").exitCode;
-    }
-    // determing if a command is registered
-    isCommand(cmd) {
-        return this.commands.includes(cmd);
-    }
-    // spawn the plugin as a child process
-    async load() {
-        var _a;
-        const name = this.getName();
-        const verbose = (...msg) => logger_1.default.verbose(name.underline, ...msg);
-        verbose('Load method invoked');
-        let frozen = true, timed = false;
-        this.commands = [];
-        // can't load the plugin if the child is still running
-        if (__classPrivateFieldGet(this, _RpcPlugin_child, "f")) {
-            verbose('Plugin already has child process');
-            return false;
-        }
-        let config;
+    return Promise.race([
+      (async () => {
         try {
-            verbose('Getting plugin config');
-            config = await this.storage.getConfig();
-        }
-        catch (e) {
-            return false;
-        }
-        try {
-            if ((_a = this.pluginConfig) === null || _a === void 0 ? void 0 : _a.emitConfig) {
-                verbose('Emitting plugin config');
-                await fs_1.default.promises.writeFile(path_1.default.join(this.path, this.pluginConfig.emitConfig), JSON.stringify(config));
+          const initialData = proxyOmegga.bootstrap(this.omegga);
+          verbose("Sending initial data");
+          for (const ev in initialData) {
+            this.notify(ev, initialData[ev]);
+          }
+          verbose("Initializing event passthrough");
+          this.omegga.on("*", this.eventPassthrough);
+          try {
+            verbose("Waiting for plugin to start...");
+            const result = await this.emit("init", config);
+            verbose("Initialized with result:", result);
+            if (typeof result === "object" && result) {
+              const cmds = result.registeredCommands;
+              if (cmds && cmds instanceof Array && cmds.every((i) => typeof i === "string"))
+                this.commands = cmds;
             }
-            verbose('Spawning child process');
-            __classPrivateFieldSet(this, _RpcPlugin_child, (0, child_process_1.spawn)(this.pluginFile), "f");
-            __classPrivateFieldGet(this, _RpcPlugin_child, "f").stdin.setDefaultEncoding('utf8');
-            __classPrivateFieldSet(this, _RpcPlugin_outInterface, readline_1.default.createInterface({
-                input: __classPrivateFieldGet(this, _RpcPlugin_child, "f").stdout,
-                terminal: false,
-            }), "f");
-            __classPrivateFieldSet(this, _RpcPlugin_errInterface, readline_1.default.createInterface({
-                input: __classPrivateFieldGet(this, _RpcPlugin_child, "f").stderr,
-                terminal: false,
-            }), "f");
-            this.attachListeners();
-        }
-        catch (err) {
-            logger_1.default.errorp('error loading stdio rpc plugin', name.brightRed.underline, err);
-            await this.kill();
-            this.emitStatus();
-            return false;
-        }
-        return Promise.race([
-            (async () => {
-                try {
-                    // get some initial information to create an omegga proxy
-                    const initialData = (0, proxyOmegga_1.bootstrap)(this.omegga);
-                    verbose('Sending initial data');
-                    // send all of the mock events to the proxy omegga
-                    for (const ev in initialData) {
-                        // send some initial information
-                        this.notify(ev, initialData[ev]);
-                    }
-                    verbose('Initializing event passthrough');
-                    // pass events through
-                    this.omegga.on('*', this.eventPassthrough);
-                    try {
-                        // tell the plugin to start
-                        verbose('Waiting for plugin to start...');
-                        const result = await this.emit('init', config);
-                        verbose('Initialized with result:', result);
-                        // plugins can return a result object
-                        if (typeof result === 'object' && result) {
-                            // if registeredCommands is in the results, register the provided strings as commands
-                            const cmds = result.registeredCommands;
-                            if (cmds &&
-                                cmds instanceof Array &&
-                                cmds.every(i => typeof i === 'string'))
-                                this.commands = cmds;
-                        }
-                    }
-                    catch (e) {
-                        if (!e.message)
-                            return;
-                        logger_1.default.errorp(name.brightRed.underline, 'error starting: ', e);
-                    }
-                    // plugin is not frozen, resolve that it has loaded
-                    frozen = false;
-                    if (timed)
-                        return;
-                    this.emitStatus();
-                    return true;
-                }
-                catch (e) {
-                    if (timed)
-                        return;
-                    logger_1.default.errorp('error loading stdio rpc plugin', name.brightRed.underline, e);
-                    await this.kill();
-                    frozen = false;
-                    this.emitStatus();
-                    return false;
-                }
-            })(),
-            new Promise(resolve => {
-                // let user know if the child quit while launching
-                __classPrivateFieldGet(this, _RpcPlugin_child, "f").once('exit', () => {
-                    if (!frozen || timed)
-                        return;
-                    verbose('Plugin exited during init');
-                    frozen = false;
-                    this.emitStatus();
-                    resolve(false);
-                });
-                // check if the child is frozen (while true)
-                setTimeout(() => {
-                    if (!frozen)
-                        return;
-                    logger_1.default.errorp('I appear to be unresponsive when starting (maybe I forgot to respond to init)', name.brightRed.underline);
-                    this.kill();
-                    timed = true;
-                    this.emitStatus();
-                    resolve(false);
-                }, 5000);
-            }),
-        ]);
-    }
-    // kill the child process after requesting it to stop
-    unload() {
-        if (!__classPrivateFieldGet(this, _RpcPlugin_child, "f") || __classPrivateFieldGet(this, _RpcPlugin_child, "f").exitCode) {
-            this.detachListeners();
-            this.emitStatus();
-            return Promise.resolve(true);
+          } catch (e) {
+            if (!e.message) return;
+            logger.default.errorp(name.brightRed.underline, "error starting: ", e);
+          }
+          frozen = false;
+          if (timed) return;
+          this.emitStatus();
+          return true;
+        } catch (e) {
+          if (timed) return;
+          logger.default.errorp(
+            "error loading stdio rpc plugin",
+            name.brightRed.underline,
+            e
+          );
+          await this.kill();
+          frozen = false;
+          this.emitStatus();
+          return false;
         }
-        let frozen = true, timed = false;
-        const name = this.getName();
-        return Promise.race([
-            (async () => {
-                try {
-                    // let the plugin know it's time to stop, if this error it's probably because the method was not implemented
-                    try {
-                        await this.emit('stop');
-                    }
-                    catch (e) {
-                        // lazy developer - just implement stop please
-                    }
-                    await this.kill();
-                    frozen = false;
-                    if (timed)
-                        return;
-                    this.emitStatus();
-                    this.commands = [];
-                    return true;
-                }
-                catch (e) {
-                    if (timed)
-                        return;
-                    logger_1.default.errorp('error unloading rpc plugin', name.brightRed.underline, e);
-                    frozen = false;
-                    this.emitStatus();
-                    return false;
-                }
-            })(),
-            // this is wrapped in a promise for the freeze check
-            new Promise(resolve => {
-                // check if the child is frozen (while true)
-                setTimeout(() => {
-                    if (!frozen)
-                        return;
-                    logger_1.default.errorp('I appear to be unresponsive when stopping (maybe I forgot to respond to stop)', name.brightRed.underline);
-                    this.kill();
-                    timed = true;
-                    this.emitStatus();
-                    resolve(true);
-                }, 5000);
-            }),
-        ]);
-    }
-    // attaches event listeners
-    attachListeners() {
-        const name = this.getName();
-        __classPrivateFieldGet(this, _RpcPlugin_outInterface, "f").on('line', line => {
-            try {
-                const rpcData = JSON.parse(line);
-                try {
-                    __classPrivateFieldGet(this, _RpcPlugin_rpc, "f").receiveAndSend(rpcData);
-                }
-                catch (e) {
-                    logger_1.default.error(this.getName().brightRed.underline, '!>'.red, 'error parsing rpc data', e, line);
-                }
-            }
-            catch (_a) {
-                // fallback to logging
-                logger_1.default.log(name.underline, '>>'.green, line);
-            }
-        });
-        // stderr - print out the errors
-        __classPrivateFieldGet(this, _RpcPlugin_errInterface, "f").on('line', err => {
-            logger_1.default.error(name.brightRed.underline, '!>'.red, err);
+      })(),
+      new Promise((resolve) => {
+        this.#child.once("exit", () => {
+          if (!frozen || timed) return;
+          verbose("Plugin exited during init");
+          frozen = false;
+          this.emitStatus();
+          resolve(false);
         });
-        __classPrivateFieldGet(this, _RpcPlugin_child, "f").on('error', () => this.kill());
-        __classPrivateFieldGet(this, _RpcPlugin_child, "f").on('close', () => this.kill());
-        __classPrivateFieldGet(this, _RpcPlugin_child, "f").on('exit', code => {
-            logger_1.default.errorp('!>'.red, 'rpc plugin', name.brightRed.underline, 'exited with code', code);
-            this.kill();
-        });
-    }
-    // removes previously attached event listeners
-    detachListeners() {
-        __classPrivateFieldGet(this, _RpcPlugin_outInterface, "f").removeAllListeners('line');
-        __classPrivateFieldGet(this, _RpcPlugin_errInterface, "f").removeAllListeners('line');
-        if (__classPrivateFieldGet(this, _RpcPlugin_child, "f")) {
-            __classPrivateFieldGet(this, _RpcPlugin_child, "f").removeAllListeners('exit');
-            __classPrivateFieldGet(this, _RpcPlugin_child, "f").removeAllListeners('close');
-            __classPrivateFieldGet(this, _RpcPlugin_child, "f").removeAllListeners('error');
-        }
+        setTimeout(() => {
+          if (!frozen) return;
+          logger.default.errorp(
+            "I appear to be unresponsive when starting (maybe I forgot to respond to init)",
+            name.brightRed.underline
+          );
+          this.kill();
+          timed = true;
+          this.emitStatus();
+          resolve(false);
+        }, 5e3);
+      })
+    ]);
+  }
+  // kill the child process after requesting it to stop
+  unload() {
+    if (!this.#child || this.#child.exitCode) {
+      this.detachListeners();
+      this.emitStatus();
+      return Promise.resolve(true);
     }
-    // write a string to the child process
-    writeln(line) {
+    let frozen = true, timed = false;
+    const name = this.getName();
+    return Promise.race([
+      (async () => {
         try {
-            if (__classPrivateFieldGet(this, _RpcPlugin_child, "f") && !__classPrivateFieldGet(this, _RpcPlugin_child, "f").exitCode)
-                __classPrivateFieldGet(this, _RpcPlugin_child, "f").stdin.write(line + '\n');
+          try {
+            await this.emit("stop");
+          } catch (e) {
+          }
+          await this.kill();
+          frozen = false;
+          if (timed) return;
+          this.emitStatus();
+          this.commands = [];
+          return true;
+        } catch (e) {
+          if (timed) return;
+          logger.default.errorp(
+            "error unloading rpc plugin",
+            name.brightRed.underline,
+            e
+          );
+          frozen = false;
+          this.emitStatus();
+          return false;
         }
-        catch (e) {
-            // the child probably died... oops!
+      })(),
+      // this is wrapped in a promise for the freeze check
+      new Promise((resolve) => {
+        setTimeout(() => {
+          if (!frozen) return;
+          logger.default.errorp(
+            "I appear to be unresponsive when stopping (maybe I forgot to respond to stop)",
+            name.brightRed.underline
+          );
+          this.kill();
+          timed = true;
+          this.emitStatus();
+          resolve(true);
+        }, 5e3);
+      })
+    ]);
+  }
+  // attaches event listeners
+  attachListeners() {
+    const name = this.getName();
+    this.#outInterface.on("line", (line) => {
+      try {
+        const rpcData = JSON.parse(line);
+        try {
+          this.#rpc.receiveAndSend(rpcData);
+        } catch (e) {
+          logger.default.error(
+            this.getName().brightRed.underline,
+            "!>".red,
+            "error parsing rpc data",
+            e,
+            line
+          );
         }
+      } catch {
+        logger.default.log(name.underline, ">>".green, line);
+      }
+    });
+    this.#errInterface.on("line", (err) => {
+      logger.default.error(name.brightRed.underline, "!>".red, err);
+    });
+    this.#child.on("error", () => this.kill());
+    this.#child.on("close", () => this.kill());
+    this.#child.on("exit", (code) => {
+      logger.default.errorp(
+        "!>".red,
+        "rpc plugin",
+        name.brightRed.underline,
+        "exited with code",
+        code
+      );
+      this.kill();
+    });
+  }
+  // removes previously attached event listeners
+  detachListeners() {
+    this.#outInterface.removeAllListeners("line");
+    this.#errInterface.removeAllListeners("line");
+    if (this.#child) {
+      this.#child.removeAllListeners("exit");
+      this.#child.removeAllListeners("close");
+      this.#child.removeAllListeners("error");
     }
-    // forcibly kills the plugin
-    async kill() {
-        __classPrivateFieldGet(this, _RpcPlugin_rpc, "f").rejectAllPendingRequests('Plugin Terminated');
-        this.detachListeners();
-        this.omegga.off('*', this.eventPassthrough);
-        if (!__classPrivateFieldGet(this, _RpcPlugin_child, "f"))
-            return;
-        // create a promise for the exit of the process
-        const promise = new Promise(resolve => __classPrivateFieldGet(this, _RpcPlugin_child, "f").once('exit', resolve));
-        // kill the process
-        __classPrivateFieldGet(this, _RpcPlugin_child, "f").kill('SIGINT');
-        // ...kill it again just to make sure it's dead
-        (0, child_process_1.spawn)('kill', ['-9', __classPrivateFieldGet(this, _RpcPlugin_child, "f").pid + '']);
-        // wait for the process to exit
-        await promise;
-        __classPrivateFieldSet(this, _RpcPlugin_child, undefined, "f");
-        this.emitStatus();
+  }
+  // write a string to the child process
+  writeln(line) {
+    try {
+      if (this.#child && !this.#child.exitCode)
+        this.#child.stdin.write(line + "\n");
+    } catch (e) {
     }
-    eventPassthrough(type, ...args) {
-        if (!__classPrivateFieldGet(this, _RpcPlugin_child, "f"))
-            return;
-        this.notify(type, args);
-    }
-    // setup the JSONRPC communication
-    initRPC() {
-        const server = new json_rpc_2_0_1.JSONRPCServer();
-        const client = new json_rpc_2_0_1.JSONRPCClient(req => {
-            try {
-                this.writeln(JSON.stringify(req));
-                return Promise.resolve();
-            }
-            catch (error) {
-                return Promise.reject(error);
-            }
-        });
-        const rpc = (__classPrivateFieldSet(this, _RpcPlugin_rpc, new json_rpc_2_0_1.JSONRPCServerAndClient(server, client), "f"));
-        // plugin log generator function
-        const ezLog = (logFn, name, symbol) => (line) => console[logFn](name.underline, symbol, line);
-        const name = this.getName();
-        // server can output logs special formatting for stdout
-        rpc.addMethod('log', ezLog('log', name, '>>'.green));
-        rpc.addMethod('error', ezLog('error', name.brightRed, '!>'.red));
-        rpc.addMethod('info', ezLog('info', name, '#>'.blue));
-        rpc.addMethod('debug', ezLog('debug', name, '?>'.blue));
-        rpc.addMethod('warn', ezLog('warn', name.brightYellow, ':>'.yellow));
-        rpc.addMethod('trace', ezLog('trace', name, 'T>'.grey));
-        // plugin store interactions
-        rpc.addMethod('store.get', key => this.storage.get(key));
-        rpc.addMethod('store.set', ([key, value]) => this.storage.set(key, value));
-        rpc.addMethod('store.delete', key => this.storage.delete(key));
-        rpc.addMethod('store.wipe', () => this.storage.wipe());
-        rpc.addMethod('store.count', () => this.storage.count());
-        rpc.addMethod('store.keys', () => this.storage.keys());
-        // server can run console commands
-        rpc.addMethod('exec', line => this.omegga.writeln(line));
-        rpc.addMethod('writeln', line => this.omegga.writeln(line));
-        rpc.addMethod('broadcast', line => this.omegga.broadcast(line));
-        rpc.addMethod('whisper', ({ target, line }) => this.omegga.whisper(target, line));
-        rpc.addMethod('middlePrint', ({ target, line }) => this.omegga.middlePrint(target, line));
-        rpc.addMethod('getPlayers', () => this.omegga.getPlayers());
-        rpc.addMethod('getPlayerPosition', name => { var _a; return (_a = this.omegga.getPlayer(name)) === null || _a === void 0 ? void 0 : _a.getPosition(); }); // included for compatibility
-        rpc.addMethod('getAllPlayerPositions', () => this.omegga.getAllPlayerPositions());
-        rpc.addMethod('getEnvironmentPresets', () => this.omegga.getEnvironmentPresets());
-        rpc.addMethod('resetEnvironment', () => this.omegga.resetEnvironment());
-        rpc.addMethod('saveEnvironment', name => this.omegga.saveEnvironment(name));
-        rpc.addMethod('loadEnvironment', name => this.omegga.loadEnvironment(name));
-        rpc.addMethod('loadEnvironmentData', data => this.omegga.loadEnvironmentData(data));
-        rpc.addMethod('getServerStatus', () => this.omegga.getServerStatus());
-        rpc.addMethod('getMinigames', () => this.omegga.getMinigames());
-        rpc.addMethod('getMinigamePresets', () => this.omegga.getMinigamePresets());
-        rpc.addMethod('saveMinigame', ({ index, name }) => this.omegga.saveMinigame(index, name));
-        rpc.addMethod('loadMinigame', ({ name, owner }) => this.omegga.loadMinigame(name, owner));
-        rpc.addMethod('nextRoundMinigame', index => this.omegga.nextRoundMinigame(index));
-        rpc.addMethod('resetMinigame', index => this.omegga.resetMinigame(index));
-        rpc.addMethod('deleteMinigame', index => this.omegga.deleteMinigame(index));
-        rpc.addMethod('listMinigames', () => this.omegga.listMinigames());
-        rpc.addMethod('getHostId', () => this.omegga.getHostId());
-        rpc.addMethod('getRoleSetup', () => this.omegga.getRoleSetup());
-        rpc.addMethod('getBanList', () => this.omegga.getBanList());
-        rpc.addMethod('getSaves', () => this.omegga.getSaves());
-        rpc.addMethod('getSavePath', name => this.omegga.getSavePath(name));
-        rpc.addMethod('clearBricks', ({ target, quiet = false }) => this.omegga.clearBricks(target, quiet));
-        rpc.addMethod('clearAllBricks', quiet => this.omegga.clearAllBricks(quiet));
-        rpc.addMethod('saveBricks', name => this.omegga.saveBricks(name));
-        rpc.addMethod('loadBricks', ({ name, offX = 0, offY = 0, offZ = 0, quiet = false, }) => this.omegga.loadBricks(name, { offX, offY, offZ, quiet }));
-        rpc.addMethod('loadBricksOnPlayer', ({ name, player, offX = 0, offY = 0, offZ = 0, }) => this.omegga.loadBricksOnPlayer(name, player, { offX, offY, offZ }));
-        rpc.addMethod('readSaveData', name => this.omegga.readSaveData(name));
-        rpc.addMethod('getSaveData', () => this.omegga.getSaveData());
-        rpc.addMethod('loadSaveData', ({ data, offX = 0, offY = 0, offZ = 0, quiet = false, }) => this.omegga.loadSaveData(data, { offX, offY, offZ, quiet }));
-        rpc.addMethod('loadSaveDataOnPlayer', ({ data, player, offX = 0, offY = 0, offZ = 0, }) => this.omegga.loadSaveDataOnPlayer(data, player, { offX, offY, offZ }));
-        rpc.addMethod('changeMap', map => this.omegga.changeMap(map));
-        rpc.addMethod('unload', () => this.unload());
-        rpc.addMethod('reload', async () => {
-            await this.unload();
-            await this.load();
-        });
-        // player related operations
-        const addPlayerMethod = (name) => rpc.addMethod(`player.${name}`, player => { var _a; return (_a = this.omegga.getPlayer(player)) === null || _a === void 0 ? void 0 : _a[name](); });
-        rpc.addMethod('player.get', target => {
-            let player = this.omegga.getPlayer(target);
-            return player && { ...player, host: player.isHost() };
-        });
-        addPlayerMethod('getRoles');
-        addPlayerMethod('getPermissions');
-        addPlayerMethod('getNameColor');
-        addPlayerMethod('getPosition');
-        addPlayerMethod('getGhostBrick');
-        addPlayerMethod('getPaint');
-        addPlayerMethod('getTemplateBounds');
-        addPlayerMethod('getTemplateBoundsData');
-        rpc.addMethod('player.loadDataAtGhostBrick', ({ target, data, rotate = true, offX = 0, offY = 0, offZ = 0, quiet = false, }) => {
-            var _a;
-            return (_a = this.omegga
-                .getPlayer(target)) === null || _a === void 0 ? void 0 : _a.loadDataAtGhostBrick(data, { rotate, offX, offY, offZ, quiet });
-        });
-        rpc.addMethod('player.loadSaveData', ({ target, data, offX = 0, offY = 0, offZ = 0, }) => { var _a; return (_a = this.omegga.getPlayer(target)) === null || _a === void 0 ? void 0 : _a.loadSaveData(data, { offX, offY, offZ }); });
-        // plugin related operations
-        rpc.addMethod('plugin.get', async (name) => {
-            const plugin = this.omegga.pluginLoader.plugins.find(p => p.getName() === name);
-            if (plugin) {
-                return {
-                    name,
-                    documentation: plugin.getDocumentation(),
-                    loaded: plugin.isLoaded(),
-                };
-            }
-            else {
-                return null;
-            }
-        });
-        rpc.addMethod('plugin.emit', async ([name, event, ...args]) => {
-            const plugin = this.omegga.pluginLoader.plugins.find(p => p.getName() === name);
-            if (plugin) {
-                return plugin.emitPlugin(event, this.getName(), args);
-            }
-            else {
-                return null;
-            }
-        });
-    }
-    // emit a custom plugin event
-    async emitPlugin(event, from, args) {
-        return await this.emit('plugin:emit', [event, from, ...args]);
-    }
-    // emit a message to the plugin via the jsonrpc client and expect a response
-    emit(type, arg) {
-        return __classPrivateFieldGet(this, _RpcPlugin_rpc, "f").request(type, arg);
-    }
-    // emit a message to the plugin via the jsonrpc client, don't expect a response
-    notify(type, arg) {
-        try {
-            __classPrivateFieldGet(this, _RpcPlugin_rpc, "f").notify(type, arg);
-        }
-        catch (e) {
-            // this only happens if the RPC library is hitting some issues - probably redundant
+  }
+  // forcibly kills the plugin
+  async kill() {
+    this.#rpc.rejectAllPendingRequests("Plugin Terminated");
+    this.detachListeners();
+    this.omegga.off("*", this.eventPassthrough);
+    if (!this.#child) return;
+    const promise = new Promise((resolve) => this.#child.once("exit", resolve));
+    this.#child.kill("SIGINT");
+    node_child_process.spawn("kill", ["-9", this.#child.pid + ""]);
+    await promise;
+    this.#child = void 0;
+    this.emitStatus();
+  }
+  eventPassthrough(type, ...args) {
+    if (!this.#child) return;
+    this.notify(type, args);
+  }
+  // setup the JSONRPC communication
+  initRPC() {
+    const server = new jsonRpc2_0.JSONRPCServer();
+    const client = new jsonRpc2_0.JSONRPCClient((req) => {
+      try {
+        this.writeln(JSON.stringify(req));
+        return Promise.resolve();
+      } catch (error) {
+        return Promise.reject(error);
+      }
+    });
+    const rpc = this.#rpc = new jsonRpc2_0.JSONRPCServerAndClient(server, client);
+    const ezLog = (logFn, name2, symbol) => (line) => console[logFn](name2.underline, symbol, line);
+    const name = this.getName();
+    rpc.addMethod("log", ezLog("log", name, ">>".green));
+    rpc.addMethod("error", ezLog("error", name.brightRed, "!>".red));
+    rpc.addMethod("info", ezLog("info", name, "#>".blue));
+    rpc.addMethod("debug", ezLog("debug", name, "?>".blue));
+    rpc.addMethod("warn", ezLog("warn", name.brightYellow, ":>".yellow));
+    rpc.addMethod("trace", ezLog("trace", name, "T>".grey));
+    rpc.addMethod(
+      "store.get",
+      (key) => this.storage.get(key)
+    );
+    rpc.addMethod(
+      "store.set",
+      ([key, value]) => this.storage.set(key, value)
+    );
+    rpc.addMethod(
+      "store.delete",
+      (key) => this.storage.delete(key)
+    );
+    rpc.addMethod("store.wipe", () => this.storage.wipe());
+    rpc.addMethod("store.count", () => this.storage.count());
+    rpc.addMethod("store.keys", () => this.storage.keys());
+    rpc.addMethod(
+      "exec",
+      (line) => this.omegga.writeln(line)
+    );
+    rpc.addMethod(
+      "writeln",
+      (line) => this.omegga.writeln(line)
+    );
+    rpc.addMethod(
+      "broadcast",
+      (line) => this.omegga.broadcast(line)
+    );
+    rpc.addMethod(
+      "whisper",
+      ({ target, line }) => this.omegga.whisper(target, line)
+    );
+    rpc.addMethod(
+      "middlePrint",
+      ({ target, line }) => this.omegga.middlePrint(target, line)
+    );
+    rpc.addMethod("getPlayers", () => this.omegga.getPlayers());
+    rpc.addMethod(
+      "getPlayerPosition",
+      (name2) => this.omegga.getPlayer(name2)?.getPosition()
+    );
+    rpc.addMethod(
+      "getAllPlayerPositions",
+      () => this.omegga.getAllPlayerPositions()
+    );
+    rpc.addMethod(
+      "getEnvironmentPresets",
+      () => this.omegga.getEnvironmentPresets()
+    );
+    rpc.addMethod("resetEnvironment", () => this.omegga.resetEnvironment());
+    rpc.addMethod(
+      "saveEnvironment",
+      (name2) => this.omegga.saveEnvironment(name2)
+    );
+    rpc.addMethod(
+      "loadEnvironment",
+      (name2) => this.omegga.loadEnvironment(name2)
+    );
+    rpc.addMethod(
+      "loadEnvironmentData",
+      (data) => this.omegga.loadEnvironmentData(data)
+    );
+    rpc.addMethod("getServerStatus", () => this.omegga.getServerStatus());
+    rpc.addMethod("getMinigames", () => this.omegga.getMinigames());
+    rpc.addMethod("getMinigamePresets", () => this.omegga.getMinigamePresets());
+    rpc.addMethod(
+      "saveMinigame",
+      ({ index, name: name2 }) => this.omegga.saveMinigame(index, name2)
+    );
+    rpc.addMethod(
+      "loadMinigame",
+      ({ name: name2, owner }) => this.omegga.loadMinigame(name2, owner)
+    );
+    rpc.addMethod(
+      "nextRoundMinigame",
+      (index) => this.omegga.nextRoundMinigame(index)
+    );
+    rpc.addMethod(
+      "resetMinigame",
+      (index) => this.omegga.resetMinigame(index)
+    );
+    rpc.addMethod(
+      "deleteMinigame",
+      (index) => this.omegga.deleteMinigame(index)
+    );
+    rpc.addMethod("listMinigames", () => this.omegga.listMinigames());
+    rpc.addMethod("getHostId", () => this.omegga.getHostId());
+    rpc.addMethod("getRoleSetup", () => this.omegga.getRoleSetup());
+    rpc.addMethod("getBanList", () => this.omegga.getBanList());
+    rpc.addMethod("getSaves", () => this.omegga.getSaves());
+    rpc.addMethod(
+      "getSavePath",
+      (name2) => this.omegga.getSavePath(name2)
+    );
+    rpc.addMethod(
+      "clearBricks",
+      ({ target, quiet = false }) => this.omegga.clearBricks(target, quiet)
+    );
+    rpc.addMethod(
+      "clearAllBricks",
+      (quiet) => this.omegga.clearAllBricks(quiet)
+    );
+    rpc.addMethod(
+      "saveBricks",
+      (name2) => this.omegga.saveBricks(name2)
+    );
+    rpc.addMethod(
+      "loadBricks",
+      ({
+        name: name2,
+        offX = 0,
+        offY = 0,
+        offZ = 0,
+        quiet = false
+      }) => this.omegga.loadBricks(name2, { offX, offY, offZ, quiet })
+    );
+    rpc.addMethod(
+      "loadBricksOnPlayer",
+      ({
+        name: name2,
+        player,
+        offX = 0,
+        offY = 0,
+        offZ = 0
+      }) => this.omegga.loadBricksOnPlayer(name2, player, { offX, offY, offZ })
+    );
+    rpc.addMethod(
+      "readSaveData",
+      (name2) => this.omegga.readSaveData(name2)
+    );
+    rpc.addMethod("getSaveData", () => this.omegga.getSaveData());
+    rpc.addMethod(
+      "loadSaveData",
+      ({
+        data,
+        offX = 0,
+        offY = 0,
+        offZ = 0,
+        quiet = false
+      }) => this.omegga.loadSaveData(data, { offX, offY, offZ, quiet })
+    );
+    rpc.addMethod(
+      "loadSaveDataOnPlayer",
+      ({
+        data,
+        player,
+        offX = 0,
+        offY = 0,
+        offZ = 0
+      }) => this.omegga.loadSaveDataOnPlayer(data, player, { offX, offY, offZ })
+    );
+    rpc.addMethod(
+      "changeMap",
+      (map) => this.omegga.changeMap(map)
+    );
+    rpc.addMethod("unload", () => this.unload());
+    rpc.addMethod("reload", async () => {
+      await this.unload();
+      await this.load();
+    });
+    const addPlayerMethod = (name2) => rpc.addMethod(
+      `player.${name2}`,
+      (player) => this.omegga.getPlayer(player)?.[name2]()
+    );
+    rpc.addMethod("player.get", (target) => {
+      let player = this.omegga.getPlayer(target);
+      return player && { ...player, host: player.isHost() };
+    });
+    addPlayerMethod("getRoles");
+    addPlayerMethod("getPermissions");
+    addPlayerMethod("getNameColor");
+    addPlayerMethod("getPosition");
+    addPlayerMethod("getPawn");
+    addPlayerMethod("getGhostBrick");
+    addPlayerMethod("getPaint");
+    addPlayerMethod("isCrouched");
+    addPlayerMethod("isDead");
+    addPlayerMethod("getTemplateBounds");
+    addPlayerMethod("getTemplateBoundsData");
+    addPlayerMethod("kill");
+    addPlayerMethod("getScore");
+    addPlayerMethod("getLeaderboard");
+    rpc.addMethod(
+      "player.loadDataAtGhostBrick",
+      ({
+        target,
+        data,
+        rotate = true,
+        offX = 0,
+        offY = 0,
+        offZ = 0,
+        quiet = false
+      }) => this.omegga.getPlayer(target)?.loadDataAtGhostBrick(data, { rotate, offX, offY, offZ, quiet })
+    );
+    rpc.addMethod(
+      "player.loadSaveData",
+      ({
+        target,
+        data,
+        offX = 0,
+        offY = 0,
+        offZ = 0
+      }) => this.omegga.getPlayer(target)?.loadSaveData(data, { offX, offY, offZ })
+    );
+    rpc.addMethod(
+      "player.clearBricks",
+      ({ target, quiet = false }) => this.omegga.getPlayer(target)?.clearBricks(quiet)
+    );
+    rpc.addMethod(
+      "player.loadBricks",
+      ({ target, saveName }) => this.omegga.getPlayer(target)?.loadBricks(saveName)
+    );
+    rpc.addMethod(
+      "player.damage",
+      ({ target, amount }) => this.omegga.getPlayer(target)?.damage(amount)
+    );
+    rpc.addMethod(
+      "player.heal",
+      ({ target, amount }) => this.omegga.getPlayer(target)?.heal(amount)
+    );
+    rpc.addMethod(
+      "player.giveItem",
+      ({ target, item }) => this.omegga.getPlayer(target)?.giveItem(item)
+    );
+    rpc.addMethod(
+      "player.takeItem",
+      ({ target, item }) => this.omegga.getPlayer(target)?.takeItem(item)
+    );
+    rpc.addMethod(
+      "player.setTeam",
+      ({ target, teamIndex }) => this.omegga.getPlayer(target)?.setTeam(teamIndex)
+    );
+    rpc.addMethod(
+      "player.setMinigame",
+      ({ target, index }) => this.omegga.getPlayer(target)?.setMinigame(index)
+    );
+    rpc.addMethod(
+      "player.setScore",
+      ({
+        target,
+        minigameIndex,
+        score
+      }) => this.omegga.getPlayer(target)?.setScore(minigameIndex, score)
+    );
+    rpc.addMethod(
+      "player.setLeaderboard",
+      ({
+        target,
+        key,
+        value
+      }) => this.omegga.getPlayer(target)?.setLeaderboard(key, value)
+    );
+    rpc.addMethod("plugin.get", async (name2) => {
+      const plugin = this.omegga.pluginLoader.plugins.find(
+        (p) => p.getName() === name2
+      );
+      if (plugin) {
+        return {
+          name: name2,
+          documentation: plugin.getDocumentation(),
+          loaded: plugin.isLoaded()
+        };
+      } else {
+        return null;
+      }
+    });
+    rpc.addMethod(
+      "plugin.emit",
+      async ([name2, event, ...args]) => {
+        const plugin = this.omegga.pluginLoader.plugins.find(
+          (p) => p.getName() === name2
+        );
+        if (plugin) {
+          return plugin.emitPlugin(event, this.getName(), args);
+        } else {
+          return null;
         }
+      }
+    );
+  }
+  // emit a custom plugin event
+  async emitPlugin(event, from, args) {
+    return await this.emit("plugin:emit", [event, from, ...args]);
+  }
+  // emit a message to the plugin via the jsonrpc client and expect a response
+  emit(type, arg) {
+    return this.#rpc.request(type, arg);
+  }
+  // emit a message to the plugin via the jsonrpc client, don't expect a response
+  notify(type, arg) {
+    try {
+      this.#rpc.notify(type, arg);
+    } catch (e) {
     }
+  }
 }
-_RpcPlugin_child = new WeakMap(), _RpcPlugin_rpc = new WeakMap(), _RpcPlugin_errInterface = new WeakMap(), _RpcPlugin_outInterface = new WeakMap();
 exports.default = RpcPlugin;
-//# sourceMappingURL=plugin_jsonrpc_stdio.js.map
+//# sourceMappingURL=plugin_jsonrpc_stdio.js.map