@runeya/runeya 1.33.22 → 1.33.23

package/www.js

@@ -102,7 +102,7 @@ var require_args = __commonJS({
     var path = require("path");
     var yargs = require("yargs/yargs");
     var { hideBin } = require("yargs/helpers");
-    var { existsSync: existsSync2 } = require("fs");
+    var { existsSync } = require("fs");
     var yarg = yargs(hideBin(process.argv)).usage("Usage: <path-to-your-stack> [options]").alias("pe", "pull-env").describe("pe", "Pull env from a service (need --environment and --service)").default("pe", false).alias("e", "environment").describe("e", "Choose your environment").default("e", void 0).alias("s", "service").describe("s", "Service").default("s", void 0).alias("ss", "services").describe("ss", "Services").default("ss", []).boolean(["pe"]).string(["e", "s"]).array(["ss"]).help("h").alias("h", "help").parse();
     var rootPath = path.resolve(yarg["_"]?.[0] || ".");
     var args2 = Object.assign({
@@ -111,7 +111,7 @@ var require_args = __commonJS({
       runeyaConfigPath: path.resolve(rootPath, ".runeya"),
       runeyaGlobalConfigPath: path.resolve(require("os").homedir(), ".runeya-global")
     }, yarg);
-    if (!existsSync2(args2.rootPath)) {
+    if (!existsSync(args2.rootPath)) {
       console.error("Error: Runeya was launched with an invalid root path that does not exist. Please check your launch command. \nPath: ", args2.rootPath);
       process.exit(1);
     }
@@ -131,19 +131,112 @@ var require_args = __commonJS({
   }
 });
 
+// helpers/migrateStackMonitor.js
+var require_migrateStackMonitor = __commonJS({
+  "helpers/migrateStackMonitor.js"(exports2, module2) {
+    "use strict";
+    var pathfs = require("path");
+    var { existsSync } = require("fs");
+    var { cp } = require("fs/promises");
+    var args2 = require_args();
+    module2.exports = async function migrateStackMonitor2() {
+      const localLegacyPath = pathfs.resolve(args2.runeyaConfigPath, "../.stackmonitor");
+      const localNewPath = args2.runeyaConfigPath;
+      if (existsSync(localLegacyPath) && !existsSync(localNewPath)) {
+        console.log("Legacy path found, copy to new path");
+        await cp(localLegacyPath, localNewPath, { recursive: true, force: true });
+      }
+      const globalLegacyPath = pathfs.resolve(args2.runeyaGlobalConfigPath, "../.stackmonitor");
+      const globalNewPath = args2.runeyaGlobalConfigPath;
+      if (existsSync(globalLegacyPath) && !existsSync(globalNewPath)) {
+        console.log("Legacy path found, copy to new path");
+        await cp(globalLegacyPath, globalNewPath, { recursive: true, force: true });
+      }
+      if (existsSync(localLegacyPath) && !existsSync(pathfs.resolve(args2.runeyaConfigPath, "dbs/overrides"))) {
+        console.log("Legacy path found, copy to new path");
+        await cp(pathfs.resolve(localLegacyPath, "dbs/overrides"), pathfs.resolve(args2.runeyaConfigPath, "dbs/overrides"), { recursive: true, force: true });
+      }
+      if (existsSync(localLegacyPath) && !existsSync(pathfs.resolve(args2.runeyaConfigPath, "dbs/encryption-key.json"))) {
+        console.log("Legacy path found, copy to new path");
+        await cp(pathfs.resolve(localLegacyPath, "dbs/encryption-key.json"), pathfs.resolve(args2.runeyaConfigPath, "dbs/encryption-key.json"), { recursive: true, force: true });
+      }
+    };
+  }
+});
+
+// helpers/conflictStorage.js
+var require_conflictStorage = __commonJS({
+  "helpers/conflictStorage.js"(exports2, module2) {
+    "use strict";
+    var pendingConflicts = [];
+    function storeConflict(conflict) {
+      const conflictId = Date.now().toString();
+      pendingConflicts.push({
+        id: conflictId,
+        timestamp: Date.now(),
+        ...conflict
+      });
+      if (pendingConflicts.length > 20) {
+        pendingConflicts.shift();
+      }
+      return conflictId;
+    }
+    function getPendingConflicts() {
+      return pendingConflicts;
+    }
+    function removeConflict(conflictId) {
+      const index = pendingConflicts.findIndex((c) => c.id === conflictId);
+      if (index !== -1) {
+        pendingConflicts.splice(index, 1);
+      }
+    }
+    module2.exports = {
+      storeConflict,
+      getPendingConflicts,
+      removeConflict
+    };
+  }
+});
+
+// helpers/reencrypt-nodered.js
+var require_reencrypt_nodered = __commonJS({
+  "helpers/reencrypt-nodered.js"(exports2, module2) {
+    "use strict";
+    var crypto = 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 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 decrypted = decipher.update(flows, "base64", "utf8") + decipher.final("utf8");
+      const newVector = crypto.randomBytes(16);
+      const newCipher = crypto.createCipheriv(encryptionAlgorithm, newKey, newVector);
+      const encrypted = newCipher.update(decrypted, "utf8", "base64") + newCipher.final("base64");
+      await writeFile(path, JSON.stringify({
+        "$": newVector.toString("hex") + encrypted
+      }, null, 2), "utf-8");
+    };
+  }
+});
+
 // ../../modules/bugs/backend/routes.js
 var require_routes = __commonJS({
   "../../modules/bugs/backend/routes.js"(exports2, module2) {
     "use strict";
     var express = require("express");
     var router = express.Router();
-    var pathfs2 = require("path");
+    var pathfs = require("path");
     var { fork } = require("child_process");
     module2.exports = (runeya) => {
       router.get("/bugs/:service", async (req, res) => {
         const service = runeya.findService(req.params.service);
         if (!service) return res.status(404).send("SERVICE_NOT_FOUND");
-        const ts = fork(pathfs2.resolve(__dirname, "checkJsFork"));
+        const ts = fork(pathfs.resolve(__dirname, "checkJsFork"));
         ts.on("message", (results) => {
           res.json(results);
           ts.kill("SIGKILL");
@@ -160,8 +253,8 @@ var require_routes = __commonJS({
 var require_backend = __commonJS({
   "../../modules/bugs/backend/index.js"(exports2, module2) {
     "use strict";
-    var { existsSync: existsSync2 } = require("fs");
-    var pathfs2 = require("path");
+    var { existsSync } = require("fs");
+    var pathfs = require("path");
     var plugin = {
       enabled: true,
       name: "Bugs",
@@ -201,756 +294,313 @@ var require_backend2 = __commonJS({
   }
 });
 
-// helpers/conflictStorage.js
-var require_conflictStorage = __commonJS({
-  "helpers/conflictStorage.js"(exports2, module2) {
+// ../../modules/documentation/backend/Documentation.js
+var require_Documentation = __commonJS({
+  "../../modules/documentation/backend/Documentation.js"(exports2, module2) {
     "use strict";
-    var pendingConflicts = [];
-    function storeConflict(conflict) {
-      const conflictId = Date.now().toString();
-      pendingConflicts.push({
-        id: conflictId,
-        timestamp: Date.now(),
-        ...conflict
-      });
-      if (pendingConflicts.length > 20) {
-        pendingConflicts.shift();
+    var PromiseB2 = require("bluebird");
+    var { randomUUID: randomUUID2 } = require("crypto");
+    var dbs2 = require_dbs();
+    var db = dbs2.getDb(`documentations`);
+    var dbDocumentationTree = dbs2.getDb(`documentations-tree`, { encrypted: true, defaultData: [] }).alasql;
+    var Documentation = class {
+      /**
+       * @param {import('@runeya/common-typings').NonFunctionProperties<Documentation>} documentation
+       */
+      constructor(documentation) {
+        this.id = documentation.id || "";
+        this.text = documentation.text || "";
       }
-      return conflictId;
-    }
-    function getPendingConflicts() {
-      return pendingConflicts;
-    }
-    function removeConflict(conflictId) {
-      const index = pendingConflicts.findIndex((c) => c.id === conflictId);
-      if (index !== -1) {
-        pendingConflicts.splice(index, 1);
+      static async load(id) {
+      }
+      static async all() {
+        return db.alasql.select("Select * from ?");
+      }
+      static async find(envId) {
+        const documentations = await this.all();
+        return documentations.find((env) => env.id === envId);
+      }
+      async save() {
+        const obj = this.toStorage();
+        await dbs2.getDb(`documentations/${this.id}`).write(obj);
+        return this;
+      }
+      async update(env) {
+        this.transform = env.transform;
+        this.label = env.label;
+        await dbs2.getDb(`documentations/${this.id}`).write(this.toStorage());
+      }
+      async delete() {
+        await dbs2.getDb(`documentations/${this.id}`).delete();
+      }
+      toStorage() {
+        return {
+          id: this.id,
+          label: this.label,
+          transform: this.transform
+        };
       }
-    }
-    module2.exports = {
-      storeConflict,
-      getPendingConflicts,
-      removeConflict
-    };
-  }
-});
-
-// helpers/reencrypt-nodered.js
-var require_reencrypt_nodered = __commonJS({
-  "helpers/reencrypt-nodered.js"(exports2, module2) {
-    "use strict";
-    var crypto = 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 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 decrypted = decipher.update(flows, "base64", "utf8") + decipher.final("utf8");
-      const newVector = crypto.randomBytes(16);
-      const newCipher = crypto.createCipheriv(encryptionAlgorithm, newKey, newVector);
-      const encrypted = newCipher.update(decrypted, "utf8", "base64") + newCipher.final("base64");
-      await writeFile(path, JSON.stringify({
-        "$": newVector.toString("hex") + encrypted
-      }, null, 2), "utf-8");
     };
+    module2.exports = Documentation;
   }
 });
 
-// models/EncryptionKey.js
-var require_EncryptionKey = __commonJS({
-  "models/EncryptionKey.js"(exports2, module2) {
+// ../../modules/documentation/backend/Leaf.js
+var require_Leaf = __commonJS({
+  "../../modules/documentation/backend/Leaf.js"(exports2, module2) {
     "use strict";
-    var { existsSync: existsSync2 } = require("fs");
-    var path = require("path");
-    var { writeFile, readFile, appendFile } = require("fs/promises");
+    var PromiseB2 = require("bluebird");
     var { randomUUID: randomUUID2 } = require("crypto");
     var dbs2 = require_dbs();
-    var { generateKey, encrypt, decrypt } = require_crypto();
-    var reencryptNodered = require_reencrypt_nodered();
-    var pathfs2 = require("path");
-    var args2 = require_args();
-    var _EncryptionKey_instances, getDb_fn;
-    var EncryptionKey = class {
-      constructor() {
-        __privateAdd(this, _EncryptionKey_instances);
-        this.encryptionKey = "";
-      }
-      async init() {
-        this.encryptionKey = (await __privateMethod(this, _EncryptionKey_instances, getDb_fn).call(this).read()).encryptionKey;
-        const dirname = path.dirname(await dbs2.getDb("encryption-key", { encrypted: false }).getPath());
-        const gitignorePath = path.resolve(dirname, ".gitignore");
-        if (!existsSync2(gitignorePath)) {
-          writeFile(gitignorePath, "encryption-key.json");
-        } else {
-          const gitignoreFile = (await readFile(gitignorePath, "utf-8")).split("\n");
-          const gitignoreHasKey = (key) => gitignoreFile.some((line) => line.trim() === key);
-          if (!gitignoreHasKey("encryption-key.json")) await appendFile(gitignorePath, "\nencryption-key.json");
-          if (!gitignoreHasKey("overrides")) await appendFile(gitignorePath, "\noverrides");
-        }
+    var { v4 } = require("uuid");
+    var dbLeafTree = dbs2.getDb(`leafs-leafs`, { encrypted: true, defaultData: [] }).alasql;
+    var Leaf = class _Leaf {
+      /**
+       * @param {import('@runeya/common-typings').NonFunctionProperties<Leaf>} leaf
+       */
+      constructor(leaf) {
+        this.id = leaf.id || v4();
+        this.docId = leaf.docId || "";
+        this.serviceId = leaf.serviceId || "";
+        this.label = leaf.label || "";
+        this.position = leaf.position || -1;
+        this.text = leaf.text || "";
+        this.parentId = leaf.parentId || "";
       }
-      async update() {
-        return __privateMethod(this, _EncryptionKey_instances, getDb_fn).call(this).write(this.toStorage());
+      static async getTree(serviceLabel) {
+        const leafs = await dbLeafTree.read(`Select * from ${dbLeafTree.table} ${serviceLabel ? `where serviceId = '${serviceLabel}'` : `where serviceId=''`}`);
+        return leafs;
       }
       toStorage() {
         return {
-          encryptionKey: this.encryptionKey
+          docId: this.docId,
+          position: this.position,
+          serviceId: this.serviceId,
+          label: this.label,
+          text: this.text,
+          parentId: this.parentId
         };
       }
-      async generateKey() {
-        return generateKey();
+      async remove() {
+        return dbLeafTree.write(`DELETE from ${dbLeafTree.table} where id = '${this.id}'`);
       }
-      async testKey(encryptionKey) {
-        try {
-          const variable = randomUUID2();
-          const result = await encrypt(variable, { encryptionKey });
-          const decrypted = await decrypt(result, { encryptionKey });
-          if (decrypted === variable) return true;
-          return false;
-        } catch (error) {
-          console.error(error);
-          return false;
-        }
+      static async find({ id }) {
+        const [leaf] = await dbLeafTree.read(`Select * from ${dbLeafTree.table} where id='${id}'`);
+        return leaf ? new _Leaf(leaf) : null;
       }
-      async saveKey(key, { noReload } = { noReload: false }) {
-        if (!await this.testKey(key)) throw new Error("Key not valid");
-        try {
-          const envSample = (await dbs2.getDbs("envs"))[0];
-          if (envSample) await dbs2.getDb(`envs/${envSample}`).read();
-          if (this.encryptionKey) {
-            await reencryptNodered(this.encryptionKey, key, pathfs2.resolve(require_stack().getRootPath(), "nodered/flow_cred.json"));
-            await dbs2.reencrypt(this.encryptionKey, key);
-          }
-          ;
-        } catch (error) {
-          console.error(error);
-        }
-        const shouldRestart = this.encryptionKey !== key;
-        this.encryptionKey = key;
-        await this.update();
-        if (!noReload) {
-          await require_stack().selectConf();
-        }
-        if (shouldRestart) {
-          console.log("Restart...");
-          require("child_process").spawn(process.argv[0], process.argv.slice(1), {
-            cwd: args2.initialCwd,
-            detached: true,
-            stdio: "inherit"
-          }).unref();
-          process.exit(0);
-        }
-        return key;
+      async save() {
+        const leafExists = await _Leaf.find({ id: this.id });
+        const storage = this.toStorage();
+        const set = dbLeafTree.buildUpdateQuery(storage);
+        await leafExists ? dbLeafTree.write(`update ${dbLeafTree.table} set ${set} where id='${this.id}'`) : dbLeafTree.write(`insert into ${dbLeafTree.table} (id, docId, position, serviceId, label, text, parentId) values ('${this.id}', '${this.docId}', ${this.position}, '${this.serviceId}', '${this.label.replace(/'/g, "''")}', '${this.text.replace(/'/g, "''")}', '${this.parentId}')`);
+        return this;
       }
     };
-    _EncryptionKey_instances = new WeakSet();
-    getDb_fn = function() {
-      return dbs2.getDb("encryption-key", { encrypted: false });
-    };
-    module2.exports = new EncryptionKey();
+    module2.exports = Leaf;
   }
 });
 
-// helpers/crypto.js
-var require_crypto = __commonJS({
-  "helpers/crypto.js"(exports2, module2) {
+// ../../modules/documentation/backend/routes.js
+var require_routes2 = __commonJS({
+  "../../modules/documentation/backend/routes.js"(exports2, module2) {
     "use strict";
-    var _sodium = require("libsodium-wrappers");
-    var crypto = require("crypto");
-    var { sockets: sockets2 } = require_src();
-    var conflictStorage = require_conflictStorage();
-    var path = require("path");
-    module2.exports.generateKey = async () => {
-      await _sodium.ready;
-      const sodium = _sodium;
-      const key = sodium.crypto_aead_aegis256_keygen();
-      return sodium.to_base64(key);
-    };
-    module2.exports.encrypt = async (data, { additionnalNonce = "", encryptionKey = "" } = {}) => {
-      await _sodium.ready;
-      const sodium = _sodium;
-      if (!encryptionKey) encryptionKey = require_EncryptionKey().encryptionKey;
-      const key = sodium.from_base64(encryptionKey);
-      if (!key || key.length !== sodium.crypto_secretbox_KEYBYTES) {
-        throw new Error("Invalid encryption key length");
-      }
-      let nonce;
-      if (additionnalNonce) {
-        const combinedHash = crypto.createHash("blake2b512").update(data + additionnalNonce).digest();
-        nonce = combinedHash.slice(0, sodium.crypto_secretbox_NONCEBYTES);
-      } else {
-        nonce = sodium.randombytes_buf(sodium.crypto_secretbox_NONCEBYTES);
-      }
-      const dataStr = typeof data === "string" ? data : String(data);
-      const dataArray = new TextEncoder().encode(dataStr);
-      const ciphertext = sodium.crypto_secretbox_easy(dataArray, nonce, key);
-      return Buffer.concat([
-        Buffer.from(nonce.buffer, nonce.byteOffset, nonce.byteLength),
-        Buffer.from(ciphertext.buffer, ciphertext.byteOffset, ciphertext.byteLength)
-      ]).toString("base64");
-    };
-    module2.exports.decryptFile = async (encryptedData, options = {}, filePath) => {
-      if (typeof encryptedData === "string" && (encryptedData.includes("<<<<<<< HEAD") || encryptedData.includes("=======") || encryptedData.includes(">>>>>>>"))) {
-        return await handleGitConflict(encryptedData, options, filePath);
-      }
-      return await module2.exports.decrypt(encryptedData, options);
+    var express = require("express");
+    var Leaf = require_Leaf();
+    var PromiseB2 = require("bluebird");
+    var router = express.Router();
+    module2.exports = (runeya) => {
+      const { findService } = runeya;
+      router.get("/documentation/tree", async (req, res) => {
+        const service = findService(req.query.serviceId?.toString() || "");
+        const result = await Leaf.getTree(service?.label);
+        return res.send(result);
+      });
+      router.post("/documentation/tree/sort", async (req, res) => {
+        const leafs = await PromiseB2.mapSeries(req.body, async (_leaf, index) => {
+          const leaf = await Leaf.find({ id: _leaf.id });
+          if (!leaf) return;
+          leaf.position = index;
+          await leaf.save();
+          return leaf;
+        });
+        return res.send(leafs);
+      });
+      router.post("/documentation/tree", async (req, res) => {
+        const result = await new Leaf({
+          ...req.body
+        }).save();
+        return res.send(result);
+      });
+      router.post("/documentation/tree/:key", async (req, res) => {
+        const result = await new Leaf({
+          ...req.body,
+          id: req.params.key
+        }).save();
+        return res.send(result);
+      });
+      router.delete("/documentation/tree/:key", async (req, res) => {
+        const result = await Leaf.find({
+          id: req.params.key
+        });
+        if (result) return res.send(await result.remove());
+        return res.send();
+      });
+      return router;
     };
-    module2.exports.decrypt = async (encryptedData, { additionnalNonce = "", encryptionKey = "" } = {}) => {
-      if (typeof encryptedData === "string" && (encryptedData.includes("<<<<<<< HEAD") || encryptedData.includes("=======") || encryptedData.includes(">>>>>>>"))) {
-        return await handleGitConflict(encryptedData, { additionnalNonce, encryptionKey });
-      }
-      await _sodium.ready;
-      const sodium = _sodium;
-      if (!encryptionKey) encryptionKey = require_EncryptionKey().encryptionKey;
-      const key = sodium.from_base64(encryptionKey);
-      if (!key || key.length !== sodium.crypto_secretbox_KEYBYTES) {
-        throw new Error("Invalid decryption key length");
-      }
-      const encryptedBuffer = Buffer.from(encryptedData, "base64");
-      const nonce = encryptedBuffer.slice(0, sodium.crypto_secretbox_NONCEBYTES);
-      const ciphertext = encryptedBuffer.slice(sodium.crypto_secretbox_NONCEBYTES);
-      let decrypted;
-      try {
-        const ciphertextArray = new Uint8Array(ciphertext);
-        const nonceArray = new Uint8Array(nonce);
-        decrypted = sodium.crypto_secretbox_open_easy(ciphertextArray, nonceArray, key);
-      } catch (error) {
-        throw new Error("Decryption failed");
-      }
-      if (!decrypted) {
-        throw new Error("Decryption failed");
+  }
+});
+
+// ../../modules/documentation/backend/index.js
+var require_backend3 = __commonJS({
+  "../../modules/documentation/backend/index.js"(exports2, module2) {
+    "use strict";
+    var { readFile } = require("fs/promises");
+    var PromiseB2 = require("bluebird");
+    var pathfs = require("path");
+    var Documentation = require_Documentation();
+    var plugin = {
+      enabled: true,
+      name: "Documentation",
+      displayName: "Documentation",
+      description: "Read documentation for a given service",
+      icon: "fas fa-book",
+      // export: Documentation,
+      placements: ["service"],
+      order: 6,
+      routes: require_routes2(),
+      finder: async (search, runeya) => {
       }
-      return Buffer.from(decrypted).toString("utf-8");
     };
-    async function handleGitConflict(conflictedData, options, filePath) {
-      const headMatch = conflictedData.match(/<<<<<<< HEAD\r?\n([\s\S]*?)\r?\n=======\r?\n([\s\S]*?)\r?\n>>>>>>>.*/);
-      if (!headMatch) {
-        throw new Error("Git conflict detected but could not be properly parsed");
-      }
-      try {
-        const ourVersion = headMatch[1];
-        const theirVersion = headMatch[2];
-        let ourDecrypted = "";
-        let theirDecrypted = "";
-        try {
-          ourDecrypted = await module2.exports.decrypt(ourVersion, options);
-        } catch (err) {
-          const errorMessage = err instanceof Error ? err.message : String(err);
-          ourDecrypted = `[ERROR DECRYPTING OUR VERSION: ${errorMessage}]`;
-        }
-        try {
-          theirDecrypted = await module2.exports.decrypt(theirVersion, options);
-        } catch (err) {
-          const errorMessage = err instanceof Error ? err.message : String(err);
-          theirDecrypted = `[ERROR DECRYPTING THEIR VERSION: ${errorMessage}]`;
+    module2.exports = plugin;
+  }
+});
+
+// ../../modules/finder/backend/routes.js
+var require_routes3 = __commonJS({
+  "../../modules/finder/backend/routes.js"(exports2, module2) {
+    "use strict";
+    var express = require("express");
+    var router = express.Router();
+    var PromiseB2 = require("bluebird");
+    function pluginToUrl(plugin) {
+      for (let i = 0; i < plugin.placements.length; i += 1) {
+        const placement = plugin.placements[i];
+        if (typeof placement !== "string") {
+          if (placement.position === "toolbox") {
+            return `/toolbox${placement.goTo?.path || placement.goTo}`;
+          }
+          if (placement.position === "sidebar") {
+            return `${placement.goTo?.path || placement.goTo}`;
+          }
         }
-        const conflictData = {
-          original: conflictedData,
-          ourVersion: ourDecrypted,
-          theirVersion: theirDecrypted,
-          filePath: filePath || null,
-          filename: filePath ? path.basename(filePath) : null
-        };
-        const conflictId = conflictStorage.storeConflict(conflictData);
-        conflictData.id = conflictId;
-        sockets2.emit("crypto:conflict", conflictData);
-        return `${JSON.stringify({
-          ourVersion: ourDecrypted,
-          theirVersion: theirDecrypted
-        })}`;
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        console.error("Error handling git conflict:", errorMessage);
-        throw new Error(`Git conflict detected, but failed to process: ${errorMessage}`);
       }
+      return "";
     }
+    var routes = (runeya) => {
+      const {
+        getServices,
+        helpers: { searchString }
+      } = runeya;
+      router.get("/finder/search", async (req, res) => {
+        const search = req.query.q?.toString()?.toUpperCase() || "";
+        const services = getServices().filter((service) => searchString(service?.label, search)).map((service) => ({
+          title: service.label,
+          description: service.description,
+          group: "Service",
+          url: `/stack-single/${service.label}`
+        }));
+        const { plugins } = runeya;
+        const _plugins = (await PromiseB2.map(Object.keys(plugins), (key) => plugins[key]).map(async (plugin) => [
+          ...await plugin?.finder?.(search, runeya)?.catch?.(() => []) || [],
+          ...searchString(plugin.name, search) ? [{
+            title: plugin.displayName || plugin.name,
+            description: plugin.description,
+            group: "Plugin",
+            icon: plugin.icon,
+            url: pluginToUrl(plugin) || ""
+          }] : []
+        ])).flat().filter((a) => a?.url);
+        const result = [
+          ...services,
+          ..._plugins
+        ].filter((a) => a);
+        res.send(result);
+      });
+      return router;
+    };
+    module2.exports = routes;
   }
 });
 
-// helpers/dbs.js
-var require_dbs = __commonJS({
-  "helpers/dbs.js"(exports2, module2) {
+// ../../modules/finder/backend/index.js
+var require_backend4 = __commonJS({
+  "../../modules/finder/backend/index.js"(exports2, module2) {
     "use strict";
-    var {
-      existsSync: existsSync2,
-      mkdirSync,
-      writeFileSync,
-      readFileSync,
-      unlinkSync
-    } = require("fs");
-    var pathfs2 = require("path");
-    var {
-      readdir,
-      mkdir: mkdir2,
-      writeFile,
-      readFile,
-      unlink
-    } = require("fs/promises");
-    var { fdir } = require("fdir");
-    var PromiseB2 = require("bluebird");
-    var { sockets: sockets2 } = require_src();
-    var args2 = require_args();
-    var { encrypt, decrypt, decryptFile } = require_crypto();
-    var alasql = require("alasql");
-    module2.exports = new class {
-      constructor() {
-        __publicField(this, "cache", {});
-      }
-      getRootPath() {
-        const rootPath = pathfs2.resolve(args2.rootPath, ".runeya/dbs");
-        if (!existsSync2(rootPath)) mkdirSync(rootPath, { recursive: true });
-        return rootPath;
-      }
-      async getDbs(namespace = "") {
-        const pathToDbs = pathfs2.resolve(this.getRootPath(), namespace);
-        if (!existsSync2(pathToDbs)) await mkdir2(pathToDbs, { recursive: true });
-        return (await readdir(pathToDbs)).map((id) => id.replace(pathfs2.extname(id), "").replace(".encrypted", ""));
-      }
-      async reencrypt(oldKey, newKey) {
-        const api = new fdir().withFullPaths().filter((path) => path.endsWith("encrypted.json")).crawl(this.getRootPath());
-        await PromiseB2.map(api.withPromise(), async (file) => {
-          const fileEncrypted = await readFile(file, "utf-8");
-          const additionnalNonce = file.split(".runeya").pop();
-          const fileDecrypted = await decrypt(fileEncrypted, { additionnalNonce, encryptionKey: oldKey });
-          const fileReEncrypted = await encrypt(fileDecrypted, { additionnalNonce, encryptionKey: newKey });
-          await writeFile(file, fileReEncrypted, "utf-8");
-        });
-      }
-      getDb(id, { encrypted, defaultData } = { encrypted: true, defaultData: {} }) {
-        const getPath = async () => {
-          const persistencePath = pathfs2.resolve(`${this.getRootPath()}/${id}${encrypted ? ".encrypted" : ""}.json`);
-          if (!existsSync2(pathfs2.dirname(persistencePath))) await mkdirSync(pathfs2.dirname(persistencePath), { recursive: true });
-          if (!existsSync2(persistencePath)) {
-            let defaultDB = JSON.stringify(defaultData || [], null, 2);
-            if (encrypted) defaultDB = await encrypt(defaultDB, { additionnalNonce: persistencePath.split(".runeya").pop() });
-            await writeFile(persistencePath, defaultDB, "utf-8");
-            this.cache[id] = defaultDB;
-          }
-          return persistencePath;
-        };
-        const table = id.replace(/[^a-z0-9]|\s+|\r?\n|\r/gmi, "_");
-        const read = async () => {
-          if (this.cache[id]) return this.cache[id];
-          const path = await getPath();
-          const additionnalNonce = path.split(".runeya").pop();
-          let db = readFileSync(path, "utf-8");
-          if (encrypted) {
-            try {
-              if (typeof db === "string" && (db.includes("<<<<<<< HEAD") || db.includes("=======") || db.includes(">>>>>>>"))) {
-                db = await decryptFile(db, { additionnalNonce }, path);
-              } else {
-                db = await decrypt(db, { additionnalNonce }).catch((err) => {
-                  console.error(path, err);
-                  sockets2.emit("system:wrongKey");
-                  throw err;
-                });
-              }
-            } catch (err) {
-              console.error(path, err);
-              sockets2.emit("system:wrongKey");
-              throw err;
-            }
-          }
-          this.cache[id] = JSON.parse(db);
-          if (!alasql.tables[table]) {
-            await alasql(`CREATE TABLE ${table}`);
-          }
-          alasql.tables[table].data = this.cache[id];
-          return this.cache[id];
-        };
-        const write = async (data) => {
-          let db = JSON.stringify(data, null, 2);
-          const path = await getPath();
-          const additionnalNonce = path.split(".runeya").pop();
-          if (encrypted) db = await encrypt(db, { additionnalNonce });
-          writeFileSync(path, db, "utf-8");
-          this.cache[id] = data;
-          if (alasql.tables[table]) {
-            alasql.tables[table].data = data;
-          }
-        };
-        const escapeQuote = (data) => {
-          if (typeof data === "string") {
-            return data.replace(/'/g, "''");
-          }
-          return data;
-        };
-        const setValue = (item) => {
-          if (item == null) {
-            return "NULL";
-          }
-          if (item instanceof Date && item.toISOString) {
-            return `'${item.toISOString()}'`;
-          }
-          if (typeof item === "string") {
-            return `'${escapeQuote(item)}'`;
-          }
-          return `${item}`;
-        };
-        return {
-          getPath,
-          alasql: {
-            table,
-            buildUpdateQuery(data) {
-              const set = [];
-              Object.keys(data).forEach((key) => {
-                set.push(`${key} = ${setValue(data[key])}`);
-              });
-              return set.join(", ");
-            },
-            read: async (sql) => {
-              await read();
-              return alasql.promise(sql);
-            },
-            /**
-             * 
-             * @param {{where?: string, orderBy?: string, limit?: number, offset?: number}} param0 
-             * @returns {Promise<any[]>}
-             */
-            simpleSelect: async ({ where, orderBy, limit, offset }) => {
-              await read();
-              return alasql.promise(`SELECT * FROM ${table} ${where ? `WHERE ${where}` : ""} ${orderBy ? `ORDER BY ${orderBy}` : ""} ${limit ? `LIMIT ${limit}` : ""} ${offset ? `OFFSET ${offset}` : ""}`);
-            },
-            /** @param {string} where */
-            delete: async (where) => {
-              await read();
-              await alasql.promise(`DELETE FROM ${table} WHERE ${where}`);
-              await write(await alasql(`select * from ${table}`));
-            },
-            insertOne: async (data) => {
-              await read();
-              await alasql.promise(`INSERT INTO ${table} VALUES ${JSON.stringify(data)}`);
-              await write(await alasql(`select * from ${table}`));
-            },
-            write: async (sql, value) => {
-              await read();
-              await alasql.promise(sql, value);
-              await write(await alasql(`select * from ${table}`));
-            }
-          },
-          write,
-          read,
-          delete: async () => {
-            delete this.cache[id];
-            return unlink(await getPath());
-          }
-        };
-      }
-    }();
+    var commandExists = require("command-exists");
+    var plugin = {
+      enabled: true,
+      name: "Finder",
+      displayName: "Finder",
+      description: "Find all you want inside this app",
+      icon: "fab fa-git-alt",
+      export: null,
+      order: -1,
+      placements: ["global", {
+        position: "sidebar",
+        label: "Finder",
+        icon: "fas fa-search",
+        goTo: { path: "/Finder" },
+        active: "Finder"
+      }],
+      hidden: () => commandExists("git").then(() => false).catch(() => true),
+      routes: require_routes3()
+    };
+    module2.exports = plugin;
   }
 });
 
-// ../../modules/documentation/backend/Documentation.js
-var require_Documentation = __commonJS({
-  "../../modules/documentation/backend/Documentation.js"(exports2, module2) {
+// helpers/exec.js
+var require_exec = __commonJS({
+  "helpers/exec.js"(exports2, module2) {
     "use strict";
-    var PromiseB2 = require("bluebird");
-    var { randomUUID: randomUUID2 } = require("crypto");
-    var dbs2 = require_dbs();
-    var db = dbs2.getDb(`documentations`);
-    var dbDocumentationTree = dbs2.getDb(`documentations-tree`, { encrypted: true, defaultData: [] }).alasql;
-    var Documentation = class {
+    var { exec } = require("child_process");
+    module2.exports = {
       /**
-       * @param {import('@runeya/common-typings').NonFunctionProperties<Documentation>} documentation
+       * @param {string} cmd
+       * @param {import('child_process').ExecOptions} options
+       * @returns {Promise<string>}
        */
-      constructor(documentation) {
-        this.id = documentation.id || "";
-        this.text = documentation.text || "";
-      }
-      static async load(id) {
-      }
-      static async all() {
-        return db.alasql.select("Select * from ?");
-      }
-      static async find(envId) {
-        const documentations = await this.all();
-        return documentations.find((env) => env.id === envId);
-      }
-      async save() {
-        const obj = this.toStorage();
-        await dbs2.getDb(`documentations/${this.id}`).write(obj);
-        return this;
-      }
-      async update(env) {
-        this.transform = env.transform;
-        this.label = env.label;
-        await dbs2.getDb(`documentations/${this.id}`).write(this.toStorage());
-      }
-      async delete() {
-        await dbs2.getDb(`documentations/${this.id}`).delete();
-      }
-      toStorage() {
-        return {
-          id: this.id,
-          label: this.label,
-          transform: this.transform
-        };
-      }
-    };
-    module2.exports = Documentation;
-  }
-});
-
-// ../../modules/documentation/backend/Leaf.js
-var require_Leaf = __commonJS({
-  "../../modules/documentation/backend/Leaf.js"(exports2, module2) {
-    "use strict";
-    var PromiseB2 = require("bluebird");
-    var { randomUUID: randomUUID2 } = require("crypto");
-    var dbs2 = require_dbs();
-    var { v4 } = require("uuid");
-    var dbLeafTree = dbs2.getDb(`leafs-leafs`, { encrypted: true, defaultData: [] }).alasql;
-    var Leaf = class _Leaf {
-      /**
-       * @param {import('@runeya/common-typings').NonFunctionProperties<Leaf>} leaf
-       */
-      constructor(leaf) {
-        this.id = leaf.id || v4();
-        this.docId = leaf.docId || "";
-        this.serviceId = leaf.serviceId || "";
-        this.label = leaf.label || "";
-        this.position = leaf.position || -1;
-        this.text = leaf.text || "";
-        this.parentId = leaf.parentId || "";
-      }
-      static async getTree(serviceLabel) {
-        const leafs = await dbLeafTree.read(`Select * from ${dbLeafTree.table} ${serviceLabel ? `where serviceId = '${serviceLabel}'` : `where serviceId=''`}`);
-        return leafs;
-      }
-      toStorage() {
-        return {
-          docId: this.docId,
-          position: this.position,
-          serviceId: this.serviceId,
-          label: this.label,
-          text: this.text,
-          parentId: this.parentId
-        };
-      }
-      async remove() {
-        return dbLeafTree.write(`DELETE from ${dbLeafTree.table} where id = '${this.id}'`);
-      }
-      static async find({ id }) {
-        const [leaf] = await dbLeafTree.read(`Select * from ${dbLeafTree.table} where id='${id}'`);
-        return leaf ? new _Leaf(leaf) : null;
-      }
-      async save() {
-        const leafExists = await _Leaf.find({ id: this.id });
-        const storage = this.toStorage();
-        const set = dbLeafTree.buildUpdateQuery(storage);
-        await leafExists ? dbLeafTree.write(`update ${dbLeafTree.table} set ${set} where id='${this.id}'`) : dbLeafTree.write(`insert into ${dbLeafTree.table} (id, docId, position, serviceId, label, text, parentId) values ('${this.id}', '${this.docId}', ${this.position}, '${this.serviceId}', '${this.label.replace(/'/g, "''")}', '${this.text.replace(/'/g, "''")}', '${this.parentId}')`);
-        return this;
-      }
-    };
-    module2.exports = Leaf;
-  }
-});
-
-// ../../modules/documentation/backend/routes.js
-var require_routes2 = __commonJS({
-  "../../modules/documentation/backend/routes.js"(exports2, module2) {
-    "use strict";
-    var express = require("express");
-    var Leaf = require_Leaf();
-    var PromiseB2 = require("bluebird");
-    var router = express.Router();
-    module2.exports = (runeya) => {
-      const { findService } = runeya;
-      router.get("/documentation/tree", async (req, res) => {
-        const service = findService(req.query.serviceId?.toString() || "");
-        const result = await Leaf.getTree(service?.label);
-        return res.send(result);
-      });
-      router.post("/documentation/tree/sort", async (req, res) => {
-        const leafs = await PromiseB2.mapSeries(req.body, async (_leaf, index) => {
-          const leaf = await Leaf.find({ id: _leaf.id });
-          if (!leaf) return;
-          leaf.position = index;
-          await leaf.save();
-          return leaf;
-        });
-        return res.send(leafs);
-      });
-      router.post("/documentation/tree", async (req, res) => {
-        const result = await new Leaf({
-          ...req.body
-        }).save();
-        return res.send(result);
-      });
-      router.post("/documentation/tree/:key", async (req, res) => {
-        const result = await new Leaf({
-          ...req.body,
-          id: req.params.key
-        }).save();
-        return res.send(result);
-      });
-      router.delete("/documentation/tree/:key", async (req, res) => {
-        const result = await Leaf.find({
-          id: req.params.key
-        });
-        if (result) return res.send(await result.remove());
-        return res.send();
-      });
-      return router;
-    };
-  }
-});
-
-// ../../modules/documentation/backend/index.js
-var require_backend3 = __commonJS({
-  "../../modules/documentation/backend/index.js"(exports2, module2) {
-    "use strict";
-    var { readFile } = require("fs/promises");
-    var PromiseB2 = require("bluebird");
-    var pathfs2 = require("path");
-    var Documentation = require_Documentation();
-    var plugin = {
-      enabled: true,
-      name: "Documentation",
-      displayName: "Documentation",
-      description: "Read documentation for a given service",
-      icon: "fas fa-book",
-      // export: Documentation,
-      placements: ["service"],
-      order: 6,
-      routes: require_routes2(),
-      finder: async (search, runeya) => {
-      }
-    };
-    module2.exports = plugin;
-  }
-});
-
-// ../../modules/finder/backend/routes.js
-var require_routes3 = __commonJS({
-  "../../modules/finder/backend/routes.js"(exports2, module2) {
-    "use strict";
-    var express = require("express");
-    var router = express.Router();
-    var PromiseB2 = require("bluebird");
-    function pluginToUrl(plugin) {
-      for (let i = 0; i < plugin.placements.length; i += 1) {
-        const placement = plugin.placements[i];
-        if (typeof placement !== "string") {
-          if (placement.position === "toolbox") {
-            return `/toolbox${placement.goTo?.path || placement.goTo}`;
-          }
-          if (placement.position === "sidebar") {
-            return `${placement.goTo?.path || placement.goTo}`;
-          }
-        }
-      }
-      return "";
-    }
-    var routes = (runeya) => {
-      const {
-        getServices,
-        helpers: { searchString }
-      } = runeya;
-      router.get("/finder/search", async (req, res) => {
-        const search = req.query.q?.toString()?.toUpperCase() || "";
-        const services = getServices().filter((service) => searchString(service?.label, search)).map((service) => ({
-          title: service.label,
-          description: service.description,
-          group: "Service",
-          url: `/stack-single/${service.label}`
-        }));
-        const { plugins } = runeya;
-        const _plugins = (await PromiseB2.map(Object.keys(plugins), (key) => plugins[key]).map(async (plugin) => [
-          ...await plugin?.finder?.(search, runeya)?.catch?.(() => []) || [],
-          ...searchString(plugin.name, search) ? [{
-            title: plugin.displayName || plugin.name,
-            description: plugin.description,
-            group: "Plugin",
-            icon: plugin.icon,
-            url: pluginToUrl(plugin) || ""
-          }] : []
-        ])).flat().filter((a) => a?.url);
-        const result = [
-          ...services,
-          ..._plugins
-        ].filter((a) => a);
-        res.send(result);
-      });
-      return router;
-    };
-    module2.exports = routes;
-  }
-});
-
-// ../../modules/finder/backend/index.js
-var require_backend4 = __commonJS({
-  "../../modules/finder/backend/index.js"(exports2, module2) {
-    "use strict";
-    var commandExists = require("command-exists");
-    var plugin = {
-      enabled: true,
-      name: "Finder",
-      displayName: "Finder",
-      description: "Find all you want inside this app",
-      icon: "fab fa-git-alt",
-      export: null,
-      order: -1,
-      placements: ["global", {
-        position: "sidebar",
-        label: "Finder",
-        icon: "fas fa-search",
-        goTo: { path: "/Finder" },
-        active: "Finder"
-      }],
-      hidden: () => commandExists("git").then(() => false).catch(() => true),
-      routes: require_routes3()
-    };
-    module2.exports = plugin;
-  }
-});
-
-// helpers/exec.js
-var require_exec = __commonJS({
-  "helpers/exec.js"(exports2, module2) {
-    "use strict";
-    var { exec } = require("child_process");
-    module2.exports = {
-      /**
-       * @param {string} cmd
-       * @param {import('child_process').ExecOptions} options
-       * @returns {Promise<string>}
-       */
-      execAsync(cmd, options) {
-        return new Promise((res, rej) => {
-          exec(cmd, options, (err, stdout, stderr) => {
-            if (err) return rej(stderr || err);
-            return res(stdout);
-          });
-        });
-      },
-      /**
-       * @param {string} cmd
-       * @param {import('child_process').ExecOptions} options
-       * @returns {Promise<string>}
-       */
-      execAsyncWithoutErr(cmd, options) {
-        return new Promise((res) => {
-          exec(cmd, options, (err, stdout) => {
-            res(stdout);
-          });
-        });
-      },
-      /**
-       * @param {string} cmd
-       * @param {import('child_process').ExecOptions} options
-       * @returns {Promise<string>}
-       */
-      execAsyncGetError(cmd, options) {
-        return new Promise((res) => {
-          exec(cmd, options, (err, stdout, stderr) => {
-            res(stderr);
-          });
-        });
+      execAsync(cmd, options) {
+        return new Promise((res, rej) => {
+          exec(cmd, options, (err, stdout, stderr) => {
+            if (err) return rej(stderr || err);
+            return res(stdout);
+          });
+        });
+      },
+      /**
+       * @param {string} cmd
+       * @param {import('child_process').ExecOptions} options
+       * @returns {Promise<string>}
+       */
+      execAsyncWithoutErr(cmd, options) {
+        return new Promise((res) => {
+          exec(cmd, options, (err, stdout) => {
+            res(stdout);
+          });
+        });
+      },
+      /**
+       * @param {string} cmd
+       * @param {import('child_process').ExecOptions} options
+       * @returns {Promise<string>}
+       */
+      execAsyncGetError(cmd, options) {
+        return new Promise((res) => {
+          exec(cmd, options, (err, stdout, stderr) => {
+            res(stderr);
+          });
+        });
       }
     };
   }
@@ -1004,16 +654,16 @@ var require_src2 = __commonJS({
 var require_Git = __commonJS({
   "../../modules/git/backend/Git.js"(exports2, module2) {
     "use strict";
-    var { existsSync: existsSync2 } = require("fs");
-    var pathfs2 = require("path");
+    var { existsSync } = require("fs");
+    var pathfs = require("path");
     var { execAsync, execAsyncWithoutErr } = require_exec();
     var HTTPError = require_src2();
     var Git = (runeya) => {
       const { findService } = runeya;
       const searchGit = (path) => {
-        if (existsSync2(pathfs2.resolve(path, ".git"))) return path;
-        const parentPath = pathfs2.resolve(path, "..");
-        if (parentPath === pathfs2.resolve("/")) return null;
+        if (existsSync(pathfs.resolve(path, ".git"))) return path;
+        const parentPath = pathfs.resolve(path, "..");
+        if (parentPath === pathfs.resolve("/")) return null;
         return searchGit(parentPath);
       };
       const getGitRootPath = (service) => searchGit(service.getRootPath());
@@ -1022,7 +672,7 @@ var require_Git = __commonJS({
         if (!service.git) throw new Error(`Git Error - ${service?.label}: Git option not set`);
         const path = getGitRootPath(service);
         if (!path) return false;
-        if (!existsSync2(path)) return false;
+        if (!existsSync(path)) return false;
         return true;
       }
       return {
@@ -1650,11 +1300,11 @@ var require_stringTransformer_helper = __commonJS({
 var require_Npm = __commonJS({
   "../../modules/npm/backend/Npm.js"(exports2, module2) {
     "use strict";
-    var pathfs2 = require("path");
+    var pathfs = require("path");
     var { execAsync } = require_exec();
     var { readFile } = require("fs/promises");
     var { replaceEnvs } = require_stringTransformer_helper();
-    var { existsSync: existsSync2 } = require("fs");
+    var { existsSync } = require("fs");
     var Npm = class {
       /** @param {import('@runeya/servers-server/models/Service')} service */
       constructor(service) {
@@ -1662,7 +1312,7 @@ var require_Npm = __commonJS({
       }
       async isNpm(path) {
         if (path) {
-          return existsSync2(pathfs2.resolve(path?.toString(), "package.json"));
+          return existsSync(pathfs.resolve(path?.toString(), "package.json"));
         }
         return null;
       }
@@ -1674,13 +1324,13 @@ var require_Npm = __commonJS({
       }
       async packageJSON(path) {
         if (path) {
-          return JSON.parse(await readFile(pathfs2.resolve(path?.toString(), "package.json"), "utf-8"));
+          return JSON.parse(await readFile(pathfs.resolve(path?.toString(), "package.json"), "utf-8"));
         }
         return {};
       }
       async packageLock(path) {
         if (path) {
-          return JSON.parse(await readFile(pathfs2.resolve(path?.toString(), "package-lock.json"), "utf-8")).catch((err) => {
+          return JSON.parse(await readFile(pathfs.resolve(path?.toString(), "package-lock.json"), "utf-8")).catch((err) => {
             console.error(err);
             return {};
           });
@@ -2109,7 +1759,7 @@ var require_src6 = __commonJS({
     require("express-async-errors");
     var express = require("express");
     var cors = require("cors");
-    var pathfs2 = require("path");
+    var pathfs = require("path");
     var fs = require("fs");
     var healthCheck = require_src3();
     var helmet = require("helmet").default;
@@ -2179,7 +1829,7 @@ var require_src6 = __commonJS({
         authApi = (app) => {
         }
       }) {
-        const pkgJSONPath = pathfs2.resolve(baseUrl, "package.json");
+        const pkgJSONPath = pathfs.resolve(baseUrl, "package.json");
         const isPkgJSONExists = fs.existsSync(pkgJSONPath);
         const pkgJSON = isPkgJSONExists ? require(pkgJSONPath) : { name: "unknown", version: "unknown" };
         const appVersion = pkgJSON.version;
@@ -2272,9 +1922,9 @@ var require_routes10 = __commonJS({
     var RED = require("node-red");
     var compressing = require("compressing");
     var router = express.Router();
-    var pathfs2 = require("path");
-    var { existsSync: existsSync2 } = require("fs");
-    var { rm: rm2, readFile, writeFile, mkdir: mkdir2, readdir } = require("fs/promises");
+    var pathfs = require("path");
+    var { existsSync } = require("fs");
+    var { rm, readFile, writeFile, mkdir, readdir } = require("fs/promises");
     var ports = require_ports();
     var { execAsync } = require_exec();
     var EncryptionKey = require_EncryptionKey();
@@ -2282,8 +1932,8 @@ var require_routes10 = __commonJS({
     var { v4 } = require("uuid");
     module2.exports = (Stack) => {
       getServer().then(async (server) => {
-        const userDir = pathfs2.resolve(Stack.getRootPath(), "nodered");
-        if (!existsSync2(userDir)) await mkdir2(userDir, { recursive: true });
+        const userDir = pathfs.resolve(Stack.getRootPath(), "nodered");
+        if (!existsSync(userDir)) await mkdir(userDir, { recursive: true });
         const settings = {
           httpAdminRoot: "/red",
           httpNodeRoot: "/node-red",
@@ -2305,25 +1955,25 @@ var require_routes10 = __commonJS({
         router.use(settings.httpNodeRoot, RED.httpNode);
         const moduleName = "node-red-contrib-runeya";
         const moduleNameLegacy = "node-red-contrib-stack-monitor";
-        const modulePath = pathfs2.resolve(userDir, "node_modules", moduleName);
-        const localNodeModuleTarPath = pathfs2.resolve(__dirname, `${moduleName}.tar`);
-        const packageJSONPath = pathfs2.resolve(userDir, "package.json");
-        if (existsSync2(pathfs2.resolve(userDir, "node_modules", moduleNameLegacy))) {
-          await rm2(pathfs2.resolve(userDir, "node_modules", moduleNameLegacy), { recursive: true, force: true });
+        const modulePath = pathfs.resolve(userDir, "node_modules", moduleName);
+        const localNodeModuleTarPath = pathfs.resolve(__dirname, `${moduleName}.tar`);
+        const packageJSONPath = pathfs.resolve(userDir, "package.json");
+        if (existsSync(pathfs.resolve(userDir, "node_modules", moduleNameLegacy))) {
+          await rm(pathfs.resolve(userDir, "node_modules", moduleNameLegacy), { recursive: true, force: true });
           await execAsync("npm uninstall node-red-contrib-stack-monitor", { cwd: userDir });
         }
-        if (existsSync2(modulePath)) {
+        if (existsSync(modulePath)) {
           console.log(moduleName, "found, delete it before start nodered");
-          await rm2(modulePath, { recursive: true, force: true });
+          await rm(modulePath, { recursive: true, force: true });
           await execAsync("npm uninstall node-red-contrib-runeya", { cwd: userDir });
         }
         await PromiseB2.map(await readdir(userDir), async (file) => {
           if (file.startsWith(`node-red-contrib-runeya-`) && file.endsWith(".tgz")) {
-            await rm2(pathfs2.resolve(userDir, file));
+            await rm(pathfs.resolve(userDir, file));
           }
         });
         let buffer;
-        if (existsSync2(localNodeModuleTarPath)) {
+        if (existsSync(localNodeModuleTarPath)) {
           console.log(`Read ${moduleName} from local tar`);
           buffer = await readFile(localNodeModuleTarPath);
         } else {
@@ -2338,7 +1988,7 @@ var require_routes10 = __commonJS({
           var stream2buffer = stream2buffer2;
           console.log(`Build ${moduleName} from dir`);
           const stream = new compressing.tar.Stream();
-          stream.addEntry(pathfs2.resolve(__dirname, "./nodes"), { ignoreBase: true, relativePath: "package" });
+          stream.addEntry(pathfs.resolve(__dirname, "./nodes"), { ignoreBase: true, relativePath: "package" });
           buffer = await stream2buffer2(stream);
         }
         let packageJSON = {
@@ -2348,16 +1998,16 @@ var require_routes10 = __commonJS({
           "private": true,
           "dependencies": {}
         };
-        if (existsSync2(packageJSONPath)) {
+        if (existsSync(packageJSONPath)) {
           Object.assign(packageJSON, JSON.parse(await readFile(packageJSONPath, "utf-8")));
         }
         const tgzFileName = `${moduleName}.tgz`;
         packageJSON.dependencies[moduleName] = `file:${tgzFileName}`;
-        const pathToTgz = pathfs2.resolve(userDir, `${tgzFileName}`);
+        const pathToTgz = pathfs.resolve(userDir, `${tgzFileName}`);
         await writeFile(pathToTgz, buffer);
         await writeFile(packageJSONPath, JSON.stringify(packageJSON, null, 2), "utf-8");
         await execAsync("npm i", { cwd: userDir });
-        await writeFile(pathfs2.resolve(userDir, ".gitignore"), `*
+        await writeFile(pathfs.resolve(userDir, ".gitignore"), `*
 !flow.json
 !flow_cred.json
 !package.json
@@ -2513,7 +2163,7 @@ var require_Environment = __commonJS({
     var PromiseB2 = require("bluebird");
     var { cloneDeep, merge, over } = require("lodash");
     var dbs2 = require_dbs();
-    var { existsSync: existsSync2 } = require("fs");
+    var { existsSync } = require("fs");
     var Environment = class _Environment {
       /**
        * @param {import('@runeya/common-typings').NonFunctionProperties<Environment>} environment
@@ -2530,7 +2180,7 @@ var require_Environment = __commonJS({
       static async load(label, Stack) {
         const environmentDB = await dbs2.getDb(`envs/${label}`).read();
         const overridesDB = dbs2.getDb(`overrides/${label}-environment`);
-        if (!existsSync2(await overridesDB.getPath())) await new _Environment(environmentDB).save();
+        if (!existsSync(await overridesDB.getPath())) await new _Environment(environmentDB).save();
         const overrides = await dbs2.getDb(`overrides/${label}-environment`).read();
         merge(environmentDB?.envs || {}, overrides?.envs || {});
         return new _Environment(environmentDB, Stack);
@@ -2758,13 +2408,13 @@ var require_Service = __commonJS({
     var PromiseB2 = require("bluebird");
     var dayjs = require("dayjs");
     var { v4 } = require("uuid");
-    var { existsSync: existsSync2, readFileSync } = require("fs");
+    var { existsSync, readFileSync } = require("fs");
     var kill = require("tree-kill");
     var axios = require("axios").default;
-    var pathfs2 = require("path");
+    var pathfs = require("path");
     var net = require("net");
     var { sockets: sockets2 } = require_src();
-    var { mkdir: mkdir2, writeFile } = require("fs/promises");
+    var { mkdir, writeFile } = require("fs/promises");
     var { cloneDeep, over } = require("lodash");
     var CreateInterface = require_readline();
     var { stripAnsi, ansiconvert, unescapeAnsi } = require_ansiconvert();
@@ -2896,8 +2546,8 @@ var require_Service = __commonJS({
       return new Service(await dbs2.getDb(`services/${label}`).read(), Stack);
     };
     Service.prototype.loadCustomEnv = function(path2) {
-      const dotEnvPath = pathfs2.resolve(path2, ".env");
-      if (existsSync2(dotEnvPath) && readFileSync(dotEnvPath, { encoding: "utf-8" }).trim()) {
+      const dotEnvPath = pathfs.resolve(path2, ".env");
+      if (existsSync(dotEnvPath) && readFileSync(dotEnvPath, { encoding: "utf-8" }).trim()) {
         console.log(`! A .env will override your ${this.label} service !`);
         return require("dotenv").parse(readFileSync(dotEnvPath, "utf-8"));
       }
@@ -3051,7 +2701,7 @@ var require_Service = __commonJS({
         this.crashed = false;
         this.exited = false;
         let { cmd, args: args2, options } = this.container.enabled ? await this.parseIncomingCommandDocker(command) : await this.parseIncomingCommand(command);
-        if (!existsSync2(options.cwd)) {
+        if (!existsSync(options.cwd)) {
           this.crashed = true;
           this.exited = true;
           const launchMessage2 = {
@@ -3315,7 +2965,7 @@ var require_Service = __commonJS({
         "sh",
         `-c '${spawnCmd} ${spawnArgs.join(" ")}'`
       ];
-      const cwd = pathfs2.resolve(replaceEnvs(spawnOptions.cwd || this.getRootPath() || "."));
+      const cwd = pathfs.resolve(replaceEnvs(spawnOptions.cwd || this.getRootPath() || "."));
       const options = {
         cwd,
         shell: isWindows ? process.env.ComSpec : "/bin/sh"
@@ -3332,7 +2982,7 @@ var require_Service = __commonJS({
         cmd = currentAlias?.cmd || cmd;
         args2 = [...currentAlias?.args || [], ...args2];
       }
-      const cwd = pathfs2.resolve(replaceEnvs(spawnOptions.cwd || this.getRootPath() || "."));
+      const cwd = pathfs.resolve(replaceEnvs(spawnOptions.cwd || this.getRootPath() || "."));
       const options = {
         ...spawnOptions,
         cwd,
@@ -3349,19 +2999,19 @@ var require_Service = __commonJS({
       return { cmd, args: args2, options };
     };
     function replaceHome(str) {
-      return str.startsWith("~") ? pathfs2.resolve(os.homedir(), str.replace("~/", "")) : pathfs2.resolve(str);
+      return str.startsWith("~") ? pathfs.resolve(os.homedir(), str.replace("~/", "")) : pathfs.resolve(str);
     }
     Service.prototype.getDockerVolumesArgs = async function() {
       const internalVolumeRootPath = replaceHome(this.container.sharedVolume);
       const volumesCmd = this.container.volumes.map((v) => {
         let [external, internal] = v.split(":");
-        if (external) external = pathfs2.resolve(replaceHome(replaceEnvs(external)));
-        if (internal) internal = pathfs2.resolve(replaceHome(replaceEnvs(internal)));
+        if (external) external = pathfs.resolve(replaceHome(replaceEnvs(external)));
+        if (internal) internal = pathfs.resolve(replaceHome(replaceEnvs(internal)));
         return ["-v", `"${external}:${internal || external}"`];
       });
       volumesCmd.push(...await PromiseB2.map(this.container.ignoreVolumes, async (ignoredVolume) => {
-        const volumePath = pathfs2.join(internalVolumeRootPath, `ignored-volume-${humanStringToKey(this.label)}`, ignoredVolume);
-        if (!existsSync2(volumePath)) await mkdir2(volumePath, { recursive: true });
+        const volumePath = pathfs.join(internalVolumeRootPath, `ignored-volume-${humanStringToKey(this.label)}`, ignoredVolume);
+        if (!existsSync(volumePath)) await mkdir(volumePath, { recursive: true });
         return ["-v", `"${volumePath}:${ignoredVolume}"`];
       }).filter((f) => !!f?.length));
       return volumesCmd.flat(1);
@@ -3383,8 +3033,8 @@ var require_Service = __commonJS({
     };
     Service.prototype.launchDockerBuild = async function({ isMainProcess }) {
       const internalVolumeRootPath = replaceHome(this.container.sharedVolume);
-      const dockerFilePath = pathfs2.resolve(internalVolumeRootPath, `Dockerfile.${this.container.name}`);
-      const dockerContextPath = pathfs2.resolve(internalVolumeRootPath, ".empty-context");
+      const dockerFilePath = pathfs.resolve(internalVolumeRootPath, `Dockerfile.${this.container.name}`);
+      const dockerContextPath = pathfs.resolve(internalVolumeRootPath, ".empty-context");
       const command = {
         spwanCmd: "docker",
         spawnArgs: ["build", "-f", dockerFilePath, "-t", this.container?.name || "", dockerContextPath],
@@ -3467,11 +3117,11 @@ var require_Service = __commonJS({
       isMainProcess
     }) {
       const internalVolumeRootPath = replaceHome(this.container.sharedVolume);
-      const dockerFilePath = pathfs2.resolve(internalVolumeRootPath, `Dockerfile.${this.container.name}`);
-      const dockerIgnoreFilePath = pathfs2.resolve(internalVolumeRootPath, ".dockerignore");
-      const dockerContextPath = pathfs2.resolve(internalVolumeRootPath, ".empty-context");
-      if (!existsSync2(internalVolumeRootPath)) await mkdir2(internalVolumeRootPath, { recursive: true });
-      if (!existsSync2(dockerContextPath)) await mkdir2(dockerContextPath, { recursive: true });
+      const dockerFilePath = pathfs.resolve(internalVolumeRootPath, `Dockerfile.${this.container.name}`);
+      const dockerIgnoreFilePath = pathfs.resolve(internalVolumeRootPath, ".dockerignore");
+      const dockerContextPath = pathfs.resolve(internalVolumeRootPath, ".empty-context");
+      if (!existsSync(internalVolumeRootPath)) await mkdir(internalVolumeRootPath, { recursive: true });
+      if (!existsSync(dockerContextPath)) await mkdir(dockerContextPath, { recursive: true });
       await writeFile(dockerFilePath, `${this.container.build || ""}`);
       await writeFile(dockerIgnoreFilePath, "Dockerfile.*".trim(), "utf-8");
       await this.launchDockerBuild({ isMainProcess });
@@ -3531,268 +3181,676 @@ var require_exportedHelpers = __commonJS({
       searchString(str, search) {
         return str?.toUpperCase()?.includes(search);
       }
-    };
-  }
-});
-
-// helpers/version.js
-var require_version = __commonJS({
-  "helpers/version.js"(exports2, module2) {
-    "use strict";
-    var { existsSync: existsSync2, readFileSync } = require("fs");
-    var path = require("path");
-    var file = {
-      version: "0.0.0"
-    };
-    if (existsSync2(path.resolve(__dirname, "./package.json"))) {
-      file.version = JSON.parse(readFileSync(path.resolve(__dirname, "./package.json"), { encoding: "utf-8" })).version;
-    } else if (existsSync2(path.resolve(__dirname, "../package.json"))) {
-      file.version = JSON.parse(readFileSync(path.resolve(__dirname, "../package.json"), { encoding: "utf-8" })).version;
-    } else if (existsSync2(path.resolve(__dirname, "../../../lerna.json"))) {
-      file.version = JSON.parse(readFileSync(path.resolve(__dirname, "../../../lerna.json"), { encoding: "utf-8" })).version;
-    }
-    module2.exports = {
-      version: file.version
-    };
-  }
-});
-
-// models/saves.js
-var require_saves = __commonJS({
-  "models/saves.js"(exports2, module2) {
-    "use strict";
-    var pathfs2 = require("path");
-    var homedir = require("os").homedir();
-    var {
-      existsSync: existsSync2,
-      mkdirSync,
-      writeFileSync,
-      readFileSync
-    } = require("fs");
-    var confDir = pathfs2.resolve(homedir, ".runeya");
-    function getSave(file, initialData, options = {}) {
-      if (!existsSync2(confDir)) mkdirSync(confDir);
-      const dataConfPath = pathfs2.resolve(confDir, file);
-      if (!existsSync2(dataConfPath)) writeFileSync(dataConfPath, JSON.stringify(initialData), "utf-8");
-      const data = JSON.parse(readFileSync(dataConfPath, "utf-8"));
-      options?.afterGet?.(data);
-      return {
-        /** @type {T} */
-        data,
-        save() {
-          options?.beforeSave?.(data);
-          writeFileSync(dataConfPath, JSON.stringify(data), "utf-8");
-        }
-      };
-    }
-    module2.exports = getSave;
+    };
+  }
+});
+
+// helpers/version.js
+var require_version = __commonJS({
+  "helpers/version.js"(exports2, module2) {
+    "use strict";
+    var { existsSync, readFileSync } = require("fs");
+    var path = require("path");
+    var file = {
+      version: "0.0.0"
+    };
+    if (existsSync(path.resolve(__dirname, "./package.json"))) {
+      file.version = JSON.parse(readFileSync(path.resolve(__dirname, "./package.json"), { encoding: "utf-8" })).version;
+    } else if (existsSync(path.resolve(__dirname, "../package.json"))) {
+      file.version = JSON.parse(readFileSync(path.resolve(__dirname, "../package.json"), { encoding: "utf-8" })).version;
+    } else if (existsSync(path.resolve(__dirname, "../../../lerna.json"))) {
+      file.version = JSON.parse(readFileSync(path.resolve(__dirname, "../../../lerna.json"), { encoding: "utf-8" })).version;
+    }
+    module2.exports = {
+      version: file.version
+    };
+  }
+});
+
+// models/saves.js
+var require_saves = __commonJS({
+  "models/saves.js"(exports2, module2) {
+    "use strict";
+    var pathfs = require("path");
+    var homedir = require("os").homedir();
+    var {
+      existsSync,
+      mkdirSync,
+      writeFileSync,
+      readFileSync
+    } = require("fs");
+    var confDir = pathfs.resolve(homedir, ".runeya");
+    function getSave(file, initialData, options = {}) {
+      if (!existsSync(confDir)) mkdirSync(confDir);
+      const dataConfPath = pathfs.resolve(confDir, file);
+      if (!existsSync(dataConfPath)) writeFileSync(dataConfPath, JSON.stringify(initialData), "utf-8");
+      const data = JSON.parse(readFileSync(dataConfPath, "utf-8"));
+      options?.afterGet?.(data);
+      return {
+        /** @type {T} */
+        data,
+        save() {
+          options?.beforeSave?.(data);
+          writeFileSync(dataConfPath, JSON.stringify(data), "utf-8");
+        }
+      };
+    }
+    module2.exports = getSave;
+  }
+});
+
+// models/stack.js
+var require_stack = __commonJS({
+  "models/stack.js"(exports2, module2) {
+    "use strict";
+    var { sockets: sockets2 } = require_src();
+    var plugins = require_plugins();
+    var PromiseB2 = require("bluebird");
+    var Service = require_Service();
+    var ports = require_ports();
+    var dbs2 = require_dbs();
+    var EnvironmentModel = require_Environment();
+    var EncryptionKey = require_EncryptionKey();
+    var CustomObservable = require_CustomObservable();
+    var args2 = require_args();
+    var { existsSync, mkdirSync } = require("fs");
+    var { rename, cp, rmdir, rm } = require("fs/promises");
+    var pathfs = require("path");
+    var { default: axios } = require("axios");
+    function Stack(stack) {
+      this.onServerLauch = new CustomObservable();
+      return (async () => {
+        this.watchFiles = stack.watchFiles || [];
+        this.logParsers = stack.logParsers || [];
+        this.monorepo = stack.monorepo || false;
+        this.themes = stack.themes || {};
+        this.environments = stack.environments ? stack.environments.map((env) => new EnvironmentModel(env)) : [];
+        this.documentation = stack.documentation;
+        this.services = await PromiseB2.map(stack.services || [], (service) => new Service(
+          service,
+          /** @type {StackWithPlugins} */
+          Stack
+        ));
+        this.helpers = require_exportedHelpers();
+        return this;
+      })();
+    }
+    Stack.currentStack = null;
+    Stack.currentWatches = [];
+    Stack.currentEnvironment = null;
+    Stack.Socket = sockets2;
+    Stack.plugins = plugins;
+    Stack.version = require_version().version || "";
+    Stack.url = `http://localhost:${ports.http}`;
+    Stack.port = +ports.http;
+    Stack.parsers = {
+      links: require_link(),
+      jsons: require_json(),
+      debug: require_debug()
+    };
+    Stack.helpers = require_exportedHelpers();
+    Stack.getSave = require_saves();
+    Stack.prototype.enable = async function(servicesLabelSelected) {
+      const services = this.getServices();
+      await PromiseB2.map(servicesLabelSelected, (serviceConf) => {
+        const service = services.find((service2) => serviceConf.label === service2.label);
+        if (!service) return null;
+        const hasChanged = serviceConf.enabled !== service.enabled;
+        if (hasChanged) {
+          if (serviceConf.enabled) {
+            service.enable();
+            return service.launch();
+          }
+          service.disable();
+          return service.kill();
+        }
+        return null;
+      });
+    };
+    Stack.restart = async function() {
+      await PromiseB2.map(this.getEnabledServices(), (service) => service.restart());
+    };
+    Stack.kill = async function() {
+      await PromiseB2.map(this.getEnabledServices(), (service) => service.kill());
+    };
+    Stack.getCurrentEnvironment = function() {
+      return Stack.currentEnvironment;
+    };
+    Stack.prototype.toStorage = function() {
+      return {
+        watchFiles: this.watchFiles,
+        themes: this.themes,
+        services: this.services.map((s) => s.toStorage())
+      };
+    };
+    Stack.getRootPath = () => {
+      const rootPath = pathfs.resolve(args2.rootPath, ".runeya");
+      return rootPath;
+    };
+    Stack.parse = async function() {
+      const dbsRootPath = await dbs2.getDbs("services");
+      let services = [];
+      let environments = [];
+      try {
+        services = await PromiseB2.map(dbsRootPath, (id) => Service.load(id, Stack));
+        environments = await EnvironmentModel.all();
+      } catch (error) {
+        console.error(error);
+        this.Socket.emit("system:wrongKey");
+      }
+      return new Stack({
+        environments,
+        services
+      });
+    };
+    Stack.prototype.launch = async function() {
+      await PromiseB2.map(this.getServices(), (microservice) => {
+        if (microservice.enabled) {
+          return microservice.launch();
+        }
+        return microservice.kill();
+      });
+    };
+    Stack.getStack = function() {
+      return Stack.currentStack;
+    };
+    Stack.getServices = function() {
+      return Stack.currentStack?.services || [];
+    };
+    Stack.deleteService = async function(label) {
+      if (!Stack.currentStack) return;
+      const service = this.findService(label);
+      Stack.currentStack.services = Stack.currentStack.services.filter((a) => a.label !== label);
+      await service.delete();
+    };
+    Stack.prototype.getServices = function() {
+      return Stack.getServices();
+    };
+    Stack.getAxios = function() {
+      return axios.create({ baseURL: this.url });
+    };
+    Stack.getEnabledServices = function() {
+      return Stack.getServices().filter((s) => s.enabled);
+    };
+    Stack.prototype.getEnabledServices = function() {
+      return Stack.getEnabledServices();
+    };
+    Stack.prototype.exportInApi = function() {
+      const res = { ...this };
+      res.services = res.services?.map((s) => s.exportInApi());
+      return res;
+    };
+    Stack.findService = function(serviceLabel) {
+      return Stack.getServices().filter((s) => s.label === serviceLabel)[0];
+    };
+    Stack.prototype.findService = function(serviceLabel) {
+      return Stack.findService(serviceLabel);
+    };
+    Stack.selectConf = async function() {
+      await EncryptionKey.init();
+      if (!EncryptionKey.encryptionKey) {
+        await EncryptionKey.saveKey(await EncryptionKey.generateKey());
+      }
+      Stack.currentStack = await this.parse();
+      Stack.currentEnvironment = args2.e || process.env.RUNEYA_DEFAULT_ENVIRONMENT ? Stack.currentStack.environments.find((env) => env.label === args2.e?.toString() || env.label === process.env.RUNEYA_DEFAULT_ENVIRONMENT) || null : Stack.currentStack.environments.find((env) => env.default) || null;
+      if (process.env.RUNEYA_SERVICES) {
+        process.env.RUNEYA_SERVICES.split(",").forEach((serviceLabel) => {
+          const service = Stack.findService(serviceLabel);
+          if (service) service.enable();
+        });
+      }
+      return sockets2.emit("stack:selectConf");
+    };
+    Stack.prototype.changeEnvironment = async function(envLabel) {
+      const environment = await EnvironmentModel.find(envLabel);
+      if (environment) {
+        Stack.currentEnvironment = environment;
+        Stack.getServices().forEach((service) => {
+          if (!service.envs[envLabel]) {
+            service.envs[envLabel] = {};
+          }
+        });
+        const enabledServices = Stack.getEnabledServices();
+        await Stack.kill();
+        enabledServices.forEach((s) => {
+          s.enabled = true;
+          s.store = [];
+        });
+        await Stack.getStack()?.launch();
+      } else {
+        throw new Error("Environment not found");
+      }
+    };
+    Stack.stopWatchers = function() {
+      Stack.currentWatches.forEach((currentWatch) => currentWatch.close());
+    };
+    var pluginsToLoad = (
+      /** @type {(keyof typeof plugins)[]} */
+      Object.keys(plugins).reduce(
+        (p, key) => {
+          const plugin = plugins[key];
+          if (plugin.export) {
+            p[key] = typeof plugin.export === "function" && !/^\s*class\s+/.test(plugin.export.toString()) ? plugin.export(
+              /** @type {StackWithPlugins} */
+              Stack
+            ) : plugin.export;
+          }
+          return p;
+        },
+        /** @type {OmitNever<typeof plugins>} */
+        {}
+      )
+    );
+    module2.exports = /** @type {StackWithPlugins} */
+    Object.assign(Stack, pluginsToLoad);
+  }
+});
+
+// models/EncryptionKey.js
+var require_EncryptionKey = __commonJS({
+  "models/EncryptionKey.js"(exports2, module2) {
+    "use strict";
+    var { existsSync } = require("fs");
+    var path = require("path");
+    var { writeFile, readFile, appendFile } = require("fs/promises");
+    var { randomUUID: randomUUID2 } = require("crypto");
+    var dbs2 = require_dbs();
+    var { generateKey, encrypt, decrypt } = require_crypto();
+    var reencryptNodered = require_reencrypt_nodered();
+    var pathfs = require("path");
+    var args2 = require_args();
+    var _EncryptionKey_instances, getDb_fn;
+    var EncryptionKey = class {
+      constructor() {
+        __privateAdd(this, _EncryptionKey_instances);
+        this.encryptionKey = "";
+      }
+      async init() {
+        this.encryptionKey = (await __privateMethod(this, _EncryptionKey_instances, getDb_fn).call(this).read()).encryptionKey;
+      }
+      async update() {
+        return __privateMethod(this, _EncryptionKey_instances, getDb_fn).call(this).write(this.toStorage());
+      }
+      toStorage() {
+        return {
+          encryptionKey: this.encryptionKey
+        };
+      }
+      async generateKey() {
+        return generateKey();
+      }
+      async testKey(encryptionKey) {
+        try {
+          const variable = randomUUID2();
+          const result = await encrypt(variable, { encryptionKey });
+          const decrypted = await decrypt(result, { encryptionKey });
+          if (decrypted === variable) return true;
+          return false;
+        } catch (error) {
+          console.error(error);
+          return false;
+        }
+      }
+      async saveKey(key, { noReload } = { noReload: false }) {
+        if (!await this.testKey(key)) throw new Error("Key not valid");
+        try {
+          const envSample = (await dbs2.getDbs("envs"))[0];
+          if (envSample) await dbs2.getDb(`envs/${envSample}`).read();
+          if (this.encryptionKey) {
+            await reencryptNodered(this.encryptionKey, key, pathfs.resolve(require_stack().getRootPath(), "nodered/flow_cred.json"));
+            await dbs2.reencrypt(this.encryptionKey, key);
+          }
+          ;
+        } catch (error) {
+          console.error(error);
+        }
+        const shouldRestart = this.encryptionKey !== key;
+        this.encryptionKey = key;
+        await this.update();
+        if (!noReload) {
+          await require_stack().selectConf();
+        }
+        if (shouldRestart) {
+          console.log("Restart...");
+          require("child_process").spawn(process.argv[0], process.argv.slice(1), {
+            cwd: args2.initialCwd,
+            detached: true,
+            stdio: "inherit"
+          }).unref();
+          process.exit(0);
+        }
+        return key;
+      }
+    };
+    _EncryptionKey_instances = new WeakSet();
+    getDb_fn = function() {
+      return dbs2.getDb("encryption-key", { encrypted: false });
+    };
+    module2.exports = new EncryptionKey();
+  }
+});
+
+// helpers/crypto.js
+var require_crypto = __commonJS({
+  "helpers/crypto.js"(exports2, module2) {
+    "use strict";
+    var _sodium = require("libsodium-wrappers");
+    var crypto = require("crypto");
+    var { sockets: sockets2 } = require_src();
+    var conflictStorage = require_conflictStorage();
+    var path = require("path");
+    module2.exports.generateKey = async () => {
+      await _sodium.ready;
+      const sodium = _sodium;
+      const key = sodium.crypto_aead_aegis256_keygen();
+      return sodium.to_base64(key);
+    };
+    module2.exports.encrypt = async (data, { additionnalNonce = "", encryptionKey = "" } = {}) => {
+      await _sodium.ready;
+      const sodium = _sodium;
+      if (!encryptionKey) encryptionKey = require_EncryptionKey().encryptionKey;
+      const key = sodium.from_base64(encryptionKey);
+      if (!key || key.length !== sodium.crypto_secretbox_KEYBYTES) {
+        throw new Error("Invalid encryption key length");
+      }
+      let nonce;
+      if (additionnalNonce) {
+        const combinedHash = crypto.createHash("blake2b512").update(data + additionnalNonce).digest();
+        nonce = combinedHash.slice(0, sodium.crypto_secretbox_NONCEBYTES);
+      } else {
+        nonce = sodium.randombytes_buf(sodium.crypto_secretbox_NONCEBYTES);
+      }
+      const dataStr = typeof data === "string" ? data : String(data);
+      const dataArray = new TextEncoder().encode(dataStr);
+      const ciphertext = sodium.crypto_secretbox_easy(dataArray, nonce, key);
+      return Buffer.concat([
+        Buffer.from(nonce.buffer, nonce.byteOffset, nonce.byteLength),
+        Buffer.from(ciphertext.buffer, ciphertext.byteOffset, ciphertext.byteLength)
+      ]).toString("base64");
+    };
+    module2.exports.decryptFile = async (encryptedData, options = {}, filePath) => {
+      if (typeof encryptedData === "string" && (encryptedData.includes("<<<<<<< HEAD") || encryptedData.includes("=======") || encryptedData.includes(">>>>>>>"))) {
+        return await handleGitConflict(encryptedData, options, filePath);
+      }
+      return await module2.exports.decrypt(encryptedData, options);
+    };
+    module2.exports.decrypt = async (encryptedData, { additionnalNonce = "", encryptionKey = "" } = {}) => {
+      if (typeof encryptedData === "string" && (encryptedData.includes("<<<<<<< HEAD") || encryptedData.includes("=======") || encryptedData.includes(">>>>>>>"))) {
+        return await handleGitConflict(encryptedData, { additionnalNonce, encryptionKey });
+      }
+      await _sodium.ready;
+      const sodium = _sodium;
+      if (!encryptionKey) encryptionKey = require_EncryptionKey().encryptionKey;
+      const key = sodium.from_base64(encryptionKey);
+      if (!key || key.length !== sodium.crypto_secretbox_KEYBYTES) {
+        throw new Error("Invalid decryption key length");
+      }
+      const encryptedBuffer = Buffer.from(encryptedData, "base64");
+      const nonce = encryptedBuffer.slice(0, sodium.crypto_secretbox_NONCEBYTES);
+      const ciphertext = encryptedBuffer.slice(sodium.crypto_secretbox_NONCEBYTES);
+      let decrypted;
+      try {
+        const ciphertextArray = new Uint8Array(ciphertext);
+        const nonceArray = new Uint8Array(nonce);
+        decrypted = sodium.crypto_secretbox_open_easy(ciphertextArray, nonceArray, key);
+      } catch (error) {
+        throw new Error("Decryption failed");
+      }
+      if (!decrypted) {
+        throw new Error("Decryption failed");
+      }
+      return Buffer.from(decrypted).toString("utf-8");
+    };
+    async function handleGitConflict(conflictedData, options, filePath) {
+      const headMatch = conflictedData.match(/<<<<<<< HEAD\r?\n([\s\S]*?)\r?\n=======\r?\n([\s\S]*?)\r?\n>>>>>>>.*/);
+      if (!headMatch) {
+        throw new Error("Git conflict detected but could not be properly parsed");
+      }
+      try {
+        const ourVersion = headMatch[1];
+        const theirVersion = headMatch[2];
+        let ourDecrypted = "";
+        let theirDecrypted = "";
+        try {
+          ourDecrypted = await module2.exports.decrypt(ourVersion, options);
+        } catch (err) {
+          const errorMessage = err instanceof Error ? err.message : String(err);
+          ourDecrypted = `[ERROR DECRYPTING OUR VERSION: ${errorMessage}]`;
+        }
+        try {
+          theirDecrypted = await module2.exports.decrypt(theirVersion, options);
+        } catch (err) {
+          const errorMessage = err instanceof Error ? err.message : String(err);
+          theirDecrypted = `[ERROR DECRYPTING THEIR VERSION: ${errorMessage}]`;
+        }
+        const conflictData = {
+          original: conflictedData,
+          ourVersion: ourDecrypted,
+          theirVersion: theirDecrypted,
+          filePath: filePath || null,
+          filename: filePath ? path.basename(filePath) : null
+        };
+        const conflictId = conflictStorage.storeConflict(conflictData);
+        conflictData.id = conflictId;
+        sockets2.emit("crypto:conflict", conflictData);
+        return `${JSON.stringify({
+          ourVersion: ourDecrypted,
+          theirVersion: theirDecrypted
+        })}`;
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error("Error handling git conflict:", errorMessage);
+        throw new Error(`Git conflict detected, but failed to process: ${errorMessage}`);
+      }
+    }
+  }
+});
+
+// helpers/dbs.js
+var require_dbs = __commonJS({
+  "helpers/dbs.js"(exports2, module2) {
+    "use strict";
+    var {
+      existsSync,
+      mkdirSync,
+      writeFileSync,
+      readFileSync,
+      unlinkSync
+    } = require("fs");
+    var pathfs = require("path");
+    var {
+      readdir,
+      mkdir,
+      writeFile,
+      readFile,
+      unlink
+    } = require("fs/promises");
+    var { fdir } = require("fdir");
+    var PromiseB2 = require("bluebird");
+    var { sockets: sockets2 } = require_src();
+    var args2 = require_args();
+    var { encrypt, decrypt, decryptFile } = require_crypto();
+    var alasql = require("alasql");
+    module2.exports = new class {
+      constructor() {
+        __publicField(this, "cache", {});
+      }
+      getRootPath() {
+        const rootPath = pathfs.resolve(args2.rootPath, ".runeya/dbs");
+        if (!existsSync(rootPath)) mkdirSync(rootPath, { recursive: true });
+        return rootPath;
+      }
+      async getDbs(namespace = "") {
+        const pathToDbs = pathfs.resolve(this.getRootPath(), namespace);
+        if (!existsSync(pathToDbs)) await mkdir(pathToDbs, { recursive: true });
+        return (await readdir(pathToDbs)).map((id) => id.replace(pathfs.extname(id), "").replace(".encrypted", ""));
+      }
+      async reencrypt(oldKey, newKey) {
+        const api = new fdir().withFullPaths().filter((path) => path.endsWith("encrypted.json")).crawl(this.getRootPath());
+        await PromiseB2.map(api.withPromise(), async (file) => {
+          const fileEncrypted = await readFile(file, "utf-8");
+          const additionnalNonce = file.split(".runeya").pop();
+          const fileDecrypted = await decrypt(fileEncrypted, { additionnalNonce, encryptionKey: oldKey });
+          const fileReEncrypted = await encrypt(fileDecrypted, { additionnalNonce, encryptionKey: newKey });
+          await writeFile(file, fileReEncrypted, "utf-8");
+        });
+      }
+      getDb(id, { encrypted, defaultData } = { encrypted: true, defaultData: {} }) {
+        const getPath = async () => {
+          const persistencePath = pathfs.resolve(`${this.getRootPath()}/${id}${encrypted ? ".encrypted" : ""}.json`);
+          if (!existsSync(pathfs.dirname(persistencePath))) await mkdirSync(pathfs.dirname(persistencePath), { recursive: true });
+          if (!existsSync(persistencePath)) {
+            let defaultDB = JSON.stringify(defaultData || [], null, 2);
+            if (encrypted) defaultDB = await encrypt(defaultDB, { additionnalNonce: persistencePath.split(".runeya").pop() });
+            await writeFile(persistencePath, defaultDB, "utf-8");
+            this.cache[id] = defaultDB;
+          }
+          return persistencePath;
+        };
+        const table = id.replace(/[^a-z0-9]|\s+|\r?\n|\r/gmi, "_");
+        const read = async () => {
+          if (this.cache[id]) return this.cache[id];
+          const path = await getPath();
+          const additionnalNonce = path.split(".runeya").pop();
+          let db = readFileSync(path, "utf-8");
+          if (encrypted) {
+            try {
+              if (typeof db === "string" && (db.includes("<<<<<<< HEAD") || db.includes("=======") || db.includes(">>>>>>>"))) {
+                db = await decryptFile(db, { additionnalNonce }, path);
+              } else {
+                db = await decrypt(db, { additionnalNonce }).catch((err) => {
+                  console.error(path, err);
+                  sockets2.emit("system:wrongKey");
+                  throw err;
+                });
+              }
+            } catch (err) {
+              console.error(path, err);
+              sockets2.emit("system:wrongKey");
+              throw err;
+            }
+          }
+          this.cache[id] = JSON.parse(db);
+          if (!alasql.tables[table]) {
+            await alasql(`CREATE TABLE ${table}`);
+          }
+          alasql.tables[table].data = this.cache[id];
+          return this.cache[id];
+        };
+        const write = async (data) => {
+          let db = JSON.stringify(data, null, 2);
+          const path = await getPath();
+          const additionnalNonce = path.split(".runeya").pop();
+          if (encrypted) db = await encrypt(db, { additionnalNonce });
+          writeFileSync(path, db, "utf-8");
+          this.cache[id] = data;
+          if (alasql.tables[table]) {
+            alasql.tables[table].data = data;
+          }
+        };
+        const escapeQuote = (data) => {
+          if (typeof data === "string") {
+            return data.replace(/'/g, "''");
+          }
+          return data;
+        };
+        const setValue = (item) => {
+          if (item == null) {
+            return "NULL";
+          }
+          if (item instanceof Date && item.toISOString) {
+            return `'${item.toISOString()}'`;
+          }
+          if (typeof item === "string") {
+            return `'${escapeQuote(item)}'`;
+          }
+          return `${item}`;
+        };
+        return {
+          getPath,
+          alasql: {
+            table,
+            buildUpdateQuery(data) {
+              const set = [];
+              Object.keys(data).forEach((key) => {
+                set.push(`${key} = ${setValue(data[key])}`);
+              });
+              return set.join(", ");
+            },
+            read: async (sql) => {
+              await read();
+              return alasql.promise(sql);
+            },
+            /**
+             * 
+             * @param {{where?: string, orderBy?: string, limit?: number, offset?: number}} param0 
+             * @returns {Promise<any[]>}
+             */
+            simpleSelect: async ({ where, orderBy, limit, offset }) => {
+              await read();
+              return alasql.promise(`SELECT * FROM ${table} ${where ? `WHERE ${where}` : ""} ${orderBy ? `ORDER BY ${orderBy}` : ""} ${limit ? `LIMIT ${limit}` : ""} ${offset ? `OFFSET ${offset}` : ""}`);
+            },
+            /** @param {string} where */
+            delete: async (where) => {
+              await read();
+              await alasql.promise(`DELETE FROM ${table} WHERE ${where}`);
+              await write(await alasql(`select * from ${table}`));
+            },
+            insertOne: async (data) => {
+              await read();
+              await alasql.promise(`INSERT INTO ${table} VALUES ${JSON.stringify(data)}`);
+              await write(await alasql(`select * from ${table}`));
+            },
+            write: async (sql, value) => {
+              await read();
+              await alasql.promise(sql, value);
+              await write(await alasql(`select * from ${table}`));
+            }
+          },
+          write,
+          read,
+          delete: async () => {
+            delete this.cache[id];
+            return unlink(await getPath());
+          }
+        };
+      }
+    }();
   }
 });
 
-// models/stack.js
-var require_stack = __commonJS({
-  "models/stack.js"(exports2, module2) {
+// helpers/createDefaultFiles.js
+var require_createDefaultFiles = __commonJS({
+  "helpers/createDefaultFiles.js"(exports2, module2) {
     "use strict";
-    var { sockets: sockets2 } = require_src();
-    var plugins = require_plugins();
-    var PromiseB2 = require("bluebird");
-    var Service = require_Service();
-    var ports = require_ports();
-    var dbs2 = require_dbs();
-    var EnvironmentModel = require_Environment();
-    var EncryptionKey = require_EncryptionKey();
-    var CustomObservable = require_CustomObservable();
+    var pathfs = require("path");
+    var { existsSync } = require("fs");
+    var { writeFile, readFile, appendFile } = require("fs/promises");
     var args2 = require_args();
-    var { existsSync: existsSync2, mkdirSync } = require("fs");
-    var { rename, cp: cp2, rmdir, rm: rm2 } = require("fs/promises");
-    var pathfs2 = require("path");
-    var { default: axios } = require("axios");
-    function Stack(stack) {
-      this.onServerLauch = new CustomObservable();
-      return (async () => {
-        this.watchFiles = stack.watchFiles || [];
-        this.logParsers = stack.logParsers || [];
-        this.monorepo = stack.monorepo || false;
-        this.themes = stack.themes || {};
-        this.environments = stack.environments ? stack.environments.map((env) => new EnvironmentModel(env)) : [];
-        this.documentation = stack.documentation;
-        this.services = await PromiseB2.map(stack.services || [], (service) => new Service(
-          service,
-          /** @type {StackWithPlugins} */
-          Stack
-        ));
-        this.helpers = require_exportedHelpers();
-        return this;
-      })();
-    }
-    Stack.currentStack = null;
-    Stack.currentWatches = [];
-    Stack.currentEnvironment = null;
-    Stack.Socket = sockets2;
-    Stack.plugins = plugins;
-    Stack.version = require_version().version || "";
-    Stack.url = `http://localhost:${ports.http}`;
-    Stack.port = +ports.http;
-    Stack.parsers = {
-      links: require_link(),
-      jsons: require_json(),
-      debug: require_debug()
-    };
-    Stack.helpers = require_exportedHelpers();
-    Stack.getSave = require_saves();
-    Stack.prototype.enable = async function(servicesLabelSelected) {
-      const services = this.getServices();
-      await PromiseB2.map(servicesLabelSelected, (serviceConf) => {
-        const service = services.find((service2) => serviceConf.label === service2.label);
-        if (!service) return null;
-        const hasChanged = serviceConf.enabled !== service.enabled;
-        if (hasChanged) {
-          if (serviceConf.enabled) {
-            service.enable();
-            return service.launch();
-          }
-          service.disable();
-          return service.kill();
-        }
-        return null;
-      });
-    };
-    Stack.restart = async function() {
-      await PromiseB2.map(this.getEnabledServices(), (service) => service.restart());
-    };
-    Stack.kill = async function() {
-      await PromiseB2.map(this.getEnabledServices(), (service) => service.kill());
-    };
-    Stack.getCurrentEnvironment = function() {
-      return Stack.currentEnvironment;
-    };
-    Stack.prototype.toStorage = function() {
-      return {
-        watchFiles: this.watchFiles,
-        themes: this.themes,
-        services: this.services.map((s) => s.toStorage())
-      };
-    };
-    Stack.getRootPath = () => {
-      const rootPath = pathfs2.resolve(args2.rootPath, ".runeya");
-      return rootPath;
-    };
-    Stack.parse = async function() {
-      const dbsRootPath = await dbs2.getDbs("services");
-      let services = [];
-      let environments = [];
-      try {
-        services = await PromiseB2.map(dbsRootPath, (id) => Service.load(id, Stack));
-        environments = await EnvironmentModel.all();
-      } catch (error) {
-        console.error(error);
-        this.Socket.emit("system:wrongKey");
-      }
-      return new Stack({
-        environments,
-        services
-      });
-    };
-    Stack.prototype.launch = async function() {
-      await PromiseB2.map(this.getServices(), (microservice) => {
-        if (microservice.enabled) {
-          return microservice.launch();
-        }
-        return microservice.kill();
-      });
-    };
-    Stack.getStack = function() {
-      return Stack.currentStack;
-    };
-    Stack.getServices = function() {
-      return Stack.currentStack?.services || [];
-    };
-    Stack.deleteService = async function(label) {
-      if (!Stack.currentStack) return;
-      const service = this.findService(label);
-      Stack.currentStack.services = Stack.currentStack.services.filter((a) => a.label !== label);
-      await service.delete();
-    };
-    Stack.prototype.getServices = function() {
-      return Stack.getServices();
-    };
-    Stack.getAxios = function() {
-      return axios.create({ baseURL: this.url });
-    };
-    Stack.getEnabledServices = function() {
-      return Stack.getServices().filter((s) => s.enabled);
-    };
-    Stack.prototype.getEnabledServices = function() {
-      return Stack.getEnabledServices();
-    };
-    Stack.prototype.exportInApi = function() {
-      const res = { ...this };
-      res.services = res.services?.map((s) => s.exportInApi());
-      return res;
-    };
-    Stack.findService = function(serviceLabel) {
-      return Stack.getServices().filter((s) => s.label === serviceLabel)[0];
-    };
-    Stack.prototype.findService = function(serviceLabel) {
-      return Stack.findService(serviceLabel);
-    };
-    Stack.selectConf = async function() {
-      await EncryptionKey.init();
-      if (!EncryptionKey.encryptionKey) {
-        await EncryptionKey.saveKey(await EncryptionKey.generateKey());
-      }
-      Stack.currentStack = await this.parse();
-      Stack.currentEnvironment = args2.e || process.env.RUNEYA_DEFAULT_ENVIRONMENT ? Stack.currentStack.environments.find((env) => env.label === args2.e?.toString() || env.label === process.env.RUNEYA_DEFAULT_ENVIRONMENT) || null : Stack.currentStack.environments.find((env) => env.default) || null;
-      if (process.env.RUNEYA_SERVICES) {
-        process.env.RUNEYA_SERVICES.split(",").forEach((serviceLabel) => {
-          const service = Stack.findService(serviceLabel);
-          if (service) service.enable();
-        });
-      }
-      return sockets2.emit("stack:selectConf");
+    var dbs2 = require_dbs();
+    module2.exports = async function createDefaultFiles2() {
+      await createGitignore();
+      await createPluginsGitignore();
     };
-    Stack.prototype.changeEnvironment = async function(envLabel) {
-      const environment = await EnvironmentModel.find(envLabel);
-      if (environment) {
-        Stack.currentEnvironment = environment;
-        Stack.getServices().forEach((service) => {
-          if (!service.envs[envLabel]) {
-            service.envs[envLabel] = {};
-          }
-        });
-        const enabledServices = Stack.getEnabledServices();
-        await Stack.kill();
-        enabledServices.forEach((s) => {
-          s.enabled = true;
-          s.store = [];
-        });
-        await Stack.getStack()?.launch();
-      } else {
-        throw new Error("Environment not found");
+    async function createPluginsGitignore() {
+      const gitignorePath = pathfs.resolve(args2.runeyaConfigPath, ".gitignore");
+      if (!existsSync(gitignorePath)) await writeFile(gitignorePath, "");
+      const gitignoreFile = (await readFile(gitignorePath, "utf-8")).split("\n");
+      const gitignoreHasKey = (key) => gitignoreFile.some((line) => line.trim() === key);
+      if (!gitignoreHasKey("plugins.json")) await appendFile(gitignorePath, "\nplugins.json");
+      if (!gitignoreHasKey("plugins")) await appendFile(gitignorePath, "\nplugins");
+    }
+    async function createGitignore() {
+      const dirname = pathfs.dirname(await dbs2.getDb("encryption-key", { encrypted: false, defaultData: {} }).getPath());
+      const gitignorePath = pathfs.resolve(dirname, ".gitignore");
+      if (!existsSync(gitignorePath)) {
+        await writeFile(gitignorePath, "encryption-key.json");
       }
-    };
-    Stack.stopWatchers = function() {
-      Stack.currentWatches.forEach((currentWatch) => currentWatch.close());
-    };
-    var pluginsToLoad = (
-      /** @type {(keyof typeof plugins)[]} */
-      Object.keys(plugins).reduce(
-        (p, key) => {
-          const plugin = plugins[key];
-          if (plugin.export) {
-            p[key] = typeof plugin.export === "function" && !/^\s*class\s+/.test(plugin.export.toString()) ? plugin.export(
-              /** @type {StackWithPlugins} */
-              Stack
-            ) : plugin.export;
-          }
-          return p;
-        },
-        /** @type {OmitNever<typeof plugins>} */
-        {}
-      )
-    );
-    module2.exports = /** @type {StackWithPlugins} */
-    Object.assign(Stack, pluginsToLoad);
+      const gitignoreFile = (await readFile(gitignorePath, "utf-8")).split("\n");
+      const gitignoreHasKey = (key) => gitignoreFile.some((line) => line.trim() === key);
+      if (!gitignoreHasKey("encryption-key.json")) await appendFile(gitignorePath, "\nencryption-key.json");
+      if (!gitignoreHasKey("overrides")) await appendFile(gitignorePath, "\noverrides");
+    }
   }
 });
 
@@ -3834,8 +3892,8 @@ var require_plugins2 = __commonJS({
     var { default: axios } = require("axios");
     var { tmpdir } = require("os");
     var path = require("path");
-    var { existsSync: existsSync2 } = require("fs");
-    var { writeFile, mkdir: mkdir2, readFile, cp: cp2, rm: rm2, readdir } = require("fs/promises");
+    var { existsSync } = require("fs");
+    var { writeFile, mkdir, readFile, cp, rm, readdir, appendFile } = require("fs/promises");
     var { spawn } = require("child_process");
     var dbs2 = require_dbs();
     var HTTPError = require_src2();
@@ -3880,13 +3938,13 @@ var require_plugins2 = __commonJS({
     });
     async function install(remotePath, force = false) {
       const rootPath = args2.rootPath;
-      if (!existsSync2(rootPath)) await mkdir2(rootPath, { recursive: true });
+      if (!existsSync(rootPath)) await mkdir(rootPath, { recursive: true });
       const runeyaPath = path.resolve(rootPath, ".runeya");
-      if (!existsSync2(runeyaPath)) await mkdir2(runeyaPath, { recursive: true });
+      if (!existsSync(runeyaPath)) await mkdir(runeyaPath, { recursive: true });
       const pluginsPath = path.resolve(runeyaPath, "plugins");
-      if (!existsSync2(pluginsPath)) await mkdir2(pluginsPath, { recursive: true });
+      if (!existsSync(pluginsPath)) await mkdir(pluginsPath, { recursive: true });
       const packageTmpPath = path.resolve(tmpdir(), `runeya-plugin-${Date.now()}`);
-      if (!existsSync2(packageTmpPath)) await mkdir2(packageTmpPath, { recursive: true });
+      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);
@@ -3899,8 +3957,8 @@ var require_plugins2 = __commonJS({
       }
       await dbConfig.alasql.delete(`name='${config.name}'`);
       const diskPath = path.resolve(pluginsPath, config.name);
-      if (existsSync2(diskPath)) await rm2(diskPath, { recursive: true, force: true });
-      await cp2(path.resolve(packageTmpPath), diskPath, { recursive: true });
+      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,
@@ -3991,8 +4049,8 @@ var require_plugins2 = __commonJS({
       if (!plugin) {
         throw new HTTPError("Plugin not found", "404.plugin.not.found");
       }
-      if (plugin.diskPath && existsSync2(plugin.diskPath)) {
-        await rm2(plugin.diskPath, { recursive: true, force: true });
+      if (plugin.diskPath && existsSync(plugin.diskPath)) {
+        await rm(plugin.diskPath, { recursive: true, force: true });
       }
       await dbConfig.alasql.delete(`name='${name}'`);
       sockets2.emit("plugins:uninstalled", {
@@ -4041,7 +4099,7 @@ var require_plugins2 = __commonJS({
           backendPath = path.resolve(pluginPath, "backend/index.js");
           themePath = path.resolve(pluginPath, "theme/index.js");
           let frontWatcher;
-          if (existsSync2(frontPath) && existsSync2(frontPathDist) && existsSync2(backendPath)) {
+          if (existsSync(frontPath) && existsSync(frontPathDist) && existsSync(backendPath)) {
             const debouncedFrontWatcher = debounce(async () => {
               sockets2.emit("plugins:front:building", pluginName);
               console.log("Front changed", pluginName);
@@ -4049,7 +4107,7 @@ var require_plugins2 = __commonJS({
             frontWatcher = chokidar.watch(frontPath, { ignored: frontPathDist, ignoreInitial: true }).on("all", debouncedFrontWatcher);
           }
           let frontDistWatcher;
-          if (existsSync2(frontPathDist)) {
+          if (existsSync(frontPathDist)) {
             const debouncedFrontDistWatcher = debounce(async (a, b, c) => {
               sockets2.emit("plugins:front:changed", pluginName);
               console.log("Front dist changed", pluginName);
@@ -4057,7 +4115,7 @@ var require_plugins2 = __commonJS({
             frontDistWatcher = chokidar.watch(frontPathDist, { ignoreInitial: true }).on("all", debouncedFrontDistWatcher);
           }
           let backendWatcher;
-          if (existsSync2(backendPath)) {
+          if (existsSync(backendPath)) {
             const debouncedBackendWatcher = debounce(async () => {
               await frontWatcher.close();
               await frontDistWatcher.close();
@@ -4070,7 +4128,7 @@ var require_plugins2 = __commonJS({
             backendPath = null;
           }
           let themeWatcher;
-          if (existsSync2(themePath)) {
+          if (existsSync(themePath)) {
             const debouncedThemeWatcher = debounce(async () => {
               if (frontWatcher) await frontWatcher.close();
               if (frontDistWatcher) await frontDistWatcher.close();
@@ -4345,18 +4403,18 @@ var require_system = __commonJS({
 var require_myConfs = __commonJS({
   "models/myConfs.js"(exports2, module2) {
     "use strict";
-    var pathfs2 = require("path");
+    var pathfs = require("path");
     var os = require("os");
     var {
-      existsSync: existsSync2,
+      existsSync,
       mkdirSync,
       writeFileSync,
       readFileSync
     } = require("fs");
-    var persistencePath = pathfs2.resolve(os.homedir(), ".runeya");
-    if (!existsSync2(persistencePath)) mkdirSync(persistencePath, { recursive: true });
-    var confsPath = pathfs2.resolve(persistencePath, "confs");
-    if (!existsSync2(confsPath)) writeFileSync(confsPath, JSON.stringify([]), "utf-8");
+    var persistencePath = pathfs.resolve(os.homedir(), ".runeya");
+    if (!existsSync(persistencePath)) mkdirSync(persistencePath, { recursive: true });
+    var confsPath = pathfs.resolve(persistencePath, "confs");
+    if (!existsSync(confsPath)) writeFileSync(confsPath, JSON.stringify([]), "utf-8");
     var store = JSON.parse(readFileSync(confsPath, "utf-8"));
     module2.exports = {
       /** @type {string[]} */
@@ -4568,7 +4626,7 @@ var require_fs = __commonJS({
     "use strict";
     var { express } = require_src6();
     var router = express.Router();
-    var pathfs2 = require("path");
+    var pathfs = require("path");
     var PromiseB2 = require("bluebird");
     var os = require("os");
     var { sort } = require("fast-sort");
@@ -4580,7 +4638,7 @@ var require_fs = __commonJS({
       const path = req.query.path?.toString() || __dirname;
       const dir = await readdir(path);
       const parentDirectory = {
-        absolutePath: pathfs2.resolve(path, ".."),
+        absolutePath: pathfs.resolve(path, ".."),
         name: "..",
         isDirectory: true
       };
@@ -4588,7 +4646,7 @@ var require_fs = __commonJS({
       await PromiseB2.map(dir, async (entry) => {
         try {
           if (entry.charAt(0) === ".") return null;
-          const absolutePath = pathfs2.resolve(path, entry);
+          const absolutePath = pathfs.resolve(path, entry);
           const entryStat = await stat(absolutePath);
           const entryInfos = {
             absolutePath,
@@ -4599,7 +4657,7 @@ var require_fs = __commonJS({
           };
           if (entryInfos.isDirectory) {
             entryInfos.npmInfos = await getNpmInfos(entryInfos.absolutePath);
-          } else if (pathfs2.extname(absolutePath) === ".js") {
+          } else if (pathfs.extname(absolutePath) === ".js") {
             try {
               const stack = require(absolutePath);
               if (Array.isArray(stack) && stack.length && stack[0].label && stack[0].spawnCmd) {
@@ -4622,7 +4680,7 @@ var require_fs = __commonJS({
     async function getNpmInfos(path) {
       const dir = await readdir(path);
       if (dir.includes("package.json")) {
-        const packageJSON = JSON.parse(await readFile(pathfs2.resolve(path, "package.json"), "utf-8"));
+        const packageJSON = JSON.parse(await readFile(pathfs.resolve(path, "package.json"), "utf-8"));
         return {
           path,
           packageJSON,
@@ -4950,7 +5008,7 @@ var require_server = __commonJS({
   "bin/server.js"(exports2, module2) {
     "use strict";
     var { launch } = require_src6();
-    var pathfs2 = require("path");
+    var pathfs = require("path");
     var ports = require_ports();
     var table = require_console_table();
     var args2 = require_args();
@@ -4963,7 +5021,7 @@ var require_server = __commonJS({
           apiPrefix: "/",
           bodyLimit: "100mb",
           noGreetings: true,
-          staticController: process.env.NODE_ENV !== "HFBXdZMJxLyJoua28asEaxRixJ6LriR7FnRzX6pwA7pFjZ" ? pathfs2.resolve(__dirname, "public") : void 0,
+          staticController: process.env.NODE_ENV !== "HFBXdZMJxLyJoua28asEaxRixJ6LriR7FnRzX6pwA7pFjZ" ? pathfs.resolve(__dirname, "public") : void 0,
           helmetConf: process.env.NODE_ENV !== "HFBXdZMJxLyJoua28asEaxRixJ6LriR7FnRzX6pwA7pFjZ" ? {
             crossOriginEmbedderPolicy: false,
             crossOriginResourcePolicy: false,
@@ -5018,33 +5076,14 @@ var require_server = __commonJS({
 
 // bin/www
 var { sockets } = require_src();
-var pathfs = require("path");
-var { mkdir, rm, cp } = require("fs/promises");
-var { existsSync } = require("fs");
+var migrateStackMonitor = require_migrateStackMonitor();
+var createDefaultFiles = require_createDefaultFiles();
 process.title = "runeya";
 var args = require_args();
 require("dotenv").config();
 (async () => {
-  const localLegacyPath = pathfs.resolve(args.runeyaConfigPath, "../.stackmonitor");
-  const localNewPath = args.runeyaConfigPath;
-  if (existsSync(localLegacyPath) && !existsSync(localNewPath)) {
-    console.log("Legacy path found, copy to new path");
-    await cp(localLegacyPath, localNewPath, { recursive: true, force: true });
-  }
-  const globalLegacyPath = pathfs.resolve(args.runeyaGlobalConfigPath, "../.stackmonitor");
-  const globalNewPath = args.runeyaGlobalConfigPath;
-  if (existsSync(globalLegacyPath) && !existsSync(globalNewPath)) {
-    console.log("Legacy path found, copy to new path");
-    await cp(globalLegacyPath, globalNewPath, { recursive: true, force: true });
-  }
-  if (existsSync(localLegacyPath) && !existsSync(pathfs.resolve(args.runeyaConfigPath, "dbs/overrides"))) {
-    console.log("Legacy path found, copy to new path");
-    await cp(pathfs.resolve(localLegacyPath, "dbs/overrides"), pathfs.resolve(args.runeyaConfigPath, "dbs/overrides"), { recursive: true, force: true });
-  }
-  if (existsSync(localLegacyPath) && !existsSync(pathfs.resolve(args.runeyaConfigPath, "dbs/encryption-key.json"))) {
-    console.log("Legacy path found, copy to new path");
-    await cp(pathfs.resolve(localLegacyPath, "dbs/encryption-key.json"), pathfs.resolve(args.runeyaConfigPath, "dbs/encryption-key.json"), { recursive: true, force: true });
-  }
+  await migrateStackMonitor();
+  await createDefaultFiles();
   if (args["pull-env"]) {
     await require_stack().selectConf();
     const service = require_stack().findService(args.s);