omegga 1.2.8 → 1.3.0

package/dist/cli/plugin.js

@@ -1,736 +1,705 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.install = install;
-exports.update = update;
-exports.check = check;
-const logger_1 = __importDefault(require("../logger"));
-const softconfig_1 = __importDefault(require("../softconfig"));
-const config = __importStar(require("../config"));
-const plugin_1 = require("../omegga/plugin");
-const child_process_1 = require("child_process");
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const logger = require("../logger.js");
+const softconfig = require("../softconfig.js");
+const index = require("../config/index.js");
+const plugin = require("../omegga/plugin.js");
+const node_child_process = require("node:child_process");
 require("colors");
-const fs_1 = __importDefault(require("fs"));
-const hasbin_1 = __importDefault(require("hasbin"));
-const lodash_1 = require("lodash");
-const path_1 = __importDefault(require("path"));
-const prompts_1 = __importDefault(require("prompts"));
-const semver_1 = __importDefault(require("semver"));
-const simple_git_1 = __importStar(require("simple-git"));
-const util_1 = require("util");
-const exec = (0, util_1.promisify)(child_process_1.exec);
-const MAIN_BRANCHES = ['master', 'main'];
-// get the working directory for omegga
+const fs = require("node:fs");
+const hasbin = require("hasbin");
+const path = require("node:path");
+const prompts = require("prompts");
+const semver = require("semver");
+const simpleGit = require("simple-git");
+const node_util = require("node:util");
+const version = require("../version.js");
+const exec = node_util.promisify(node_child_process.exec);
+const MAIN_BRANCHES = ["master", "main"];
 function getWorkDir() {
-    // default working directory is the one specified in config
-    let workDir = config.store.get('defaultOmegga');
-    verboseLog('Using working directory', workDir.yellow);
-    // if there's a config in the current directory, use that one instead
-    if (config.find('.'))
-        workDir = '.';
-    const confFile = config.find(workDir);
-    return confFile
-        ? path_1.default.resolve(process.cwd(), path_1.default.dirname(confFile))
-        : undefined;
+  let workDir = index.store.get("defaultOmegga");
+  verboseLog("Using working directory", workDir.yellow);
+  if (index.find(".")) workDir = ".";
+  const confFile = index.find(workDir);
+  return confFile ? path.resolve(process.cwd(), path.dirname(confFile)) : void 0;
 }
-const PLUGIN_TYPES = ['safe', 'safe-ts', 'unsafe', 'rust', 'rpc'];
-// plugin url transformers
+const PLUGIN_TYPES = ["safe", "safe-ts", "unsafe", "rust", "rpc"];
 const transformers = [
-    {
-        // github transformer
-        pattern: /^gh:(?<owner>[^/]+)\/(?<repo>[^/]+)$/,
-        fn: ({ owner, repo }) => ({
-            type: 'short',
-            name: repo,
-            url: `https://github.com/${owner}/omegga-${repo}`,
-        }),
-    },
-    {
-        // gitlab transformer
-        pattern: /^gl:(?<owner>[^/]+)\/(?<repo>[^/]+)$/,
-        fn: ({ owner, repo }) => ({
-            type: 'short',
-            name: repo,
-            url: `https://gitlab.com/${owner}/omegga-${repo}`,
-        }),
-    },
+  {
+    // github transformer
+    pattern: /^gh:(?<owner>[^/]+)\/(?<repo>[^/]+)$/,
+    fn: ({ owner, repo }) => ({
+      type: "short",
+      name: repo,
+      url: `https://github.com/${owner}/omegga-${repo}`
+    })
+  },
+  {
+    // gitlab transformer
+    pattern: /^gl:(?<owner>[^/]+)\/(?<repo>[^/]+)$/,
+    fn: ({ owner, repo }) => ({
+      type: "short",
+      name: repo,
+      url: `https://gitlab.com/${owner}/omegga-${repo}`
+    })
+  }
 ];
-// convert a shortened url into a full length one
 const transformUrl = (url) => {
-    const found = transformers.find(t => url.match(t.pattern));
-    if (!found)
-        return { type: 'raw', url };
-    return found.fn(url.match(found.pattern).groups);
+  const found = transformers.find((t) => url.match(t.pattern));
+  if (!found) return { type: "raw", url };
+  return found.fn(url.match(found.pattern).groups);
 };
 let needsNL = false;
-// rewrite a console line
 const rewriteLine = (...args) => {
-    process.stdout.clearLine(0);
-    process.stdout.cursorTo(0);
-    process.stdout.write(args.join(' '));
-    needsNL = true;
+  process.stdout.clearLine(0);
+  process.stdout.cursorTo(0);
+  process.stdout.write(args.join(" "));
+  needsNL = true;
 };
-// logging helper functions
-const plg = (plugin, ...args) => {
-    if (needsNL) {
-        needsNL = false;
-        console.log();
-    }
-    console.log(plugin.name, '>>'.green, ...args);
+const plg = (plugin2, ...args) => {
+  if (needsNL) {
+    needsNL = false;
+    console.log();
+  }
+  console.log(plugin2.name, ">>".green, ...args);
 };
-const plgLog = (plugin, ...args) => {
-    if (logger_1.default.VERBOSE)
-        plg(plugin, ...args);
-    else
-        rewriteLine(plugin.name, '>>'.green, ...args);
+const plgLog = (plugin2, ...args) => {
+  if (logger.default.VERBOSE) plg(plugin2, ...args);
+  else rewriteLine(plugin2.name, ">>".green, ...args);
 };
-const plgWarn = (plugin, ...args) => {
-    if (needsNL) {
-        needsNL = false;
-        console.warn();
-    }
-    console.warn(plugin.name, 'W>'.yellow, ...args);
+const plgWarn = (plugin2, ...args) => {
+  if (needsNL) {
+    needsNL = false;
+    console.warn();
+  }
+  console.warn(plugin2.name, "W>".yellow, ...args);
 };
-const plgErr = (plugin, ...args) => {
-    if (needsNL) {
-        needsNL = false;
-        console.error();
-    }
-    console.error(plugin.name, '!>'.red, ...args);
+const plgErr = (plugin2, ...args) => {
+  if (needsNL) {
+    needsNL = false;
+    console.error();
+  }
+  console.error(plugin2.name, "!>".red, ...args);
 };
 const err = (...args) => {
-    if (needsNL) {
-        needsNL = false;
-        console.error();
-    }
-    console.error('!>'.red, ...args);
+  if (needsNL) {
+    needsNL = false;
+    console.error();
+  }
+  console.error("!>".red, ...args);
 };
 const log = (...args) => {
-    if (needsNL) {
-        needsNL = false;
-        console.log();
-    }
-    console.log('>>'.green, ...args);
+  if (needsNL) {
+    needsNL = false;
+    console.log();
+  }
+  console.log(">>".green, ...args);
 };
 const verboseLog = (...args) => {
-    if (!logger_1.default.VERBOSE)
-        return;
-    if (needsNL) {
-        needsNL = false;
-        console.log();
-    }
-    console.log('V>'.magenta, ...args);
+  if (!logger.default.VERBOSE) return;
+  if (needsNL) {
+    needsNL = false;
+    console.log();
+  }
+  console.log("V>".magenta, ...args);
 };
-function checkPlugin(omeggaPath, plugin) {
-    const pluginPath = path_1.default.join(omeggaPath, softconfig_1.default.PLUGIN_PATH, plugin.name);
-    // check for the plugin file, whatever it's called
-    if (fs_1.default.existsSync(path_1.default.join(pluginPath, softconfig_1.default.PLUGIN_FILE))) {
-        if (needsNL) {
-            console.log();
-            needsNL = false;
-        }
-        plgLog(plugin, 'Checking plugin file...');
-        let data;
-        try {
-            data = JSON.parse(fs_1.default.readFileSync(path_1.default.join(pluginPath, softconfig_1.default.PLUGIN_FILE), 'utf8'));
-        }
-        catch (e) {
-            plgErr(plugin, 'Error reading plugin file', e);
-            return false;
-        }
-        // make sure this plugin version is okay.
-        // in the future, this may include deprecation warnings and format changes
-        if (data.formatVersion !== 1) {
-            plgWarn(plugin, 'WARNING - Plugin file has invalid', 'formatVersion'.yellow + '. Expected', '1'.yellow);
-            return;
-        }
-        // check the omeggaVersion field of the plugin file
-        if (!data.omeggaVersion || !semver_1.default.validRange(data.omeggaVersion)) {
-            plgWarn(plugin, 'WARNING - Plugin file has invalid', 'omeggaVersion'.yellow + '. Expected semver expression');
-            return false;
-        }
-        else if (!semver_1.default.satisfies(lodash_1.VERSION, data.omeggaVersion)) {
-            plgWarn(plugin, `WARNING - Plugin is not made for this version of omegga (${lodash_1.VERSION.yellow} vs ${data.omeggaVersion.yellow})`);
-            return false;
-        }
-        plgLog(plugin, 'Plugin file', 'OK'.green);
-        return true;
-    }
-    // no plugin file, no problem!
-    plgWarn(plugin, `WARNING - Plugin is missing plugin file (${softconfig_1.default.PLUGIN_FILE}), this may be a problem in future versions`);
+function checkPlugin(omeggaPath, plugin2) {
+  const pluginPath = path.join(omeggaPath, softconfig.default.PLUGIN_PATH, plugin2.name);
+  if (fs.existsSync(path.join(pluginPath, softconfig.default.PLUGIN_FILE))) {
+    if (needsNL) {
+      console.log();
+      needsNL = false;
+    }
+    plgLog(plugin2, "Checking plugin file...");
+    let data;
+    try {
+      data = JSON.parse(
+        fs.readFileSync(path.join(pluginPath, softconfig.default.PLUGIN_FILE), "utf8")
+      );
+    } catch (e) {
+      plgErr(plugin2, "Error reading plugin file", e);
+      return false;
+    }
+    if (data.formatVersion !== 1) {
+      plgWarn(
+        plugin2,
+        "WARNING - Plugin file has invalid",
+        "formatVersion".yellow + ". Expected",
+        "1".yellow
+      );
+      return;
+    }
+    if (!data.omeggaVersion || !semver.validRange(data.omeggaVersion)) {
+      plgWarn(
+        plugin2,
+        "WARNING - Plugin file has invalid",
+        "omeggaVersion".yellow + ". Expected semver expression"
+      );
+      return false;
+    } else if (!semver.satisfies(version.VERSION, data.omeggaVersion)) {
+      plgWarn(
+        plugin2,
+        `WARNING - Plugin is not made for this version of omegga (${version.VERSION.yellow} vs ${data.omeggaVersion.yellow})`
+      );
+      return false;
+    }
+    plgLog(plugin2, "Plugin file", "OK".green);
     return true;
+  }
+  plgWarn(
+    plugin2,
+    `WARNING - Plugin is missing plugin file (${softconfig.default.PLUGIN_FILE}), this may be a problem in future versions`
+  );
+  return true;
 }
-// install plugins from a list of plugins
 async function install(plugins, _options) {
-    const omeggaPath = getWorkDir();
-    if (!omeggaPath)
-        return err('Not an omegga directory, run ', 'omegga init'.yellow, 'to setup one.');
-    log('Attempting to install', (plugins.length + '').yellow, 'plugins...');
-    for (const pluginUrl of plugins) {
-        const plugin = transformUrl(pluginUrl);
-        // if the plugin wasn't transformed, try to extract its name from the git url
-        if (!('name' in plugin)) {
-            try {
-                const { name } = path_1.default.parse(plugin.url);
-                plugin.name = name.replace(/^omegga-/, '');
-            }
-            catch (e) {
-                console.error('!>'.red, 'Error parsing name from url', plugin.url);
-                break;
-            }
-        }
-        log('Installing plugin', plugin.name.yellow, 'from', plugin.url.yellow + '...');
-        // plugin absolute path
-        const pluginPath = path_1.default.join(omeggaPath, softconfig_1.default.PLUGIN_PATH, plugin.name);
-        // check if plugin already exists
-        // TODO: if force is passed in, remove the old directory
-        if (fs_1.default.existsSync(pluginPath) &&
-            fs_1.default.existsSync(path_1.default.join(pluginPath, 'doc.json'))) {
-            plgErr(plugin, 'Directory already exists! Try', ('omegga update ' + plugin.name).yellow, 'or check for plugin name collisions');
-            continue;
-        }
-        if (!fs_1.default.existsSync(pluginPath)) {
-            // create plugin local directory
-            try {
-                fs_1.default.mkdirSync(pluginPath, { recursive: true });
-            }
-            catch (e) {
-                plgErr(plugin, 'Error creating plugin directory', e);
-            }
-        }
-        // clone the plugin from git
-        try {
-            plgLog(plugin, 'Cloning...');
-            const git = (0, simple_git_1.default)(pluginPath);
-            await git.clone(plugin.url, pluginPath);
-        }
-        catch (e) {
-            plgErr(plugin, 'Error cloning plugin', e);
-        }
-        // check for the plugin file for issues
-        // TODO: if force is passed in, ignore the plugin check
-        if (!checkPlugin(omeggaPath, plugin))
-            continue;
-        const postInstallPath = path_1.default.join(pluginPath, softconfig_1.default.PLUGIN_POSTINSTALL);
-        if (fs_1.default.existsSync(postInstallPath)) {
-            plgLog(plugin, 'Running post install script...');
-            try {
-                verboseLog('Changing permission of', postInstallPath);
-                fs_1.default.chmodSync(postInstallPath, '0755');
-                verboseLog('Executing bash file');
-                let { stdout, stderr } = await exec(postInstallPath, {
-                    cwd: pluginPath,
-                    shell: 'bash',
-                });
-                if (stderr.length)
-                    plgErr(plugin, stderr);
-                verboseLog(stdout);
-            }
-            catch (e) {
-                plgErr(plugin, 'Error running post install script:', e);
-            }
-        }
-    }
+  const omeggaPath = getWorkDir();
+  if (!omeggaPath)
+    return err(
+      "Not an omegga directory, run ",
+      "omegga init".yellow,
+      "to setup one."
+    );
+  log("Attempting to install", (plugins.length + "").yellow, "plugins...");
+  for (const pluginUrl of plugins) {
+    const plugin2 = transformUrl(pluginUrl);
+    if (!("name" in plugin2)) {
+      try {
+        const { name } = path.parse(plugin2.url);
+        plugin2.name = name.replace(/^omegga-/, "");
+      } catch (e) {
+        console.error("!>".red, "Error parsing name from url", plugin2.url);
+        break;
+      }
+    }
+    log(
+      "Installing plugin",
+      plugin2.name.yellow,
+      "from",
+      plugin2.url.yellow + "..."
+    );
+    const pluginPath = path.join(omeggaPath, softconfig.default.PLUGIN_PATH, plugin2.name);
+    if (fs.existsSync(pluginPath) && fs.existsSync(path.join(pluginPath, "doc.json"))) {
+      plgErr(
+        plugin2,
+        "Directory already exists! Try",
+        ("omegga update " + plugin2.name).yellow,
+        "or check for plugin name collisions"
+      );
+      continue;
+    }
+    if (!fs.existsSync(pluginPath)) {
+      try {
+        fs.mkdirSync(pluginPath, { recursive: true });
+      } catch (e) {
+        plgErr(plugin2, "Error creating plugin directory", e);
+      }
+    }
+    try {
+      plgLog(plugin2, "Cloning...");
+      const git = simpleGit(pluginPath);
+      await git.clone(plugin2.url, pluginPath);
+    } catch (e) {
+      plgErr(plugin2, "Error cloning plugin", e);
+    }
+    if (!checkPlugin(omeggaPath, plugin2)) continue;
+    const postInstallPath = path.join(pluginPath, softconfig.default.PLUGIN_POSTINSTALL);
+    if (fs.existsSync(postInstallPath)) {
+      plgLog(plugin2, "Running post install script...");
+      try {
+        verboseLog("Changing permission of", postInstallPath);
+        fs.chmodSync(postInstallPath, "0755");
+        verboseLog("Executing bash file");
+        let { stdout, stderr } = await exec(postInstallPath, {
+          cwd: pluginPath,
+          shell: "bash"
+        });
+        if (stderr.length) plgErr(plugin2, stderr);
+        verboseLog(stdout);
+      } catch (e) {
+        plgErr(plugin2, "Error running post install script:", e);
+      }
+    }
+  }
 }
 async function update(pluginsNames, _options) {
-    var _a, _b;
-    const omeggaPath = getWorkDir();
-    if (!omeggaPath)
-        return err('Not an omegga directory, run ', 'omegga init'.yellow, 'to setup one.');
-    const pluginFolder = path_1.default.join(omeggaPath, softconfig_1.default.PLUGIN_PATH);
-    // if no plugins are passed in, use every plugin in the plugins folder
-    if (pluginsNames.length === 0) {
-        pluginsNames = fs_1.default.readdirSync(pluginFolder);
-    }
-    const plugins = pluginsNames
-        .map(dir => path_1.default.join(pluginFolder, dir))
-        // every plugin must be in a directory
-        .filter(dir => fs_1.default.existsSync(dir) &&
-        fs_1.default.lstatSync(dir).isDirectory() &&
-        fs_1.default.existsSync(path_1.default.join(dir, '.git')))
-        .map(dir => ({ name: path_1.default.basename(dir) }));
-    if (plugins.length === 0) {
-        log('Found no plugins that can be updated');
-        return;
-    }
-    log('Checking', (plugins.length + '').yellow, 'plugins for updates...');
-    // list of plugins that will be updated
-    let pluginsToUpdate = [];
-    for (const plugin of plugins) {
-        if (needsNL) {
-            console.log();
-            needsNL = false;
-        }
-        plgLog(plugin, 'Checking...');
-        const pluginPath = path_1.default.join(pluginFolder, plugin.name);
-        plugin.path = pluginPath;
-        const git = (0, simple_git_1.default)(pluginPath);
-        plugin.git = git;
-        if (!(await git.checkIsRepo())) {
-            plgErr(plugin, 'No git repo detected');
-            continue;
-        }
-        let status;
-        // get git status
-        try {
-            status = await git.status();
-        }
-        catch (e) {
-            plgErr(plugin, 'Error getting status', e);
-        }
-        try {
-            // check for uncommitted changes
-            if (status.files.some(f => f.working_dir !== '?')) {
-                plgErr(plugin, 'Detected uncommitted changes - ignoring');
-                continue;
-            }
-            const remotes = await git.getRemotes();
-            const branches = await git.branch();
-            // check if we're on a weird branch
-            if (!MAIN_BRANCHES.includes(branches.current)) {
-                plgErr(plugin, 'Not on a main branch - ignoring');
-                continue;
-            }
-            // try to correct a weird detached branch
-            if (remotes.length === 1 &&
-                remotes[0].name === 'origin' &&
-                !status.tracking) {
-                let skip = false;
-                for (const branch of MAIN_BRANCHES) {
-                    if (branches.current === branch &&
-                        branches.branches[`remotes/origin/${branch}`]) {
-                        plgLog(plugin, 'Correcting upstream...');
-                        try {
-                            await git.branch({ '--set-upstream-to': `origin/${branch}` });
-                            status = await git.status();
-                            break;
-                        }
-                        catch (e) {
-                            plgErr(plugin, 'Error getting status/fixing upstream branch', e);
-                            skip = true;
-                            break;
-                        }
-                    }
-                }
-                if (skip)
-                    continue;
-            }
-            // this should be corrected by the above check, though if it's not I am not fighting git lol
-            if (!status.tracking) {
-                plgErr(plugin, 'No upstream branch - ignoring');
-                continue;
-            }
-            // local developers, publish your code please!!! :)
-            if (remotes.length === 0) {
-                plgErr(plugin, 'No remotes - ignoring');
-                continue;
-            }
+  const omeggaPath = getWorkDir();
+  if (!omeggaPath)
+    return err(
+      "Not an omegga directory, run ",
+      "omegga init".yellow,
+      "to setup one."
+    );
+  const pluginFolder = path.join(omeggaPath, softconfig.default.PLUGIN_PATH);
+  if (pluginsNames.length === 0) {
+    pluginsNames = fs.readdirSync(pluginFolder);
+  }
+  const plugins = pluginsNames.map((dir) => path.join(pluginFolder, dir)).filter(
+    (dir) => fs.existsSync(dir) && fs.lstatSync(dir).isDirectory() && fs.existsSync(path.join(dir, ".git"))
+  ).map((dir) => ({ name: path.basename(dir) }));
+  if (plugins.length === 0) {
+    log("Found no plugins that can be updated");
+    return;
+  }
+  log("Checking", (plugins.length + "").yellow, "plugins for updates...");
+  let pluginsToUpdate = [];
+  for (const plugin2 of plugins) {
+    if (needsNL) {
+      console.log();
+      needsNL = false;
+    }
+    plgLog(plugin2, "Checking...");
+    const pluginPath = path.join(pluginFolder, plugin2.name);
+    plugin2.path = pluginPath;
+    const git = simpleGit(pluginPath);
+    plugin2.git = git;
+    if (!await git.checkIsRepo()) {
+      plgErr(plugin2, "No git repo detected");
+      continue;
+    }
+    let status;
+    try {
+      status = await git.status();
+    } catch (e) {
+      plgErr(plugin2, "Error getting status", e);
+    }
+    try {
+      if (status.files.some((f) => f.working_dir !== "?")) {
+        plgErr(plugin2, "Detected uncommitted changes - ignoring");
+        continue;
+      }
+      const remotes = await git.getRemotes();
+      const branches = await git.branch();
+      if (!MAIN_BRANCHES.includes(branches.current)) {
+        plgErr(plugin2, "Not on a main branch - ignoring");
+        continue;
+      }
+      if (remotes.length === 1 && remotes[0].name === "origin" && !status.tracking) {
+        let skip = false;
+        for (const branch of MAIN_BRANCHES) {
+          if (branches.current === branch && branches.branches[`remotes/origin/${branch}`]) {
+            plgLog(plugin2, "Correcting upstream...");
             try {
-                plgLog(plugin, 'Fetching...');
-                await git.fetch();
-                status = await git.status();
+              await git.branch({ "--set-upstream-to": `origin/${branch}` });
+              status = await git.status();
+              break;
+            } catch (e) {
+              plgErr(plugin2, "Error getting status/fixing upstream branch", e);
+              skip = true;
+              break;
             }
-            catch (e) {
-                plgErr(plugin, 'Error fetching remote code', e);
-                continue;
-            }
-            if (status.ahead > 0) {
-                plgErr(plugin, 'Detected plugin is ahead - ignoring');
-                continue;
-            }
-            if (status.behind === 0) {
-                plgLog(plugin, 'Already up-to-date!'.green);
-                continue;
-            }
-            plgLog(plugin, 'Update available');
-            pluginsToUpdate.push(plugin);
-        }
-        catch (e) {
-            plgErr(plugin, 'Error', e);
+          }
         }
-    }
-    if (pluginsToUpdate.length === 0) {
-        log('All plugins are currently up-to-date');
-        return;
-    }
-    log('Updating', (pluginsToUpdate.length + '').yellow, 'plugins...');
-    let updates = 0;
-    for (const plugin of pluginsToUpdate) {
-        const { git } = plugin;
-        if (needsNL) {
-            console.log();
-            needsNL = false;
-        }
-        plgLog(plugin, 'Creating backup branch...');
+        if (skip) continue;
+      }
+      if (!status.tracking) {
+        plgErr(plugin2, "No upstream branch - ignoring");
+        continue;
+      }
+      if (remotes.length === 0) {
+        plgErr(plugin2, "No remotes - ignoring");
+        continue;
+      }
+      try {
+        plgLog(plugin2, "Fetching...");
+        await git.fetch();
+        status = await git.status();
+      } catch (e) {
+        plgErr(plugin2, "Error fetching remote code", e);
+        continue;
+      }
+      if (status.ahead > 0) {
+        plgErr(plugin2, "Detected plugin is ahead - ignoring");
+        continue;
+      }
+      if (status.behind === 0) {
+        plgLog(plugin2, "Already up-to-date!".green);
+        continue;
+      }
+      plgLog(plugin2, "Update available");
+      pluginsToUpdate.push(plugin2);
+    } catch (e) {
+      plgErr(plugin2, "Error", e);
+    }
+  }
+  if (pluginsToUpdate.length === 0) {
+    log("All plugins are currently up-to-date");
+    return;
+  }
+  log("Updating", (pluginsToUpdate.length + "").yellow, "plugins...");
+  let updates = 0;
+  for (const plugin2 of pluginsToUpdate) {
+    const { git } = plugin2;
+    if (needsNL) {
+      console.log();
+      needsNL = false;
+    }
+    plgLog(plugin2, "Creating backup branch...");
+    try {
+      const branches = await git.branch();
+      const mainBranch = MAIN_BRANCHES.find((b) => branches.branches[b]) ?? MAIN_BRANCHES[0];
+      if (branches.branches["omegga-upgrade-backup"]) {
+        plgLog(plugin2, "Deleting leftover backup branch...");
+        await git.deleteLocalBranch("omegga-upgrade-backup", true);
+      }
+      await git.checkoutBranch("omegga-upgrade-backup", mainBranch);
+      await git.branch({ "--set-upstream-to": `origin/${mainBranch}` });
+      await git.checkout(mainBranch);
+      plgLog(plugin2, "Pulling update...");
+      await git.pull();
+      if ((await git.status()).behind > 0) {
+        throw "- still behind?";
+      }
+      plgLog(plugin2, "Checking plugin versions...");
+      if (!checkPlugin(omeggaPath, plugin2)) {
+        throw "Incompatible";
+      }
+      const postInstallPath = path.join(plugin2.path, softconfig.default.PLUGIN_POSTINSTALL);
+      if (fs.existsSync(postInstallPath)) {
+        plgLog(plugin2, "Running post install script...");
         try {
-            const branches = await git.branch();
-            const mainBranch = (_a = MAIN_BRANCHES.find(b => branches.branches[b])) !== null && _a !== void 0 ? _a : MAIN_BRANCHES[0];
-            if (branches.branches['omegga-upgrade-backup']) {
-                plgLog(plugin, 'Deleting leftover backup branch...');
-                await git.deleteLocalBranch('omegga-upgrade-backup', true);
-            }
-            await git.checkoutBranch('omegga-upgrade-backup', mainBranch);
-            await git.branch({ '--set-upstream-to': `origin/${mainBranch}` });
-            await git.checkout(mainBranch);
-            plgLog(plugin, 'Pulling update...');
-            await git.pull();
-            if ((await git.status()).behind > 0) {
-                throw '- still behind?';
-            }
-            plgLog(plugin, 'Checking plugin versions...');
-            if (!checkPlugin(omeggaPath, plugin)) {
-                throw 'Incompatible';
-            }
-            const postInstallPath = path_1.default.join(plugin.path, softconfig_1.default.PLUGIN_POSTINSTALL);
-            if (fs_1.default.existsSync(postInstallPath)) {
-                plgLog(plugin, 'Running post install script...');
-                try {
-                    fs_1.default.chmodSync(postInstallPath, '0755');
-                    let { stdout, stderr } = await exec(postInstallPath, {
-                        cwd: plugin.path,
-                        shell: 'bash',
-                    });
-                    if (stderr.length)
-                        plgErr(plugin, stderr);
-                    verboseLog(stdout);
-                }
-                catch (e) {
-                    plgErr(plugin, 'Error running post install script:', e);
-                }
-            }
-            plgLog(plugin, 'Updated!'.green);
-            updates++;
+          fs.chmodSync(postInstallPath, "0755");
+          let { stdout, stderr } = await exec(postInstallPath, {
+            cwd: plugin2.path,
+            shell: "bash"
+          });
+          if (stderr.length) plgErr(plugin2, stderr);
+          verboseLog(stdout);
+        } catch (e) {
+          plgErr(plugin2, "Error running post install script:", e);
         }
-        catch (e) {
-            plgErr(plugin, 'Error updating - attempting to restore from backup branch', e);
-            try {
-                const branches = await git.branch();
-                if (!MAIN_BRANCHES.includes(branches.current)) {
-                    plgErr(plugin, 'Not on expected branch - exiting before I break more things');
-                    continue;
-                }
-                const mainBranch = (_b = MAIN_BRANCHES.find(b => branches.branches[b])) !== null && _b !== void 0 ? _b : MAIN_BRANCHES[0];
-                plg(plugin, 'Resetting current branch');
-                await git.reset(simple_git_1.ResetMode.HARD);
-                plgLog(plugin, 'Attempting to checkout backup branch');
-                await git.checkout('omegga-upgrade-backup');
-                plgLog(plugin, `Replacing ${mainBranch} with backup`);
-                await git.deleteLocalBranch(mainBranch);
-                await git.checkoutBranch(mainBranch, 'omegga-upgrade-backup');
-                plgLog(plugin, 'Restored to backup branch');
-                if ((await git.branch()).current !== mainBranch) {
-                    plgErr(plugin, `Failed to checkout newly created ${mainBranch} branch`);
-                    continue;
-                }
-                else {
-                    plgWarn(plugin, 'Restored from backup and plugin not updated...');
-                }
-            }
-            catch (e) {
-                plgErr(plugin, 'Error restoring from backup... Whelp...');
-            }
-            continue;
+      }
+      plgLog(plugin2, "Updated!".green);
+      updates++;
+    } catch (e) {
+      plgErr(
+        plugin2,
+        "Error updating - attempting to restore from backup branch",
+        e
+      );
+      try {
+        const branches = await git.branch();
+        if (!MAIN_BRANCHES.includes(branches.current)) {
+          plgErr(
+            plugin2,
+            "Not on expected branch - exiting before I break more things"
+          );
+          continue;
+        }
+        const mainBranch = MAIN_BRANCHES.find((b) => branches.branches[b]) ?? MAIN_BRANCHES[0];
+        plg(plugin2, "Resetting current branch");
+        await git.reset(simpleGit.ResetMode.HARD);
+        plgLog(plugin2, "Attempting to checkout backup branch");
+        await git.checkout("omegga-upgrade-backup");
+        plgLog(plugin2, `Replacing ${mainBranch} with backup`);
+        await git.deleteLocalBranch(mainBranch);
+        await git.checkoutBranch(mainBranch, "omegga-upgrade-backup");
+        plgLog(plugin2, "Restored to backup branch");
+        if ((await git.branch()).current !== mainBranch) {
+          plgErr(
+            plugin2,
+            `Failed to checkout newly created ${mainBranch} branch`
+          );
+          continue;
+        } else {
+          plgWarn(plugin2, "Restored from backup and plugin not updated...");
         }
+      } catch (e2) {
+        plgErr(plugin2, "Error restoring from backup... Whelp...");
+      }
+      continue;
     }
-    log('Updated', (updates + '').yellow, 'plugins!');
+  }
+  log("Updated", (updates + "").yellow, "plugins!");
 }
 async function check(pluginNames, _options) {
-    const omeggaPath = getWorkDir();
-    if (!omeggaPath)
-        return err('Not an omegga directory, run ', 'omegga init'.yellow, 'to setup one.');
-    const pluginFolder = path_1.default.join(omeggaPath, softconfig_1.default.PLUGIN_PATH);
-    // if no plugins are passed in, use every plugin in the plugins folder
-    if (pluginNames.length === 0) {
-        pluginNames = fs_1.default.readdirSync(pluginFolder);
-    }
-    const plugins = pluginNames
-        .map(dir => path_1.default.join(pluginFolder, dir))
-        // every plugin must be in a directory
-        .filter(dir => fs_1.default.existsSync(dir) &&
-        fs_1.default.lstatSync(dir).isDirectory() &&
-        fs_1.default.existsSync(path_1.default.join(dir, '.git')))
-        .map(dir => ({ name: path_1.default.basename(dir) }));
-    if (plugins.length === 0) {
-        log('Found no plugins that can be checked');
-        return;
-    }
-    log('Checking', (plugins.length + '').yellow, 'plugins for valid plugin files');
-    for (const plugin of plugins) {
-        const pluginPath = path_1.default.join(pluginFolder, plugin.name);
-        plugin.path = pluginPath;
-        const git = (0, simple_git_1.default)(pluginPath);
-        plugin.git = git;
-        if (!(await git.checkIsRepo())) {
-            plgErr(plugin, 'No git repo detected');
-            continue;
-        }
-        checkPlugin(omeggaPath, plugin);
-    }
-    console.log();
+  const omeggaPath = getWorkDir();
+  if (!omeggaPath)
+    return err(
+      "Not an omegga directory, run ",
+      "omegga init".yellow,
+      "to setup one."
+    );
+  const pluginFolder = path.join(omeggaPath, softconfig.default.PLUGIN_PATH);
+  if (pluginNames.length === 0) {
+    pluginNames = fs.readdirSync(pluginFolder);
+  }
+  const plugins = pluginNames.map((dir) => path.join(pluginFolder, dir)).filter(
+    (dir) => fs.existsSync(dir) && fs.lstatSync(dir).isDirectory() && fs.existsSync(path.join(dir, ".git"))
+  ).map((dir) => ({ name: path.basename(dir) }));
+  if (plugins.length === 0) {
+    log("Found no plugins that can be checked");
+    return;
+  }
+  log(
+    "Checking",
+    (plugins.length + "").yellow,
+    "plugins for valid plugin files"
+  );
+  for (const plugin2 of plugins) {
+    const pluginPath = path.join(pluginFolder, plugin2.name);
+    plugin2.path = pluginPath;
+    const git = simpleGit(pluginPath);
+    plugin2.git = git;
+    if (!await git.checkIsRepo()) {
+      plgErr(plugin2, "No git repo detected");
+      continue;
+    }
+    checkPlugin(omeggaPath, plugin2);
+  }
+  console.log();
 }
-const EXECUTABLES = ['setup.sh', 'omegga_plugin'];
+const EXECUTABLES = ["setup.sh", "omegga_plugin"];
 async function init() {
-    const { author, ...response } = await (0, prompts_1.default)([
-        {
-            type: 'text',
-            name: 'name',
-            message: 'What would you like to ' + 'name'.yellow + ' your plugin?',
-            validate: value => value.match(/^[\w-_]+$/) ? true : 'Invalid plugin name!',
-        },
-        {
-            type: 'select',
-            name: 'type',
-            message: 'What ' + 'type'.yellow + ' of plugin would you like to initialize?',
-            choices: [
-                { title: 'safe ' + '(default)'.italic, value: 'safe' },
-                { title: 'unsafe', value: 'unsafe' },
-                { title: 'rust', value: 'rust' },
-                { title: 'rpc', value: 'rpc' },
-            ],
-        },
-        {
-            type: prev => (prev == 'safe' ? 'confirm' : null),
-            name: 'ts',
-            message: 'Would you like to use ' + 'TypeScript'.yellow + ' in your plugin?',
-            initial: false,
-        },
-        {
-            type: 'text',
-            name: 'author',
-            message: 'Who is the ' + 'author'.yellow + ' of this plugin?',
-        },
-    ]);
-    const name = response.name;
-    const type = response.type == 'safe' && response.ts ? 'safe-ts' : response.type;
-    if (!PLUGIN_TYPES.includes(type)) {
-        err('Invalid plugin type', type.red, '!');
-        process.exit(1);
-    }
-    let dest;
-    if (!config.find('.')) {
-        log('Warning:'.yellow, 'This is not an omegga installation, initializing here instead...');
-        dest = `./${name}`;
-    }
-    else {
-        dest = `./plugins/${name}`;
-        if (!fs_1.default.existsSync('./plugins'))
-            fs_1.default.mkdirSync('./plugins');
-    }
-    if (fs_1.default.existsSync(dest)) {
-        err('A directory already exists at the desired plugin location.');
-        process.exit(1);
-    }
-    log('Initializing new', type.yellow, 'plugin', name.cyan, '...');
-    const templateData = {
-        name,
-        author: author !== null && author !== void 0 ? author : 'AUTHOR',
-        omeggaVersion: lodash_1.VERSION,
-    };
-    const copyAndRender = async (src, dest) => {
-        const stats = fs_1.default.statSync(src);
-        // remove .rename suffix from files
-        dest = dest.replace(/\.rename$/, '');
-        if (stats.isDirectory()) {
-            await fs_1.default.promises.mkdir(dest);
-            const contents = await fs_1.default.promises.readdir(src);
-            for (const child of contents)
-                await copyAndRender(path_1.default.join(src, child), path_1.default.join(dest, child));
-        }
-        else {
-            // copy and render the file
-            const data = (await fs_1.default.promises.readFile(src)).toString();
-            const mode = EXECUTABLES.includes(path_1.default.basename(dest)) ? 0o755 : 0o644;
-            await fs_1.default.promises.writeFile(dest, data.replace(/{{(\w+)}}/g, (_, p) => { var _a; return (_a = templateData[p]) !== null && _a !== void 0 ? _a : `{{${p}}}`; }), { mode });
-        }
-    };
-    const src = path_1.default.join(__dirname, `../../templates/${type}`);
-    verboseLog('Copying and rendering template...');
-    await copyAndRender(src, dest);
-    if (hasbin_1.default.sync('git')) {
-        verboseLog('Running', 'git init'.yellow, 'in the new plugin directory ...');
-        await exec('git init', { cwd: dest });
-    }
-    if (fs_1.default.existsSync(path_1.default.join(src, 'package.json'))) {
-        verboseLog('Running', 'npm i'.yellow, 'in the new plugin directory ...');
-        try {
-            await exec('npm i', { cwd: dest });
-        }
-        catch (e) {
-            log('Warning: npm i'.yellow, 'failed to execute. Proceeding anyway...');
-        }
-    }
-    log('Initialized', type.yellow, 'plugin', `${name}`.cyan, 'successfully!');
+  const { author, ...response } = await prompts([
+    {
+      type: "text",
+      name: "name",
+      message: "What would you like to " + "name".yellow + " your plugin?",
+      validate: (value) => value.match(/^[\w-_]+$/) ? true : "Invalid plugin name!"
+    },
+    {
+      type: "select",
+      name: "type",
+      message: "What " + "type".yellow + " of plugin would you like to initialize?",
+      choices: [
+        { title: "safe " + "(default)".italic, value: "safe" },
+        { title: "unsafe", value: "unsafe" },
+        { title: "rust", value: "rust" },
+        { title: "rpc", value: "rpc" }
+      ]
+    },
+    {
+      type: (prev) => prev == "safe" ? "confirm" : null,
+      name: "ts",
+      message: "Would you like to use " + "TypeScript".yellow + " in your plugin?",
+      initial: false
+    },
+    {
+      type: "text",
+      name: "author",
+      message: "Who is the " + "author".yellow + " of this plugin?"
+    }
+  ]);
+  const name = response.name;
+  const type = response.type == "safe" && response.ts ? "safe-ts" : response.type;
+  if (!PLUGIN_TYPES.includes(type)) {
+    err("Invalid plugin type", type.red, "!");
+    process.exit(1);
+  }
+  let dest;
+  if (!index.find(".")) {
+    log(
+      "Warning:".yellow,
+      "This is not an omegga installation, initializing here instead..."
+    );
+    dest = `./${name}`;
+  } else {
+    dest = `./plugins/${name}`;
+    if (!fs.existsSync("./plugins")) fs.mkdirSync("./plugins");
+  }
+  if (fs.existsSync(dest)) {
+    err("A directory already exists at the desired plugin location.");
+    process.exit(1);
+  }
+  log("Initializing new", type.yellow, "plugin", name.cyan, "...");
+  const templateData = {
+    name,
+    author: author ?? "AUTHOR",
+    omeggaVersion: version.VERSION
+  };
+  const copyAndRender = async (src2, dest2) => {
+    const stats = fs.statSync(src2);
+    dest2 = dest2.replace(/\.rename$/, "");
+    if (stats.isDirectory()) {
+      await fs.promises.mkdir(dest2);
+      const contents = await fs.promises.readdir(src2);
+      for (const child of contents)
+        await copyAndRender(path.join(src2, child), path.join(dest2, child));
+    } else {
+      const data = (await fs.promises.readFile(src2)).toString();
+      const mode = EXECUTABLES.includes(path.basename(dest2)) ? 493 : 420;
+      await fs.promises.writeFile(
+        dest2,
+        data.replace(/{{(\w+)}}/g, (_, p) => templateData[p] ?? `{{${p}}}`),
+        { mode }
+      );
+    }
+  };
+  const src = path.join(__dirname, `../../templates/${type}`);
+  verboseLog("Copying and rendering template...");
+  await copyAndRender(src, dest);
+  if (hasbin.sync("git")) {
+    verboseLog("Running", "git init".yellow, "in the new plugin directory ...");
+    await exec("git init", { cwd: dest });
+  }
+  if (fs.existsSync(path.join(src, "package.json"))) {
+    verboseLog("Running", "npm i".yellow, "in the new plugin directory ...");
+    try {
+      await exec("npm i", { cwd: dest });
+    } catch (e) {
+      log("Warning: npm i".yellow, "failed to execute. Proceeding anyway...");
+    }
+  }
+  log("Initialized", type.yellow, "plugin", `${name}`.cyan, "successfully!");
 }
 function pluginLoaderFactory() {
-    const workDir = getWorkDir();
-    return new plugin_1.PluginLoader(workDir);
+  const workDir = getWorkDir();
+  return new plugin.PluginLoader(workDir);
 }
-/** Loads in a plugin and it's documentation. */
 async function loadPlugin(pluginName) {
-    const pluginLoader = pluginLoaderFactory();
-    const foundPluginDirectory = fs_1.default
-        .readdirSync(pluginLoader.path)
-        .find(dir => dir.toLowerCase() === pluginName.toLowerCase());
-    if (!foundPluginDirectory) {
-        err(`Plugin ${pluginName} not found! Make sure to use the plugin's directory name.`);
-        process.exit(1);
-    }
-    const plugin = await pluginLoader.scanPlugin(path_1.default.join(pluginLoader.path, foundPluginDirectory));
-    return plugin;
+  const pluginLoader = pluginLoaderFactory();
+  const foundPluginDirectory = fs.readdirSync(pluginLoader.path).find((dir) => dir.toLowerCase() === pluginName.toLowerCase());
+  if (!foundPluginDirectory) {
+    err(
+      `Plugin ${pluginName} not found! Make sure to use the plugin's directory name.`
+    );
+    process.exit(1);
+  }
+  const plugin2 = await pluginLoader.scanPlugin(
+    path.join(pluginLoader.path, foundPluginDirectory)
+  );
+  return plugin2;
 }
 async function listConfig(pluginName, json = false) {
-    const plugin = await loadPlugin(pluginName);
-    const configDoc = plugin.getDocumentation().config;
-    const config = await plugin.storage.getConfig();
-    if (json) {
-        console.log(JSON.stringify(config, null, 2));
-    }
-    else {
-        for (const key in config) {
-            if (!configDoc[key])
-                continue; // Skip unknown config keys.
-            const value = config[key];
-            log(key.cyan, '=', ['string', 'number', 'boolean'].includes(typeof value)
-                ? value.toString().yellow
-                : JSON.stringify(value).yellow);
-        }
-    }
-    process.exit();
+  const plugin2 = await loadPlugin(pluginName);
+  const configDoc = plugin2.getDocumentation().config;
+  const config2 = await plugin2.storage.getConfig();
+  if (json) {
+    console.log(JSON.stringify(config2, null, 2));
+  } else {
+    for (const key in config2) {
+      if (!configDoc[key]) continue;
+      const value = config2[key];
+      log(
+        key.cyan,
+        "=",
+        ["string", "number", "boolean"].includes(typeof value) ? value.toString().yellow : JSON.stringify(value).yellow
+      );
+    }
+  }
+  process.exit();
 }
 async function getConfig(pluginName, configName, json = false) {
-    const plugin = await loadPlugin(pluginName);
-    const configDoc = plugin.getDocumentation().config[configName];
-    if (configDoc === undefined) {
-        err('Config', configName.cyan, 'not found');
-        process.exit(1);
-    }
-    const config = await plugin.storage.getConfig();
-    if (json) {
-        console.log(JSON.stringify(config[configName], null, 2));
-    }
-    else {
-        log(config[configName]);
-    }
-    process.exit();
+  const plugin2 = await loadPlugin(pluginName);
+  const configDoc = plugin2.getDocumentation().config[configName];
+  if (configDoc === void 0) {
+    err("Config", configName.cyan, "not found");
+    process.exit(1);
+  }
+  const config2 = await plugin2.storage.getConfig();
+  if (json) {
+    console.log(JSON.stringify(config2[configName], null, 2));
+  } else {
+    log(config2[configName]);
+  }
+  process.exit();
 }
 async function setConfig(pluginName, configName, valueString) {
-    const plugin = await loadPlugin(pluginName);
-    const configDoc = plugin.getDocumentation().config[configName];
-    if (configDoc === undefined) {
-        err('Config', configName.cyan, 'not found');
+  const plugin2 = await loadPlugin(pluginName);
+  const configDoc = plugin2.getDocumentation().config[configName];
+  if (configDoc === void 0) {
+    err("Config", configName.cyan, "not found");
+    process.exit(1);
+  }
+  let parsed;
+  switch (configDoc.type) {
+    case "boolean":
+      parsed = valueString === "true";
+      break;
+    case "number":
+      parsed = Number(valueString);
+      if (isNaN(parsed)) {
+        err("Invalid number value", valueString.yellow);
         process.exit(1);
-    }
-    // Parse the value string into a value of the correct type for the config.
-    let parsed;
-    switch (configDoc.type) {
-        case 'boolean':
-            parsed = valueString === 'true';
-            break;
-        case 'number':
-            parsed = Number(valueString);
-            if (isNaN(parsed)) {
-                err('Invalid number value', valueString.yellow);
-                process.exit(1);
-            }
-            break;
-        case 'string':
-            parsed = valueString;
-            break;
-        case 'enum':
-            if (!configDoc.options.includes(valueString)) {
-                err('Config', configName.cyan, 'must be one of', configDoc.options.join(', ').yellow);
-                process.exit(1);
-            }
-            parsed = valueString;
-            break;
-        default:
-            err('set-context does not support config type', configDoc.type.cyan);
-            process.exit(1);
-    }
-    const pluginConfig = await plugin.storage.getConfig();
-    pluginConfig[configName] = parsed;
-    await plugin.storage.setConfig(pluginConfig);
-    log('Set config', configName.cyan, 'of plugin', plugin.getName().cyan, 'to', parsed.toString().yellow);
-    process.exit();
+      }
+      break;
+    case "string":
+      parsed = valueString;
+      break;
+    case "enum":
+      if (!configDoc.options.includes(valueString)) {
+        err(
+          "Config",
+          configName.cyan,
+          "must be one of",
+          configDoc.options.join(", ").yellow
+        );
+        process.exit(1);
+      }
+      parsed = valueString;
+      break;
+    default:
+      err("set-context does not support config type", configDoc.type.cyan);
+      process.exit(1);
+  }
+  const pluginConfig = await plugin2.storage.getConfig();
+  pluginConfig[configName] = parsed;
+  await plugin2.storage.setConfig(pluginConfig);
+  log(
+    "Set config",
+    configName.cyan,
+    "of plugin",
+    plugin2.getName().cyan,
+    "to",
+    parsed.toString().yellow
+  );
+  process.exit();
 }
 async function resetAllConfigs(pluginName, force) {
-    const plugin = await loadPlugin(pluginName);
-    if (!force) {
-        const { answer } = await (0, prompts_1.default)([
-            {
-                type: 'confirm',
-                name: 'answer',
-                message: 'Are you sure you want to reset all configs?',
-                initial: false,
-            },
-        ]);
-        if (!answer) {
-            log('Reset aborted.');
-            process.exit(1);
-        }
-    }
-    await plugin.storage.wipeConfig();
-    await plugin.storage.init();
-    log('Reset all configs of plugin', plugin.getName().cyan);
-    process.exit();
+  const plugin2 = await loadPlugin(pluginName);
+  if (!force) {
+    const { answer } = await prompts([
+      {
+        type: "confirm",
+        name: "answer",
+        message: "Are you sure you want to reset all configs?",
+        initial: false
+      }
+    ]);
+    if (!answer) {
+      log("Reset aborted.");
+      process.exit(1);
+    }
+  }
+  await plugin2.storage.wipeConfig();
+  await plugin2.storage.init();
+  log("Reset all configs of plugin", plugin2.getName().cyan);
+  process.exit();
 }
 async function resetConfig(pluginName, configName) {
-    const plugin = await loadPlugin(pluginName);
-    const configDoc = plugin.getDocumentation().config[configName];
-    if (configDoc === undefined) {
-        err('Config', configName.cyan, 'not found');
-        process.exit(1);
-    }
-    const pluginConfig = await plugin.storage.getConfig();
-    pluginConfig[configName] = plugin.storage.getDefaultConfig()[configName];
-    await plugin.storage.setConfig(pluginConfig);
-    log('Reset config', configName.cyan, 'of plugin', plugin.getName().cyan, 'to', pluginConfig[configName]);
-    process.exit();
+  const plugin2 = await loadPlugin(pluginName);
+  const configDoc = plugin2.getDocumentation().config[configName];
+  if (configDoc === void 0) {
+    err("Config", configName.cyan, "not found");
+    process.exit(1);
+  }
+  const pluginConfig = await plugin2.storage.getConfig();
+  pluginConfig[configName] = plugin2.storage.getDefaultConfig()[configName];
+  await plugin2.storage.setConfig(pluginConfig);
+  log(
+    "Reset config",
+    configName.cyan,
+    "of plugin",
+    plugin2.getName().cyan,
+    "to",
+    pluginConfig[configName]
+  );
+  process.exit();
 }
-exports.default = {
-    install,
-    update,
-    check,
-    init,
-    listConfig,
-    getConfig,
-    setConfig,
-    resetAllConfigs,
-    resetConfig,
+const _pluginUtil = {
+  install,
+  update,
+  check,
+  init,
+  listConfig,
+  getConfig,
+  setConfig,
+  resetAllConfigs,
+  resetConfig
 };
-//# sourceMappingURL=plugin.js.map
+exports.check = check;
+exports.default = _pluginUtil;
+exports.install = install;
+exports.update = update;
+//# sourceMappingURL=plugin.js.map