omegga 1.2.9 → 1.3.0

package/dist/omegga/plugin/plugin_node_safe.js

@@ -1,407 +1,379 @@
 "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 _NodeVmPlugin_worker, _NodeVmPlugin_outInterface, _NodeVmPlugin_errInterface;
-Object.defineProperty(exports, "__esModule", { value: true });
-const logger_1 = __importDefault(require("../../logger"));
-const events_1 = __importDefault(require("events"));
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const readline_1 = __importDefault(require("readline"));
-const worker_threads_1 = require("worker_threads");
-const interface_1 = require("./interface");
-const proxyOmegga_1 = require("./plugin_node_safe/proxyOmegga");
-// Main plugin file (like index.js)
-// this isn't named 'index.js' or 'plugin.js' because those may be filenames
-// used with other loaders (rpc loader) and are too generic
-// omegga.main.js is rather unique and helps avoid collision
-const MAIN_FILE = 'omegga.plugin.js';
-const MAIN_FILE_TS = 'omegga.plugin.ts';
-// Documentation file (contains name, description, author, command helptext)
-const DOC_FILE = 'doc.json';
-const ACCESS_FILE = 'access.json';
-const PLUGIN_FILE = 'plugin.json';
-class NodeVmPlugin extends interface_1.Plugin {
-    // every node vm plugin requires a main file, a doc file, and an access file
-    // may evolve this so it checks the contents of the doc file later
-    static canLoad(pluginPath) {
-        return ((fs_1.default.existsSync(path_1.default.join(pluginPath, MAIN_FILE)) ||
-            fs_1.default.existsSync(path_1.default.join(pluginPath, MAIN_FILE_TS))) &&
-            fs_1.default.existsSync(path_1.default.join(pluginPath, DOC_FILE)) &&
-            fs_1.default.existsSync(path_1.default.join(pluginPath, ACCESS_FILE)));
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const logger = require("../../logger.js");
+const EventEmitter = require("node:events");
+const fs = require("node:fs");
+const path = require("node:path");
+const node_worker_threads = require("node:worker_threads");
+const readline = require("readline");
+const _interface = require("./interface.js");
+const proxyOmegga = require("./plugin_node_safe/proxyOmegga.js");
+const MAIN_FILE = "omegga.plugin.js";
+const MAIN_FILE_TS = "omegga.plugin.ts";
+const DOC_FILE = "doc.json";
+const ACCESS_FILE = "access.json";
+const PLUGIN_FILE = "plugin.json";
+class NodeVmPlugin extends _interface.Plugin {
+  #worker;
+  #outInterface;
+  #errInterface;
+  // every node vm plugin requires a main file, a doc file, and an access file
+  // may evolve this so it checks the contents of the doc file later
+  static canLoad(pluginPath) {
+    return (fs.existsSync(path.join(pluginPath, MAIN_FILE)) || fs.existsSync(path.join(pluginPath, MAIN_FILE_TS))) && fs.existsSync(path.join(pluginPath, DOC_FILE)) && fs.existsSync(path.join(pluginPath, ACCESS_FILE));
+  }
+  // safe node plugins are limited
+  static getFormat() {
+    return "node_safe";
+  }
+  constructor(pluginPath, omegga) {
+    super(pluginPath, omegga);
+    this.plugin = new EventEmitter();
+    this.messageCounter = 0;
+    this.documentation = _interface.Plugin.readJSON(path.join(pluginPath, DOC_FILE));
+    this.isTypeScript = fs.existsSync(path.join(pluginPath, MAIN_FILE_TS));
+    this.pluginConfig = _interface.Plugin.readJSON(path.join(pluginPath, PLUGIN_FILE));
+    this.access = _interface.Plugin.readJSON(path.join(pluginPath, ACCESS_FILE)) || [];
+    this.commands = [];
+    if (!(this.access instanceof Array) || !this.access.every((s) => typeof s === "string")) {
+      throw new Error("access list not a string array");
     }
-    // safe node plugins are limited
-    static getFormat() {
-        return 'node_safe';
-    }
-    constructor(pluginPath, omegga) {
-        super(pluginPath, omegga);
-        _NodeVmPlugin_worker.set(this, void 0);
-        _NodeVmPlugin_outInterface.set(this, void 0);
-        _NodeVmPlugin_errInterface.set(this, void 0);
-        // event emitter and message counter for keeping track of worker events
-        this.plugin = new events_1.default();
-        this.messageCounter = 0;
-        // TODO: validate documentation
-        this.documentation = interface_1.Plugin.readJSON(path_1.default.join(pluginPath, DOC_FILE));
-        this.isTypeScript = fs_1.default.existsSync(path_1.default.join(pluginPath, MAIN_FILE_TS));
-        this.pluginConfig = interface_1.Plugin.readJSON(path_1.default.join(pluginPath, PLUGIN_FILE));
-        // access list is a list of builtin requires
-        // can be ['*'] for everything
-        this.access = interface_1.Plugin.readJSON(path_1.default.join(pluginPath, ACCESS_FILE)) || [];
-        // list of registered commands
-        this.commands = [];
-        // verify access is an array of strings
-        if (!(this.access instanceof Array) ||
-            !this.access.every(s => typeof s === 'string')) {
-            throw new Error('access list not a string array');
-        }
-        // plugin name
-        const name = this.getName();
-        // when the worker emits an error or a log, pass it up to omegga
-        this.plugin.on('error', (resp, ...args) => {
-            logger_1.default.error(name.brightRed.underline, '!>'.red, ...args);
-            this.notify(resp);
-        });
-        this.plugin.on('log', (resp, ...args) => {
-            logger_1.default.log(name.underline, '>>'.green, ...args);
-            this.notify(resp);
-        });
-        // let the worker write commands to brickadia
-        this.plugin.on('exec', (_, cmd) => omegga.writeln(cmd));
-        // storage interface
-        this.plugin.on('store.get', async (resp, key) => {
-            try {
-                this.notify(resp, await this.storage.get(key));
-            }
-            catch (e) {
-                logger_1.default.error(name.brightRed.underline, '!>'.red, 'error in store.get of', key, e);
-            }
-        });
-        this.plugin.on('store.set', async (resp, key, value) => {
-            try {
-                await this.storage.set(key, JSON.parse(value));
-            }
-            catch (e) {
-                logger_1.default.error(name.brightRed.underline, '!>'.red, 'error in store.set of', key, value, e);
-            }
-            this.notify(resp);
-        });
-        this.plugin.on('store.delete', async (resp, key) => {
-            try {
-                await this.storage.delete(key);
-            }
-            catch (e) {
-                logger_1.default.error(name.brightRed.underline, '!>'.red, 'error in store.delete of', key, e);
-            }
-            this.notify(resp);
-        });
-        this.plugin.on('store.wipe', async (resp) => {
-            try {
-                await this.storage.wipe();
-            }
-            catch (e) {
-                logger_1.default.error(name.brightRed.underline, '!>'.red, 'error in store.wipe', e);
-            }
-            this.notify(resp);
+    const name = this.getName();
+    this.plugin.on("error", (resp, ...args) => {
+      logger.default.error(name.brightRed.underline, "!>".red, ...args);
+      this.notify(resp);
+    });
+    this.plugin.on("log", (resp, ...args) => {
+      logger.default.log(name.underline, ">>".green, ...args);
+      this.notify(resp);
+    });
+    this.plugin.on("exec", (_, cmd) => omegga.writeln(cmd));
+    this.plugin.on("store.get", async (resp, key) => {
+      try {
+        this.notify(resp, await this.storage.get(key));
+      } catch (e) {
+        logger.default.error(
+          name.brightRed.underline,
+          "!>".red,
+          "error in store.get of",
+          key,
+          e
+        );
+      }
+    });
+    this.plugin.on("store.set", async (resp, key, value) => {
+      try {
+        await this.storage.set(key, JSON.parse(value));
+      } catch (e) {
+        logger.default.error(
+          name.brightRed.underline,
+          "!>".red,
+          "error in store.set of",
+          key,
+          value,
+          e
+        );
+      }
+      this.notify(resp);
+    });
+    this.plugin.on("store.delete", async (resp, key) => {
+      try {
+        await this.storage.delete(key);
+      } catch (e) {
+        logger.default.error(
+          name.brightRed.underline,
+          "!>".red,
+          "error in store.delete of",
+          key,
+          e
+        );
+      }
+      this.notify(resp);
+    });
+    this.plugin.on("store.wipe", async (resp) => {
+      try {
+        await this.storage.wipe();
+      } catch (e) {
+        logger.default.error(
+          name.brightRed.underline,
+          "!>".red,
+          "error in store.wipe",
+          e
+        );
+      }
+      this.notify(resp);
+    });
+    this.plugin.on("store.count", async (resp) => {
+      try {
+        this.notify(resp, await this.storage.count());
+      } catch (e) {
+        logger.default.error(
+          name.brightRed.underline,
+          "!>".red,
+          "error in store.count",
+          e
+        );
+      }
+    });
+    this.plugin.on("store.keys", async (resp) => {
+      try {
+        this.notify(resp, await this.storage.keys());
+      } catch (e) {
+        logger.default.error(
+          name.brightRed.underline,
+          "!>".red,
+          "error in store.keys",
+          e
+        );
+      }
+    });
+    this.plugin.on("getPlugin", async (resp, name2) => {
+      const plugin = this.omegga.pluginLoader.plugins.find(
+        (p) => p.getName() === name2
+      );
+      if (plugin) {
+        this.notify(resp, {
+          name: name2,
+          documentation: plugin.getDocumentation(),
+          loaded: plugin.isLoaded()
         });
-        this.plugin.on('store.count', async (resp) => {
-            try {
-                this.notify(resp, await this.storage.count());
-            }
-            catch (e) {
-                logger_1.default.error(name.brightRed.underline, '!>'.red, 'error in store.count', e);
-            }
-        });
-        this.plugin.on('store.keys', async (resp) => {
-            try {
-                this.notify(resp, await this.storage.keys());
-            }
-            catch (e) {
-                logger_1.default.error(name.brightRed.underline, '!>'.red, 'error in store.keys', e);
-            }
-        });
-        // plugin fetching
-        this.plugin.on('getPlugin', async (resp, name) => {
-            const plugin = this.omegga.pluginLoader.plugins.find(p => p.getName() === name);
-            if (plugin) {
-                this.notify(resp, {
-                    name,
-                    documentation: plugin.getDocumentation(),
-                    loaded: plugin.isLoaded(),
-                });
-            }
-            else {
-                this.notify(resp);
-            }
-        });
-        this.plugin.on('emitPlugin', async (resp, target, ev, args) => {
-            const plugin = this.omegga.pluginLoader.plugins.find(p => p.getName() === target);
-            if (plugin) {
-                let r = await plugin.emitPlugin(ev, name, args);
-                this.notify(resp, r);
-            }
-            else {
-                logger_1.default.error(name.brightRed.underline, '!>'.red, 'error in emitPlugin');
-            }
-        });
-        // command registration
-        this.plugin.on('command.registers', async (_, blob) => {
-            if (typeof blob !== 'string')
-                return;
-            const registers = JSON.parse(blob);
-            // ensure registers is an array of strings
-            if (!(registers instanceof Array) ||
-                registers.some(i => typeof i !== 'string'))
-                return;
-            this.commands = registers;
-        });
-        // listen on every message, post them to to the worker
-        this.eventPassthrough = this.eventPassthrough.bind(this);
-    }
-    // emit a custom plugin event
-    async emitPlugin(ev, from, args) {
-        var _a;
-        const [r] = (_a = (await this.emit('emitPlugin', ev, from, args))) !== null && _a !== void 0 ? _a : [];
-        return r;
-    }
-    // documentation is based on doc.json file
-    getDocumentation() {
-        return this.documentation;
-    }
-    // loaded state is based on if a worker exists
-    isLoaded() {
-        return !!__classPrivateFieldGet(this, _NodeVmPlugin_worker, "f");
-    }
-    // determing if a command is registered
-    isCommand(cmd) {
-        return this.commands.includes(cmd);
-    }
-    // require the plugin into the system, run the init func
-    async load() {
-        var _a;
-        // can't load the plugin if it's already loaded
-        if (typeof __classPrivateFieldGet(this, _NodeVmPlugin_worker, "f") !== 'undefined')
-            return false;
-        // vm restriction settings, default is access to everything
-        const vmOptions = {
-            builtin: this.access, // TODO: reference access file
-            external: true, // TODO: reference access file
-            isTypeScript: this.isTypeScript,
-        };
-        this.commands = [];
-        try {
-            const config = await this.storage.getConfig();
-            if ((_a = this.pluginConfig) === null || _a === void 0 ? void 0 : _a.emitConfig) {
-                await fs_1.default.promises.writeFile(path_1.default.join(this.path, this.pluginConfig.emitConfig), JSON.stringify(config));
-            }
-            this.createWorker();
-            // tell the worker its name :)
-            await this.emit('name', this.getName());
-            // create the vm, export the plugin's class
-            logger_1.default.verbose('Loading safe plugin');
-            if (!(await this.emit('load', this.path, vmOptions))[0])
-                throw '';
-            // get some initial information to create an omegga proxy
-            const initialData = (0, proxyOmegga_1.bootstrap)(this.omegga);
-            // send all of the mock events to the proxy omegga
-            logger_1.default.verbose('Sending initial data to safe plugin');
-            for (const ev in initialData) {
-                try {
-                    __classPrivateFieldGet(this, _NodeVmPlugin_worker, "f").postMessage({
-                        action: 'brickadiaEvent',
-                        args: [ev, ...initialData[ev]],
-                    });
-                }
-                catch (e) {
-                    /* just writing 'safe' code :) */
-                }
-            }
-            // pass events through
-            this.omegga.on('*', this.eventPassthrough);
-            logger_1.default.verbose('Starting safe plugin');
-            // actually start the plugin
-            if (!(await this.emit('start', config))[0])
-                throw 'plugin failed start';
-            this.emitStatus();
-            return true;
-        }
-        catch (e) {
-            // kill the worker
-            await this.emit('kill');
-            logger_1.default.error('!>'.red, 'error loading node vm plugin', this.getName().brightRed.underline, e);
-            this.emitStatus();
-            return false;
-        }
-    }
-    // disrequire the plugin into the system, run the stop func
-    unload() {
-        let frozen = true, timed = false;
-        return Promise.race([
-            (async () => {
-                // can't unload the plugin if it hasn't been loaded
-                if (typeof __classPrivateFieldGet(this, _NodeVmPlugin_worker, "f") === 'undefined')
-                    return false;
-                try {
-                    // stop the plugin (cleanly)
-                    await this.emit('stop');
-                    // remove listeners
-                    this.omegga.off('*', this.eventPassthrough);
-                    // let the unload function wait for the worker to properly cleanup
-                    const promise = new Promise(res => {
-                        __classPrivateFieldGet(this, _NodeVmPlugin_worker, "f").once('exit', res);
-                    });
-                    // kill the worker
-                    await this.emit('kill');
-                    // wait for the worker to exit
-                    await promise;
-                    frozen = false;
-                    if (timed)
-                        return;
-                    this.emitStatus();
-                    this.commands = [];
-                    return true;
-                }
-                catch (e) {
-                    frozen = false;
-                    if (timed)
-                        return;
-                    logger_1.default.error('!>'.red, 'error unloading node plugin', this.getName().brightRed.underline, e);
-                    this.emitStatus();
-                    return false;
-                }
-            })(),
-            new Promise(resolve => {
-                // check if the worker is frozen (while true)
-                setTimeout(() => {
-                    if (!frozen)
-                        return;
-                    this.plugin.emit('error', 0, 'I appear to be in an unresponsive state - terminating worker');
-                    // remove listeners
-                    this.omegga.off('*', this.eventPassthrough);
-                    // tell the worker to exit
-                    if (__classPrivateFieldGet(this, _NodeVmPlugin_worker, "f"))
-                        __classPrivateFieldGet(this, _NodeVmPlugin_worker, "f").emit('exit');
-                    // terminate the worker if it still exists
-                    try {
-                        if (__classPrivateFieldGet(this, _NodeVmPlugin_worker, "f"))
-                            __classPrivateFieldGet(this, _NodeVmPlugin_worker, "f").terminate();
-                    }
-                    catch (err) {
-                        console.error('error terminating worker:', err);
-                    }
-                    timed = true;
-                    resolve(true);
-                    this.emitStatus();
-                }, 5000);
-            }),
-        ]);
-    }
-    // emit an action to the worker and return a promise with its response
-    emit(action, ...args) {
-        if (!__classPrivateFieldGet(this, _NodeVmPlugin_worker, "f"))
-            return;
-        const messageId = 'message:' + this.messageCounter++;
-        // promise waits for the message to resolve
-        const promise = new Promise(resolve => this.plugin.once(messageId, (_, ...x) => resolve(x)));
-        // post the message
+      } else {
+        this.notify(resp);
+      }
+    });
+    this.plugin.on("emitPlugin", async (resp, target, ev, args) => {
+      const plugin = this.omegga.pluginLoader.plugins.find(
+        (p) => p.getName() === target
+      );
+      if (plugin) {
+        let r = await plugin.emitPlugin(ev, name, args);
+        this.notify(resp, r);
+      } else {
+        logger.default.error(name.brightRed.underline, "!>".red, "error in emitPlugin");
+      }
+    });
+    this.plugin.on("command.registers", async (_, blob) => {
+      if (typeof blob !== "string") return;
+      const registers = JSON.parse(blob);
+      if (!(registers instanceof Array) || registers.some((i) => typeof i !== "string"))
+        return;
+      this.commands = registers;
+    });
+    this.eventPassthrough = this.eventPassthrough.bind(this);
+  }
+  // emit a custom plugin event
+  async emitPlugin(ev, from, args) {
+    const [r] = await this.emit("emitPlugin", ev, from, args) ?? [];
+    return r;
+  }
+  // documentation is based on doc.json file
+  getDocumentation() {
+    return this.documentation;
+  }
+  // loaded state is based on if a worker exists
+  isLoaded() {
+    return !!this.#worker;
+  }
+  // determing if a command is registered
+  isCommand(cmd) {
+    return this.commands.includes(cmd);
+  }
+  // require the plugin into the system, run the init func
+  async load() {
+    if (typeof this.#worker !== "undefined") return false;
+    const vmOptions = {
+      builtin: this.access,
+      // TODO: reference access file
+      external: true,
+      // TODO: reference access file
+      isTypeScript: this.isTypeScript
+    };
+    this.commands = [];
+    try {
+      const config = await this.storage.getConfig();
+      if (this.pluginConfig?.emitConfig) {
+        await fs.promises.writeFile(
+          path.join(this.path, this.pluginConfig.emitConfig),
+          JSON.stringify(config)
+        );
+      }
+      this.createWorker();
+      await this.emit("name", this.getName());
+      logger.default.verbose("Loading safe plugin");
+      if (!(await this.emit("load", this.path, vmOptions))[0]) throw "";
+      const initialData = proxyOmegga.bootstrap(this.omegga);
+      logger.default.verbose("Sending initial data to safe plugin");
+      for (const ev in initialData) {
         try {
-            __classPrivateFieldGet(this, _NodeVmPlugin_worker, "f").postMessage({
-                action,
-                args: [messageId, ...args],
-            });
-        }
-        catch (e) {
-            return Promise.reject(e);
+          this.#worker.postMessage({
+            action: "brickadiaEvent",
+            args: [ev, ...initialData[ev]]
+          });
+        } catch (e) {
         }
-        // return the promise
-        return promise;
+      }
+      this.omegga.on("*", this.eventPassthrough);
+      logger.default.verbose("Starting safe plugin");
+      if (!(await this.emit("start", config))[0]) throw "plugin failed start";
+      this.emitStatus();
+      return true;
+    } catch (e) {
+      await this.emit("kill");
+      logger.default.error(
+        "!>".red,
+        "error loading node vm plugin",
+        this.getName().brightRed.underline,
+        e
+      );
+      this.emitStatus();
+      return false;
     }
-    // notify a response to the worker
-    notify(action, ...args) {
-        if (!__classPrivateFieldGet(this, _NodeVmPlugin_worker, "f"))
-            return;
-        // post the message
+  }
+  // disrequire the plugin into the system, run the stop func
+  unload() {
+    let frozen = true, timed = false;
+    return Promise.race([
+      (async () => {
+        if (typeof this.#worker === "undefined") return false;
         try {
-            __classPrivateFieldGet(this, _NodeVmPlugin_worker, "f").postMessage({
-                action,
-                args: [...args],
-            });
-        }
-        catch (e) {
-            // do nothing here
+          await this.emit("stop");
+          this.omegga.off("*", this.eventPassthrough);
+          const promise = new Promise((res) => {
+            this.#worker.once("exit", res);
+          });
+          await this.emit("kill");
+          await promise;
+          frozen = false;
+          if (timed) return;
+          this.emitStatus();
+          this.commands = [];
+          return true;
+        } catch (e) {
+          frozen = false;
+          if (timed) return;
+          logger.default.error(
+            "!>".red,
+            "error unloading node plugin",
+            this.getName().brightRed.underline,
+            e
+          );
+          this.emitStatus();
+          return false;
         }
+      })(),
+      new Promise((resolve) => {
+        setTimeout(() => {
+          if (!frozen) return;
+          this.plugin.emit(
+            "error",
+            0,
+            "I appear to be in an unresponsive state - terminating worker"
+          );
+          this.omegga.off("*", this.eventPassthrough);
+          if (this.#worker) this.#worker.emit("exit");
+          try {
+            if (this.#worker) this.#worker.terminate();
+          } catch (err) {
+            console.error("error terminating worker:", err);
+          }
+          timed = true;
+          resolve(true);
+          this.emitStatus();
+        }, 5e3);
+      })
+    ]);
+  }
+  // emit an action to the worker and return a promise with its response
+  emit(action, ...args) {
+    if (!this.#worker) return;
+    const messageId = "message:" + this.messageCounter++;
+    const promise = new Promise(
+      (resolve) => this.plugin.once(messageId, (_, ...x) => resolve(x))
+    );
+    try {
+      this.#worker.postMessage({
+        action,
+        args: [messageId, ...args]
+      });
+    } catch (e) {
+      return Promise.reject(e);
     }
-    // create the worker for this plugin, attach emitter
-    createWorker() {
-        __classPrivateFieldSet(this, _NodeVmPlugin_worker, new worker_threads_1.Worker(path_1.default.join(__dirname, 'plugin_node_safe/worker.js'), {
-            stdout: true,
-            env: {
-                VERBOSE: logger_1.default.VERBOSE + '',
-            },
-        }), "f");
-        // pipe plugin output into omegga
-        __classPrivateFieldSet(this, _NodeVmPlugin_outInterface, readline_1.default.createInterface({
-            input: __classPrivateFieldGet(this, _NodeVmPlugin_worker, "f").stdout,
-            terminal: false,
-        }), "f");
-        __classPrivateFieldSet(this, _NodeVmPlugin_errInterface, readline_1.default.createInterface({
-            input: __classPrivateFieldGet(this, _NodeVmPlugin_worker, "f").stderr,
-            terminal: false,
-        }), "f");
-        __classPrivateFieldGet(this, _NodeVmPlugin_outInterface, "f").on('line', logger_1.default.log);
-        __classPrivateFieldGet(this, _NodeVmPlugin_errInterface, "f").on('line', logger_1.default.error);
-        // attach message emitter
-        __classPrivateFieldGet(this, _NodeVmPlugin_worker, "f").on('message', ({ action, args }) => this.plugin.emit(action, ...args));
-        // broadcast an error if there is one
-        __classPrivateFieldGet(this, _NodeVmPlugin_worker, "f").on('error', err => {
-            logger_1.default.error('!>'.red, 'error in plugin', this.getName().brightRed.underline, err);
-        });
-        // when the worker exits - set its variable to undefined this knows it's stopped
-        __classPrivateFieldGet(this, _NodeVmPlugin_worker, "f").on('exit', () => {
-            this.omegga.off('*', this.eventPassthrough);
-            __classPrivateFieldGet(this, _NodeVmPlugin_outInterface, "f").removeAllListeners('line');
-            __classPrivateFieldGet(this, _NodeVmPlugin_errInterface, "f").removeAllListeners('line');
-            try {
-                if (__classPrivateFieldGet(this, _NodeVmPlugin_worker, "f"))
-                    __classPrivateFieldGet(this, _NodeVmPlugin_worker, "f").terminate();
-            }
-            catch (err) {
-                logger_1.default.error('!>'.red, 'Error terminating worker for', this.getName().brightRed.underline, err);
-            }
-            __classPrivateFieldSet(this, _NodeVmPlugin_worker, undefined, "f");
-            this.emitStatus();
-        });
+    return promise;
+  }
+  // notify a response to the worker
+  notify(action, ...args) {
+    if (!this.#worker) return;
+    try {
+      this.#worker.postMessage({
+        action,
+        args: [...args]
+      });
+    } catch (e) {
     }
-    eventPassthrough(...args) {
-        // worker does not exist
-        if (!__classPrivateFieldGet(this, _NodeVmPlugin_worker, "f"))
-            return;
-        try {
-            // post the message
-            __classPrivateFieldGet(this, _NodeVmPlugin_worker, "f").postMessage({
-                action: 'brickadiaEvent',
-                args,
-            });
-        }
-        catch (e) {
-            // make sure post message doesn't crash the entire app
-            logger_1.default.error('!>'.red, 'error sending to plugin', ...args, e);
+  }
+  // create the worker for this plugin, attach emitter
+  createWorker() {
+    this.#worker = new node_worker_threads.Worker(
+      // vite transpiles worker.ts to dist/worker.js
+      path.join(__dirname, "../../worker.js"),
+      {
+        stdout: true,
+        env: {
+          VERBOSE: logger.default.VERBOSE + ""
         }
+      }
+    );
+    this.#outInterface = readline.createInterface({
+      input: this.#worker.stdout,
+      terminal: false
+    });
+    this.#errInterface = readline.createInterface({
+      input: this.#worker.stderr,
+      terminal: false
+    });
+    this.#outInterface.on("line", logger.default.log);
+    this.#errInterface.on("line", logger.default.error);
+    this.#worker.on(
+      "message",
+      ({ action, args }) => this.plugin.emit(action, ...args)
+    );
+    this.#worker.on("error", (err) => {
+      logger.default.error(
+        "!>".red,
+        "error in plugin",
+        this.getName().brightRed.underline,
+        err
+      );
+    });
+    this.#worker.on("exit", () => {
+      this.omegga.off("*", this.eventPassthrough);
+      this.#outInterface.removeAllListeners("line");
+      this.#errInterface.removeAllListeners("line");
+      try {
+        if (this.#worker) this.#worker.terminate();
+      } catch (err) {
+        logger.default.error(
+          "!>".red,
+          "Error terminating worker for",
+          this.getName().brightRed.underline,
+          err
+        );
+      }
+      this.#worker = void 0;
+      this.emitStatus();
+    });
+  }
+  eventPassthrough(...args) {
+    if (!this.#worker) return;
+    try {
+      this.#worker.postMessage({
+        action: "brickadiaEvent",
+        args
+      });
+    } catch (e) {
+      logger.default.error("!>".red, "error sending to plugin", ...args, e);
     }
+  }
 }
-_NodeVmPlugin_worker = new WeakMap(), _NodeVmPlugin_outInterface = new WeakMap(), _NodeVmPlugin_errInterface = new WeakMap();
 exports.default = NodeVmPlugin;
-//# sourceMappingURL=plugin_node_safe.js.map
+//# sourceMappingURL=plugin_node_safe.js.map