omegga 0.1.85 → 1.0.2

package/src/omegga/plugin/plugin_node_safe/worker.js

@@ -1,238 +0,0 @@
-// The safe node plugin is run inside of a worker
-// so if the plugin inevitably crashes, only the worker dies
-// this also lets plugins get terminated easier by killing the worker
-// rather than unloading and reloading code
-
-const path = require('path');
-const fs = require('fs');
-const { parentPort } = require('worker_threads');
-const { ProxyOmegga } = require('./proxyOmegga.js');
-const { EventEmitter } = require('events');
-
-const { NodeVM } = require('vm2');
-require('colors');
-
-const MAIN_FILE = 'omegga.plugin.js';
-let vm, PluginClass, pluginInstance;
-let pluginName = 'unnamed plugin';
-let messageCounter = 0;
-// emitter that receives messages from the parent
-const parent = new EventEmitter();
-
-// handle message passing
-parentPort.on('message', ({ action, args }) => parent.emit(action, ...args));
-
-// emit a message to the parent port - async wait for a reponse
-const emit = (action, ...args) => {
-  const messageId = 'message:' + messageCounter++;
-
-  let rejectFn;
-  // promise waits for the message to resolve
-  const promise = new Promise((resolve, reject) => {
-    parent.once(messageId, resolve);
-    rejectFn = reject;
-  });
-
-  try {
-    // post the message
-    parentPort.postMessage({ action, args: [messageId, ...args] });
-  } catch (err) {
-    rejectFn(err);
-  }
-
-  // return the promise
-  return promise;
-};
-
-// tell omegga to exec a command
-const exec = cmd => emit('exec', cmd);
-
-// create the proxy omegga
-const omegga = new ProxyOmegga(exec);
-
-// add plugin fetcher
-omegga.getPlugin = async name => {
-  let plugin = await emit('getPlugin', name);
-  if (plugin) {
-    plugin.emit = async (ev, ...args) => {
-      return await emit('emitPlugin', name, ev, args);
-    };
-    return plugin;
-  } else {
-    return null;
-  }
-};
-
-// interface with plugin store
-const store = {
-  get: key => emit('store.get', key),
-  set: (key, value) => emit('store.set', key, JSON.stringify(value)),
-  delete: key => emit('store.delete', key),
-  wipe: () => emit('store.wipe'),
-  count: () => emit('store.count'),
-  keys: () => emit('store.keys'),
-};
-
-// generic brickadia events are forwarded to the proxy omegga
-parent.on('brickadiaEvent', (type, ...args) => {
-  if (!vm) return;
-  try {
-    omegga.emit(type, ...args);
-  } catch (e) {
-    console.log('error in brickadia event', e?.stack ?? e.toString());
-  }
-});
-
-// create the node vm
-function createVm(pluginPath, { builtin = ['*'], external = true } = {}) {
-  if (vm !== undefined) return [false, 'vm is already created'];
-
-  // create the vm
-  vm = new NodeVM({
-    console: 'redirect',
-    sandbox: {},
-    require: {
-      external,
-      builtin,
-      root: pluginPath,
-    },
-  });
-
-  // plugin log generator function
-  const ezLog =
-    (logFn, name, symbol) =>
-    (...args) =>
-      console[logFn](name.underline, symbol, ...args);
-
-  // special formatting for stdout
-  vm.on('console.log', ezLog('log', pluginName, '>>'.green));
-  vm.on('console.error', ezLog('error', pluginName.brightRed, '!>'.red));
-  vm.on('console.info', ezLog('info', pluginName, '#>'.blue));
-  vm.on('console.warn', ezLog('warn', pluginName.brightYellow, ':>'.yellow));
-  vm.on('console.trace', ezLog('trace', pluginName, 'T>'.grey));
-
-  global.OMEGGA_UTIL = require('../../../util/index.js');
-  // pass in util functions
-  vm.freeze(global.OMEGGA_UTIL, 'OMEGGA_UTIL');
-  vm.freeze(omegga, 'Omegga');
-
-  const file = path.join(pluginPath, MAIN_FILE);
-  let pluginCode;
-
-  try {
-    pluginCode = fs.readFileSync(file);
-  } catch (e) {
-    emit('error', 'failed to read plugin source: ' + e?.stack ?? e.toString());
-    throw 'failed to read plugin source: ' + e?.stack ?? e.toString();
-  }
-
-  // proxy the plugin out of the vm
-  // potential for performance improvement by using VM.script to precompile plugins
-  try {
-    PluginClass = vm.run(pluginCode.toString(), file);
-  } catch (e) {
-    emit('error', 'plugin failed to init');
-    console.log(e);
-    throw 'plugin failed to init: ' + e?.stack ?? e.toString();
-  }
-
-  if (
-    !PluginClass ||
-    typeof PluginClass !== 'function' ||
-    typeof PluginClass.prototype !== 'object'
-  ) {
-    PluginClass = undefined;
-    emit('error', 'plugin does not export a class');
-    throw 'plugin does not export a class';
-  }
-
-  if (typeof PluginClass.prototype.init !== 'function') {
-    PluginClass = undefined;
-    emit('error', 'plugin is missing init() function');
-    throw 'plugin is missing init() function';
-  }
-
-  if (typeof PluginClass.prototype.stop !== 'function') {
-    PluginClass = undefined;
-    emit('error', 'plugin is missing stop() function');
-    throw 'plugin is missing stop() function';
-  }
-}
-
-// kill this plugin
-parent.on('kill', resp => {
-  emit(resp);
-  process.exit(0);
-});
-
-// set plugin name
-parent.on('name', (resp, name) => {
-  pluginName = name;
-  // temp save prefix changes to avoid collision
-  omegga._tempSavePrefix = 'omegga_' + name + '_temp';
-  emit(resp);
-});
-
-// get memory usage for this plugin
-parent.on('mem', resp => emit(resp, 'mem', process.memoryUsage()));
-
-// create the vm
-parent.on('load', (resp, pluginPath, options) => {
-  try {
-    createVm(pluginPath, options);
-    emit(resp, true);
-  } catch (err) {
-    console.error('error creating vm', err?.stack ?? err.toString());
-    emit(resp, false);
-  }
-});
-
-// start the plugin with a faux omegga
-// resp is an action sent back to the parent process
-// to coordinate async funcs
-parent.on('start', async (resp, config) => {
-  try {
-    pluginInstance = new PluginClass(omegga, config, store);
-    const result = await pluginInstance.init();
-    // if a plugin init returns a list of strings, treat them as the list of commands
-    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')
-      ) {
-        emit('command.registers', JSON.stringify(cmds));
-      }
-    }
-    emit(resp, true);
-  } catch (err) {
-    emit('error', 'error starting plugin', err?.stack ?? JSON.stringify(err));
-    emit(resp, false);
-    console.error(err);
-  }
-});
-
-// stop the plugin
-parent.on('stop', async resp => {
-  try {
-    if (pluginInstance) {
-      await pluginInstance.stop();
-    }
-    pluginInstance = undefined;
-    emit(resp, true);
-  } catch (err) {
-    emit('error', 'error stopping plugin', err?.stack ?? toString());
-    emit(resp, false);
-  }
-});
-
-// handle emitPlugins
-parent.on('emitPlugin', async (resp, ev, from, args) => {
-  if (pluginInstance?.pluginEvent) {
-    emit(resp, await pluginInstance.pluginEvent(ev, from, ...args));
-  } else {
-    emit(resp, null);
-  }
-});

package/src/omegga/plugin/plugin_node_safe.js

@@ -1,473 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const { EventEmitter } = require('events');
-const readline = require('readline');
-
-const { Worker } = require('worker_threads');
-
-const { Plugin } = require('../plugin.js');
-const { bootstrap } = require('./plugin_node_safe/proxyOmegga.js');
-const Omegga = require('../server.js');
-
-// 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';
-
-// 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 Plugin {
-  #worker = undefined;
-  #outInterface = undefined;
-  #errInterface = undefined;
-
-  // 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, 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);
-
-    // event emitter and message counter for keeping track of worker events
-    this.plugin = new EventEmitter();
-    this.messageCounter = 0;
-
-    // TODO: validate documentation
-    this.documentation = Plugin.readJSON(path.join(pluginPath, DOC_FILE));
-    this.pluginConfig = Plugin.readJSON(path.join(pluginPath, PLUGIN_FILE));
-
-    // access list is a list of builtin requires
-    // can be ['*'] for everything
-    this.access = Plugin.readJSON(path.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) => {
-      Omegga.error(name.brightRed.underline, '!>'.red, ...args);
-      this.notify(resp);
-    });
-    this.plugin.on('log', (resp, ...args) => {
-      Omegga.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) {
-        Omegga.error(
-          name.brightRed.underline,
-          '!>'.red,
-          'error in store.get of',
-          key
-        );
-      }
-    });
-    this.plugin.on('store.set', async (resp, key, value) => {
-      try {
-        await this.storage.set(key, JSON.parse(value));
-      } catch (e) {
-        Omegga.error(
-          name.brightRed.underline,
-          '!>'.red,
-          'error in store.set of',
-          key,
-          value
-        );
-      }
-      this.notify(resp);
-    });
-    this.plugin.on('store.delete', async (resp, key) => {
-      try {
-        await this.storage.delete(key);
-      } catch (e) {
-        Omegga.error(
-          name.brightRed.underline,
-          '!>'.red,
-          'error in store.delete of',
-          key
-        );
-      }
-      this.notify(resp);
-    });
-    this.plugin.on('store.wipe', async resp => {
-      try {
-        await this.storage.wipe();
-      } catch (e) {
-        Omegga.error(name.brightRed.underline, '!>'.red, 'error in store.wipe');
-      }
-      this.notify(resp);
-    });
-    this.plugin.on('store.count', async resp => {
-      try {
-        this.notify(resp, await this.storage.count());
-      } catch (e) {
-        Omegga.error(
-          name.brightRed.underline,
-          '!>'.red,
-          'error in store.count'
-        );
-      }
-    });
-    this.plugin.on('store.keys', async resp => {
-      try {
-        this.notify(resp, await this.storage.keys());
-      } catch (e) {
-        Omegga.error(name.brightRed.underline, '!>'.red, 'error in store.keys');
-      }
-    });
-
-    // 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 {
-        Omegga.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) {
-    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() {
-    // can't load the plugin if it's already loaded
-    if (typeof this.#worker !== '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
-    };
-    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();
-
-      // tell the worker its name :)
-      await this.emit('name', this.getName());
-
-      // create the vm, export the plugin's class
-      if (!(await this.emit('load', this.path, vmOptions))[0]) throw '';
-
-      // get some initial information to create an omegga proxy
-      const initialData = bootstrap(this.omegga);
-      // send all of the mock events to the proxy omegga
-      for (const ev in initialData) {
-        try {
-          this.#worker.postMessage({
-            action: 'brickadiaEvent',
-            args: [ev, ...initialData[ev]],
-          });
-        } catch (e) {
-          /* just writing 'safe' code :) */
-        }
-      }
-
-      // pass events through
-      this.omegga.on('*', this.eventPassthrough);
-
-      // 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');
-
-      Omegga.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 this.#worker === '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 => {
-            this.#worker.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;
-
-          Omegga.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 (this.#worker) this.#worker.emit('exit');
-
-          // terminate the worker if it still exists
-          if (this.#worker) this.#worker.terminate();
-
-          timed = true;
-          resolve(true);
-          this.emitStatus();
-        }, 5000);
-      }),
-    ]);
-  }
-
-  // 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++;
-
-    // promise waits for the message to resolve
-    const promise = new Promise(resolve =>
-      this.plugin.once(messageId, (_, ...x) => resolve(x))
-    );
-
-    // post the message
-    try {
-      this.#worker.postMessage({
-        action,
-        args: [messageId, ...args],
-      });
-    } catch (e) {
-      return Promise.reject(e);
-    }
-
-    // return the promise
-    return promise;
-  }
-
-  // notify a response to the worker
-  notify(action, ...args) {
-    if (!this.#worker) return;
-
-    // post the message
-    try {
-      this.#worker.postMessage({
-        action,
-        args: [...args],
-      });
-    } catch (e) {
-      // do nothing here
-    }
-  }
-
-  // create the worker for this plugin, attach emitter
-  createWorker() {
-    this.#worker = new Worker(
-      path.join(__dirname, 'plugin_node_safe/worker.js'),
-      {
-        stdout: true,
-      }
-    );
-
-    // pipe plugin output into omegga
-    this.#outInterface = readline.createInterface({
-      input: this.#worker.stdout,
-      terminal: false,
-    });
-    this.#errInterface = readline.createInterface({
-      input: this.#worker.stderr,
-      terminal: false,
-    });
-    this.#outInterface.on('line', Omegga.log);
-    this.#errInterface.on('line', Omegga.error);
-
-    // attach message emitter
-    this.#worker.on('message', ({ action, args }) =>
-      this.plugin.emit(action, ...args)
-    );
-
-    // broadcast an error if there is one
-    this.#worker.on('error', err => {
-      Omegga.error(
-        '!>'.red,
-        'error in plugin',
-        this.getName().brightRed.underline,
-        err
-      );
-    });
-
-    // when the worker exits - set its variable to undefined this knows it's stopped
-    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) {
-        Omegga.error(
-          '!>'.red,
-          'Error terminating worker for',
-          this.getName().brightRed.underline,
-          err
-        );
-      }
-      this.#worker = undefined;
-      this.emitStatus();
-    });
-  }
-
-  eventPassthrough(...args) {
-    // worker does not exist
-    if (!this.#worker) return;
-
-    try {
-      // post the message
-      this.#worker.postMessage({
-        action: 'brickadiaEvent',
-        args,
-      });
-    } catch (e) {
-      // make sure post message doesn't crash the entire app
-      Omegga.error('!>'.red, 'error sending to plugin', ...args, e);
-    }
-  }
-}
-
-module.exports = NodeVmPlugin;