@runeya/runeya 1.33.24 → 1.33.26

package/www.js

@@ -202,20 +202,20 @@ var require_conflictStorage = __commonJS({
 var require_reencrypt_nodered = __commonJS({
   "helpers/reencrypt-nodered.js"(exports2, module2) {
     "use strict";
-    var crypto = require("crypto");
+    var crypto2 = require("crypto");
     var { readFile, writeFile } = require("fs/promises");
     var encryptionAlgorithm = "aes-256-ctr";
     module2.exports = async function decryptCreds(oldSecret, newScret, path) {
-      const oldKey = crypto.createHash("sha256").update(oldSecret).digest();
-      const newKey = crypto.createHash("sha256").update(newScret).digest();
+      const oldKey = crypto2.createHash("sha256").update(oldSecret).digest();
+      const newKey = crypto2.createHash("sha256").update(newScret).digest();
       const cipher = JSON.parse(await readFile(path, "utf-8"));
       let flows = cipher["$"];
       const vector = Buffer.from(flows.substring(0, 32), "hex");
       flows = flows.substring(32);
-      const decipher = crypto.createDecipheriv(encryptionAlgorithm, oldKey, vector);
+      const decipher = crypto2.createDecipheriv(encryptionAlgorithm, oldKey, vector);
       const decrypted = decipher.update(flows, "base64", "utf8") + decipher.final("utf8");
-      const newVector = crypto.randomBytes(16);
-      const newCipher = crypto.createCipheriv(encryptionAlgorithm, newKey, newVector);
+      const newVector = crypto2.randomBytes(16);
+      const newCipher = crypto2.createCipheriv(encryptionAlgorithm, newKey, newVector);
       const encrypted = newCipher.update(decrypted, "utf8", "base64") + newCipher.final("base64");
       await writeFile(path, JSON.stringify({
         "$": newVector.toString("hex") + encrypted
@@ -509,8 +509,8 @@ var require_routes3 = __commonJS({
           group: "Service",
           url: `/stack-single/${service.label}`
         }));
-        const { plugins } = runeya;
-        const _plugins = (await PromiseB2.map(Object.keys(plugins), (key) => plugins[key]).map(async (plugin) => [
+        const { plugins: plugins2 } = runeya;
+        const _plugins = (await PromiseB2.map(Object.keys(plugins2), (key) => plugins2[key]).map(async (plugin) => [
           ...await plugin?.finder?.(search, runeya)?.catch?.(() => []) || [],
           ...searchString(plugin.name, search) ? [{
             title: plugin.displayName || plugin.name,
@@ -2055,7 +2055,7 @@ var require_backend13 = __commonJS({
 var require_plugins = __commonJS({
   "../../modules/plugins-loader/backend/plugins.js"(exports2, module2) {
     "use strict";
-    var plugins = {
+    var plugins2 = {
       bugs: require_backend(),
       configuration: require_backend2(),
       documentation: require_backend3(),
@@ -2070,8 +2070,8 @@ var require_plugins = __commonJS({
       docker: require_backend12(),
       nodered: require_backend13()
     };
-    module2.exports = Object.keys(plugins).reduce((acc, key) => {
-      if (plugins[key].enabled) acc[key] = plugins[key];
+    module2.exports = Object.keys(plugins2).reduce((acc, key) => {
+      if (plugins2[key].enabled) acc[key] = plugins2[key];
       return acc;
     }, {});
   }
@@ -2339,7 +2339,10 @@ var require_Parser = __commonJS({
     var nativeParsers = {
       [require_debug().id]: require_debug(),
       [require_json().id]: require_json(),
-      [require_link().id]: require_link()
+      [require_link().id]: require_link(),
+      "stack-monitor-parser-debug": { ...require_debug(), id: "stack-monitor-parser-debug" },
+      "stack-monitor-parser-jsons": { ...require_json(), id: "stack-monitor-parser-jsons" },
+      "stack-monitor-parser-links": { ...require_link(), id: "stack-monitor-parser-links" }
     };
     var Parser = class _Parser {
       /**
@@ -3244,7 +3247,7 @@ var require_stack = __commonJS({
   "models/stack.js"(exports2, module2) {
     "use strict";
     var { sockets: sockets2 } = require_src();
-    var plugins = require_plugins();
+    var plugins2 = require_plugins();
     var PromiseB2 = require("bluebird");
     var Service = require_Service();
     var ports = require_ports();
@@ -3279,7 +3282,7 @@ var require_stack = __commonJS({
     Stack.currentWatches = [];
     Stack.currentEnvironment = null;
     Stack.Socket = sockets2;
-    Stack.plugins = plugins;
+    Stack.plugins = plugins2;
     Stack.version = require_version().version || "";
     Stack.url = `http://localhost:${ports.http}`;
     Stack.port = +ports.http;
@@ -3426,9 +3429,9 @@ var require_stack = __commonJS({
     };
     var pluginsToLoad = (
       /** @type {(keyof typeof plugins)[]} */
-      Object.keys(plugins).reduce(
+      Object.keys(plugins2).reduce(
         (p, key) => {
-          const plugin = plugins[key];
+          const plugin = plugins2[key];
           if (plugin.export) {
             p[key] = typeof plugin.export === "function" && !/^\s*class\s+/.test(plugin.export.toString()) ? plugin.export(
               /** @type {StackWithPlugins} */
@@ -3535,7 +3538,7 @@ var require_crypto = __commonJS({
   "helpers/crypto.js"(exports2, module2) {
     "use strict";
     var _sodium = require("libsodium-wrappers");
-    var crypto = require("crypto");
+    var crypto2 = require("crypto");
     var { sockets: sockets2 } = require_src();
     var conflictStorage = require_conflictStorage();
     var path = require("path");
@@ -3555,7 +3558,7 @@ var require_crypto = __commonJS({
       }
       let nonce;
       if (additionnalNonce) {
-        const combinedHash = crypto.createHash("blake2b512").update(data + additionnalNonce).digest();
+        const combinedHash = crypto2.createHash("blake2b512").update(data + additionnalNonce).digest();
         nonce = combinedHash.slice(0, sodium.crypto_secretbox_NONCEBYTES);
       } else {
         nonce = sodium.randombytes_buf(sodium.crypto_secretbox_NONCEBYTES);
@@ -3854,40 +3857,11 @@ var require_createDefaultFiles = __commonJS({
   }
 });
 
-// helpers/console.table.js
-var require_console_table = __commonJS({
-  "helpers/console.table.js"(exports2, module2) {
-    "use strict";
-    var { Transform } = require("stream");
-    var { Console } = require("console");
-    function table(input) {
-      const ts = new Transform({ transform(chunk, enc, cb) {
-        cb(null, chunk);
-      } });
-      const logger = new Console({ stdout: ts });
-      logger.table(input);
-      const table2 = (ts.read() || "").toString();
-      let result = "";
-      for (const row of table2.split(/[\r\n]+/)) {
-        let r = row.replace(/[^┬]*┬/, "\u250C");
-        r = r.replace(/^├─*┼/, "\u251C");
-        r = r.replace(/│[^│]*/, "");
-        r = r.replace(/^└─*┴/, "\u2514");
-        r = r.replace(/'/g, " ");
-        result += `${r}
-`;
-      }
-      console.log(result);
-    }
-    module2.exports = table;
-  }
-});
-
 // helpers/plugins.js
 var require_plugins2 = __commonJS({
   "helpers/plugins.js"(exports2, module2) {
     "use strict";
-    var plugins = require_plugins();
+    var plugins2 = require_plugins();
     var Stack = require_stack();
     var { default: axios } = require("axios");
     var { tmpdir } = require("os");
@@ -3900,9 +3874,24 @@ var require_plugins2 = __commonJS({
     var args2 = require_args();
     var tar = require("tar");
     var dbConfig = dbs2.getDb("plugins", { encrypted: false, defaultData: [] });
+    var dbPublicPlugins = dbs2.getDb("public-plugins", { encrypted: false, defaultData: [] });
     var { sockets: sockets2 } = require_src();
     var stack = require_stack();
     var debounce = require("debounce");
+    var PromiseB2 = require("bluebird");
+    var pluginsState = new Proxy({}, {
+      get(target, prop) {
+        return target[prop];
+      },
+      set(target, prop, value) {
+        sockets2.emit("plugins:loading:progress", {
+          ...value,
+          plugin: prop
+        });
+        target[prop] = value;
+        return true;
+      }
+    });
     var chokidar = null;
     if (process.env.NODE_ENV === "HFBXdZMJxLyJoua28asEaxRixJ6LriR7FnRzX6pwA7pFjZ") {
       chokidar = require("chokidar");
@@ -3912,7 +3901,7 @@ var require_plugins2 = __commonJS({
     var allPlugins = {};
     var loadedPlugins = {};
     var themes = {};
-    Object.keys(plugins).map((key) => plugins[
+    Object.keys(plugins2).map((key) => plugins2[
       /** @type {keyof (typeof plugins)} */
       key
     ]).forEach((plugin) => {
@@ -3936,38 +3925,41 @@ var require_plugins2 = __commonJS({
       });
       return plugin;
     });
-    async function install(remotePath, force = false) {
+    async function install(remotePath, force = false, insert = true, shouldLoadPlugin = true) {
       const rootPath = args2.rootPath;
       if (!existsSync(rootPath)) await mkdir(rootPath, { recursive: true });
-      const runeyaPath = path.resolve(rootPath, ".runeya");
-      if (!existsSync(runeyaPath)) await mkdir(runeyaPath, { recursive: true });
-      const pluginsPath = path.resolve(runeyaPath, "plugins");
+      const pluginsPath = path.resolve(args2.runeyaConfigPath, "plugins");
       if (!existsSync(pluginsPath)) await mkdir(pluginsPath, { recursive: true });
-      const packageTmpPath = path.resolve(tmpdir(), `runeya-plugin-${Date.now()}`);
+      const packageTmpPath = path.resolve(tmpdir(), `runeya-plugin-${crypto.randomUUID()}`);
       if (!existsSync(packageTmpPath)) await mkdir(packageTmpPath, { recursive: true });
       const packageTmpFilePath = `${packageTmpPath}.tar.gz`;
       const { data } = await axios.get(remotePath, { responseType: "arraybuffer" });
       await writeFile(packageTmpFilePath, data);
       await tar.extract({ file: packageTmpFilePath, cwd: packageTmpPath });
       const config = JSON.parse(await readFile(path.join(packageTmpPath, "package.json"), "utf8"));
+      pluginsState[config.name] = { step: "INSTALL_START" };
       const plugin = await getInstalledPlugin(config.name, config.version);
       console.log("Installing", config.name + "@" + config.version);
       if (plugin && !force) {
+        sockets2.emit("plugins:install:error", config.name, "Plugin already installed");
+        pluginsState[config.name] = void 0;
         throw new HTTPError("Plugin already installed", "400.68746854743512");
       }
-      await dbConfig.alasql.delete(`name='${config.name}'`);
+      if (insert) await dbConfig.alasql.delete(`name='${config.name}'`);
       const diskPath = path.resolve(pluginsPath, config.name);
       if (existsSync(diskPath)) await rm(diskPath, { recursive: true, force: true });
       await cp(path.resolve(packageTmpPath), diskPath, { recursive: true });
-      await dbConfig.alasql.insertOne({
-        name: config.name,
-        version: config.version,
-        diskPath,
-        config,
-        remotePath
-      });
+      if (insert) {
+        await dbConfig.alasql.insertOne({
+          name: config.name,
+          version: config.version,
+          config,
+          remotePath
+        });
+      }
       if (config.runeya.entries.backend) {
         try {
+          pluginsState[config.name] = { step: "INSTALL_BACKEND_START" };
           const child = await spawn("npm i --omit=dev", { cwd: path.dirname(path.resolve(diskPath, config.runeya.entries.backend)), shell: true });
           const installPromise = new Promise((resolve, reject) => {
             const installLog = [];
@@ -3992,17 +3984,28 @@ var require_plugins2 = __commonJS({
           console.error(error);
           sockets2.emit("plugins:install:error", config.name, error);
           return null;
+        } finally {
+          pluginsState[config.name] = void 0;
         }
       }
-      await loadPlugin(config.name);
+      if (shouldLoadPlugin) await loadPlugin(config.name);
       sockets2.emit("plugins:installed", {
         name: config.name,
         version: config.version,
-        diskPath,
         config,
         remotePath
       });
     }
+    async function init() {
+      const plugins3 = await getInstalledPlugins();
+      await PromiseB2.map(plugins3, async (plugin) => {
+        try {
+          await loadPlugin(plugin.name);
+        } catch (error) {
+          console.error(error);
+        }
+      }, { concurrency: 10 });
+    }
     async function getInstalledPlugins() {
       let installedPlugins = [];
       if (process.env.NODE_ENV === "HFBXdZMJxLyJoua28asEaxRixJ6LriR7FnRzX6pwA7pFjZ" && process.env.PLUGIN_ONLY_PRODUCTION !== "true") {
@@ -4015,7 +4018,6 @@ var require_plugins2 = __commonJS({
           installedPlugins.push({
             "name": config.name,
             "version": "development",
-            "diskPath": pluginPath,
             "config": {
               ...config,
               runeya: {
@@ -4033,7 +4035,12 @@ var require_plugins2 = __commonJS({
           });
         }));
       } else {
-        installedPlugins = await dbConfig.alasql.simpleSelect({});
+        const privatePlugins = await dbConfig.alasql.simpleSelect({});
+        const publicPlugins = await dbPublicPlugins.alasql.simpleSelect({});
+        const map = /* @__PURE__ */ new Map();
+        publicPlugins.forEach((plugin) => map.set(plugin.name, { ...plugin, availableForAll: true }));
+        privatePlugins.forEach((plugin) => map.set(plugin.name, plugin));
+        installedPlugins = [...map.values()];
         installedPlugins = installedPlugins.filter((plugin) => plugin.version !== "development");
       }
       const sortedPlugins = installedPlugins.sort((a, b) => a.name.localeCompare(b.name));
@@ -4046,18 +4053,41 @@ var require_plugins2 = __commonJS({
     }
     async function uninstall(name) {
       const [plugin] = await dbConfig.alasql.simpleSelect({ where: `name='${name}'` });
-      if (!plugin) {
+      const [publicPlugin] = await dbPublicPlugins.alasql.simpleSelect({ where: `name='${name}'` });
+      if (!plugin && !publicPlugin) {
         throw new HTTPError("Plugin not found", "404.plugin.not.found");
       }
-      if (plugin.diskPath && existsSync(plugin.diskPath)) {
-        await rm(plugin.diskPath, { recursive: true, force: true });
+      const diskPath = path.resolve(args2.runeyaConfigPath, "plugins", name);
+      if (diskPath && existsSync(diskPath)) {
+        await rm(diskPath, { recursive: true, force: true });
+      }
+      if (plugin) {
+        await dbConfig.alasql.delete(`name='${name}'`);
+      } else {
+        await dbPublicPlugins.alasql.delete(`name='${name}'`);
       }
-      await dbConfig.alasql.delete(`name='${name}'`);
       sockets2.emit("plugins:uninstalled", {
         name
       });
       return { success: true, message: "Plugin uninstalled successfully" };
     }
+    async function changeAvailability(name, availableForAll) {
+      let [plugin] = await dbConfig.alasql.simpleSelect({ where: `name='${name}'` });
+      if (!plugin) {
+        [plugin] = await dbPublicPlugins.alasql.simpleSelect({ where: `name='${name}'` });
+      }
+      if (!plugin) {
+        throw new HTTPError("Plugin not found", "404.plugin.not.found");
+      }
+      if (availableForAll) {
+        await dbPublicPlugins.alasql.insertOne(plugin);
+        await dbConfig.alasql.delete(`name='${name}'`);
+      } else {
+        await dbPublicPlugins.alasql.delete(`name='${name}'`);
+        await dbConfig.alasql.insertOne(plugin);
+      }
+      return { success: true, message: "Plugin availability changed successfully" };
+    }
     async function registerRoutes(router) {
       routes.forEach((route) => router.use(route));
       router.get("/api/plugins/themes", async (req, res) => {
@@ -4082,16 +4112,21 @@ var require_plugins2 = __commonJS({
       const pluginDir = path.dirname(pluginPath);
       Object.keys(require.cache).forEach((cachedPath) => {
         if (cachedPath.startsWith(pluginDir)) {
-          console.log("Clearing cache for:", cachedPath);
           delete require.cache[cachedPath];
         }
       });
     }
     async function loadPlugin(pluginName) {
+      pluginsState[pluginName] = { step: "LOAD_START" };
       try {
         const plugin = await getInstalledPlugin(pluginName);
         let backendPath;
         let themePath;
+        const diskPath = path.join(args2.runeyaConfigPath, "plugins", pluginName);
+        if (!existsSync(diskPath)) {
+          console.error("Plugin not found on disk, reinstalling", pluginName, "...");
+          return install(plugin.remotePath, true, false, false);
+        }
         if (process.env.NODE_ENV === "HFBXdZMJxLyJoua28asEaxRixJ6LriR7FnRzX6pwA7pFjZ" && process.env.PLUGIN_ONLY_PRODUCTION !== "true" && pluginName.startsWith("@runeya/")) {
           const pluginPath = path.resolve(__dirname, `../../../plugins/${pluginName.replace("@runeya/plugins-", "")}`);
           const frontPath = path.resolve(pluginPath, "front");
@@ -4149,9 +4184,12 @@ var require_plugins2 = __commonJS({
           }
         }
         if (backendPath) {
+          pluginsState[pluginName] = { step: "CLEAR_CACHE" };
           clearPluginCache(backendPath);
           try {
+            pluginsState[pluginName] = { step: "REQUIRE_BACKEND" };
             const loadedPlugin = safeRequire(backendPath);
+            pluginsState[pluginName] = { step: "LOAD_BACKEND_START" };
             loadedPlugins[pluginName] = await loadedPlugin(stack, {
               socket: {
                 emit: (event, ...args3) => {
@@ -4167,7 +4205,6 @@ var require_plugins2 = __commonJS({
             });
           } catch (error) {
             console.error(`[${plugin.name}@${plugin.version}]`, error);
-            console.log(Object.getOwnPropertyNames(error));
             setTimeout(() => {
               sockets2.emit("plugins:loading:error", pluginName, { ...error, message: error?.message?.split("\n")?.[0] });
             }, 1e3);
@@ -4175,8 +4212,11 @@ var require_plugins2 = __commonJS({
           }
         }
         if (themePath) {
+          pluginsState[pluginName] = { step: "CLEAR_CACHE" };
           clearPluginCache(themePath);
+          pluginsState[pluginName] = { step: "REQUIRE_BACKEND" };
           const loadedTheme = require(themePath);
+          pluginsState[pluginName] = { step: "LOAD_BACKEND_START" };
           themes[pluginName] = await loadedTheme(stack, {
             socket: {
               emit: (event, ...args3) => {
@@ -4194,6 +4234,8 @@ var require_plugins2 = __commonJS({
         return loadedPlugins[pluginName];
       } catch (error) {
         console.error(error?.message || error);
+      } finally {
+        pluginsState[pluginName] = void 0;
       }
     }
     function safeRequire(path2) {
@@ -4206,19 +4248,8 @@ var require_plugins2 = __commonJS({
     }
     async function frontFile(pluginName) {
       const plugin = await getInstalledPlugin(pluginName);
-      return await readFile(path.join(plugin.diskPath, plugin.config.runeya.entries.front.js), "utf8");
+      return await readFile(path.join(args2.runeyaConfigPath, "plugins", pluginName, plugin.config.runeya.entries.front.js), "utf8");
     }
-    (async () => {
-      const plugins2 = await getInstalledPlugins();
-      await Promise.all(plugins2.map(async (plugin) => {
-        try {
-          await loadPlugin(plugin.name);
-          console.log("loadedPlugin", plugin.name);
-        } catch (error) {
-          console.error(error);
-        }
-      }));
-    })();
     module2.exports = {
       install,
       frontFile,
@@ -4227,6 +4258,8 @@ var require_plugins2 = __commonJS({
       getInstalledPlugins,
       getInstalledPlugin,
       registerRoutes,
+      changeAvailability,
+      init,
       forService,
       ...allPlugins,
       routes
@@ -4234,6 +4267,35 @@ var require_plugins2 = __commonJS({
   }
 });
 
+// helpers/console.table.js
+var require_console_table = __commonJS({
+  "helpers/console.table.js"(exports2, module2) {
+    "use strict";
+    var { Transform } = require("stream");
+    var { Console } = require("console");
+    function table(input) {
+      const ts = new Transform({ transform(chunk, enc, cb) {
+        cb(null, chunk);
+      } });
+      const logger = new Console({ stdout: ts });
+      logger.table(input);
+      const table2 = (ts.read() || "").toString();
+      let result = "";
+      for (const row of table2.split(/[\r\n]+/)) {
+        let r = row.replace(/[^┬]*┬/, "\u250C");
+        r = r.replace(/^├─*┼/, "\u251C");
+        r = r.replace(/│[^│]*/, "");
+        r = r.replace(/^└─*┴/, "\u2514");
+        r = r.replace(/'/g, " ");
+        result += `${r}
+`;
+      }
+      console.log(result);
+    }
+    module2.exports = table;
+  }
+});
+
 // routes/plugins.js
 var require_plugins3 = __commonJS({
   "routes/plugins.js"(exports2, module2) {
@@ -4243,52 +4305,57 @@ var require_plugins3 = __commonJS({
     var PromiseB2 = require("bluebird");
     var { findService } = require_stack();
     var Stack = require_stack();
-    var plugins = require_plugins2();
+    var plugins2 = require_plugins2();
     var { readFile } = require("fs/promises");
     var path = require("path");
     var args2 = require_args();
     router.get("/", async (req, res) => {
-      res.send(await plugins.getInstalledPlugins());
+      res.send(await plugins2.getInstalledPlugins());
     });
     router.get("/front/:name", async (req, res) => {
-      const plugin = await plugins.getInstalledPlugin(req.params.name);
+      const plugin = await plugins2.getInstalledPlugin(req.params.name);
       res.send(plugin);
     });
     router.post("/install", async (req, res) => {
       const { url } = req.body;
-      const plugin = await plugins.install(url, req.query.force?.toString() === "true");
+      const plugin = await plugins2.install(url, req.query.force?.toString() === "true");
       res.send(plugin);
     });
+    router.post("/:plugin/change-availability", async (req, res) => {
+      const { availableForAll } = req.body;
+      const result = await plugins2.changeAvailability(req.params.plugin, availableForAll);
+      res.send(result);
+    });
     router.delete("/delete", async (req, res) => {
       const { name } = req.body;
-      const result = await plugins.uninstall(name);
+      const result = await plugins2.uninstall(name);
       res.send(result);
     });
     router.get("/services/:service", async (req, res) => {
       const service = findService(req.params.service);
-      const services = await PromiseB2.filter(plugins.forService, async (plugin) => plugin.hidden ? !await plugin.hidden(service, Stack, "service") : true);
+      const services = await PromiseB2.filter(plugins2.forService, async (plugin) => plugin.hidden ? !await plugin.hidden(service, Stack, "service") : true);
       services.sort((a, b) => (b?.order || Number.MAX_SAFE_INTEGER) - (a?.order || Number.MAX_SAFE_INTEGER));
       res.send(services);
     });
     router.get("/services", async (req, res) => {
-      const services = await PromiseB2.filter(plugins.forService, async (plugin) => plugin.hidden ? !await plugin.hidden(null, Stack, "global") : true);
+      const services = await PromiseB2.filter(plugins2.forService, async (plugin) => plugin.hidden ? !await plugin.hidden(null, Stack, "global") : true);
       res.send(services);
     });
     router.get("/:type", async (req, res) => {
       const services = await PromiseB2.filter(
-        plugins[req.params.type] || [],
+        plugins2[req.params.type] || [],
         async (plugin) => plugin.hidden ? !await plugin.hidden(null, Stack, req.params.type) : true
       );
       services.sort((a, b) => (a.order || 1e3) - (b.order || 1e3));
       res.send(services);
     });
     router.get("/:plugin/js", async (req, res) => {
-      const file = await plugins.frontFile(req.params.plugin);
+      const file = await plugins2.frontFile(req.params.plugin);
       res.setHeader("Content-Type", "application/javascript");
       res.send(file);
     });
     router.post("/:plugin/call/:method", async (req, res) => {
-      const result = await plugins.call(req.params.plugin, req.params.method, req.body?.args || []);
+      const result = await plugins2.call(req.params.plugin, req.params.method, req.body?.args || []);
       if (typeof result === "function") {
         await result(req, res);
       } else {
@@ -4935,8 +5002,8 @@ var require_routes11 = __commonJS({
     "use strict";
     var { express } = require_src6();
     var router = express.Router();
-    var plugins = require_plugins2();
-    plugins.registerRoutes(router);
+    var plugins2 = require_plugins2();
+    plugins2.registerRoutes(router);
     router.use("/plugins", require_plugins3());
     router.use("/system", require_system());
     router.use("/stack", require_stack2());
@@ -5078,12 +5145,14 @@ var require_server = __commonJS({
 var { sockets } = require_src();
 var migrateStackMonitor = require_migrateStackMonitor();
 var createDefaultFiles = require_createDefaultFiles();
+var plugins = require_plugins2();
 process.title = "runeya";
 var args = require_args();
 require("dotenv").config();
 (async () => {
   await migrateStackMonitor();
   await createDefaultFiles();
+  await plugins.init();
   if (args["pull-env"]) {
     await require_stack().selectConf();
     const service = require_stack().findService(args.s);