@elementspanel/epanel-plugin-backup 0.0.0-stage → 1.0.0

package/daemon/backend/index.cjs

@@ -0,0 +1,772 @@
+/******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ "./plugins/backup/src/backend/index.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.inject = void 0;
+exports.apply = apply;
+const archiver_1 = __importDefault(__webpack_require__("archiver"));
+const child_process_1 = __webpack_require__("child_process");
+const fs_extra_1 = __importDefault(__webpack_require__("fs-extra"));
+const os_1 = __importDefault(__webpack_require__("os"));
+const path_1 = __importDefault(__webpack_require__("path"));
+const promises_1 = __webpack_require__("stream/promises");
+const uuid_1 = __webpack_require__("uuid");
+const i18n_1 = __webpack_require__("./plugins/backup/src/i18n/index.ts");
+exports.inject = [
+    "i18n",
+    "protocol",
+    "instances",
+    "tasks",
+    "schedules",
+    "features",
+    "archive",
+    "settings",
+    "settingsForm"
+];
+function apply(ctx) {
+    ctx.i18n.define(i18n_1.localeMessages);
+    const BACKUP_FORMATS = ["zip", "tar.gz", "7z"];
+    // Described, not drawn. The fields a backup actually reads live in the
+    // daemon configuration, and the panel's plugin manager renders this
+    // declaration; there is no browser half of a daemon plugin to put a form in.
+    ctx.settingsForm.declare({
+        fields: () => [
+            {
+                key: "instanceBackupPath",
+                type: "string",
+                title: ctx.i18n.$t("TXT_CODE_DBACKUP_PATH"),
+                description: ctx.i18n.$t("TXT_CODE_DBACKUP_PATH_TIP")
+            },
+            {
+                key: "instanceBackupFormat",
+                type: "select",
+                title: ctx.i18n.$t("TXT_CODE_DBACKUP_FORMAT"),
+                options: BACKUP_FORMATS.map((format) => ({ value: format, label: format }))
+            },
+            {
+                key: "instanceBackupCompressionLevel",
+                type: "number",
+                title: ctx.i18n.$t("TXT_CODE_DBACKUP_LEVEL"),
+                description: ctx.i18n.$t("TXT_CODE_DBACKUP_LEVEL_TIP"),
+                min: 0,
+                max: 9
+            },
+            {
+                key: "instanceBackupMaxSize",
+                type: "number",
+                title: ctx.i18n.$t("TXT_CODE_DBACKUP_MAX_SIZE"),
+                description: ctx.i18n.$t("TXT_CODE_DBACKUP_MAX_SIZE_TIP"),
+                min: 0
+            }
+        ],
+        read: () => ({
+            instanceBackupPath: ctx.settings.config.instanceBackupPath,
+            instanceBackupFormat: ctx.settings.config.instanceBackupFormat,
+            instanceBackupCompressionLevel: ctx.settings.config.instanceBackupCompressionLevel,
+            instanceBackupMaxSize: ctx.settings.config.instanceBackupMaxSize
+        }),
+        write: (values) => {
+            const config = ctx.settings.config;
+            if (values.instanceBackupPath != null) {
+                config.instanceBackupPath = String(values.instanceBackupPath);
+            }
+            const format = values.instanceBackupFormat;
+            if (typeof format === "string" && BACKUP_FORMATS.includes(format)) {
+                config.instanceBackupFormat = format;
+            }
+            const level = Number(values.instanceBackupCompressionLevel);
+            if (Number.isInteger(level) && level >= 0 && level <= 9) {
+                config.instanceBackupCompressionLevel = level;
+            }
+            const maxSize = Number(values.instanceBackupMaxSize);
+            if (Number.isFinite(maxSize) && maxSize >= 0) {
+                config.instanceBackupMaxSize = maxSize;
+            }
+            ctx.settings.save();
+        }
+    });
+    const { AsyncTask, Center: TaskCenter } = ctx.tasks;
+    const { GitignoreMatcher, decompressWithProgress, check7zipStatus, sevenZipPath, zipTimeoutSeconds } = ctx.archive;
+    const Instance = ctx.instances.Instance;
+    const t = ctx.i18n.$t;
+    const protocol = ctx.protocol;
+    const instances = ctx.instances.subsystem;
+    const logger = ctx.logger;
+    const BACKUP_EXTENSIONS = [".zip", ".tar.gz", ".7z"];
+    const GB_IN_BYTES = 1024 * 1024 * 1024;
+    const getBackupDirPath = (instanceUuid) => path_1.default.join(path_1.default.normalize(ctx.settings.config.instanceBackupPath || path_1.default.join(process.cwd(), "data/backups")), instanceUuid);
+    // Returns the instance's backup archives, newest first. `time` is in milliseconds.
+    const listBackupFiles = async (instanceUuid) => {
+        const instanceBackupDir = getBackupDirPath(instanceUuid);
+        if (!(await fs_extra_1.default.pathExists(instanceBackupDir)))
+            return [];
+        const backups = [];
+        for (const file of await fs_extra_1.default.readdir(instanceBackupDir)) {
+            const lowerFileName = file.toLowerCase();
+            if (!BACKUP_EXTENSIONS.some((extension) => lowerFileName.endsWith(extension)))
+                continue;
+            const stat = await fs_extra_1.default.stat(path_1.default.join(instanceBackupDir, file)).catch(() => null);
+            if (!stat?.isFile())
+                continue;
+            backups.push({ name: file, size: stat.size, time: stat.birthtimeMs || stat.ctimeMs });
+        }
+        return backups.sort((a, b) => b.time - a.time);
+    };
+    // One instance may store at most `instanceBackupMaxSize` GB of backup archives
+    // (0 = unlimited). A new backup is only allowed while the space left is at
+    // least as large as the average size of the archives already stored, so the
+    // archive about to be written stays within the budget.
+    const getBackupBudget = (backups) => {
+        const limitGb = Number(ctx.settings.config.instanceBackupMaxSize);
+        const unlimited = !Number.isFinite(limitGb) || limitGb <= 0;
+        const usedBytes = backups.reduce((total, backup) => total + backup.size, 0);
+        const averageBytes = backups.length > 0 ? usedBytes / backups.length : 0;
+        return {
+            unlimited,
+            limitGb,
+            usedBytes,
+            averageBytes,
+            exceeded: !unlimited && limitGb * GB_IN_BYTES - usedBytes < averageBytes
+        };
+    };
+    const toGigabytes = (bytes) => (bytes / GB_IN_BYTES).toFixed(2);
+    class InstanceBackupTask extends AsyncTask {
+        instance;
+        static TYPE = "InstanceBackupTask";
+        backupPath = "";
+        backupFileName = "";
+        ownsBusyState = false;
+        constructor(instance) {
+            super();
+            this.instance = instance;
+            this.taskId = `${InstanceBackupTask.TYPE}-${instance.instanceUuid}-${(0, uuid_1.v4)()}`;
+            this.type = InstanceBackupTask.TYPE;
+        }
+        async onStart() {
+            this.ownsBusyState = false;
+            try {
+                if (this.instance.status() === Instance.STATUS_BUSY) {
+                    throw new Error(t("TXT_CODE_instanceConf.instanceBusy"));
+                }
+                const budget = getBackupBudget(await listBackupFiles(this.instance.instanceUuid));
+                if (budget.exceeded) {
+                    throw new Error(t("TXT_CODE_INSTANCE_BACKUP_QUOTA_EXCEEDED", {
+                        limit: String(budget.limitGb),
+                        used: toGigabytes(budget.usedBytes),
+                        average: toGigabytes(budget.averageBytes)
+                    }));
+                }
+                this.instance.println("INFO", t("TXT_CODE_INSTANCE_BACKUP_START"));
+                const configuredPath = ctx.settings.config.instanceBackupPath;
+                this.backupPath = path_1.default.normalize(configuredPath || path_1.default.join(process.cwd(), "data/backups"));
+                await fs_extra_1.default.ensureDir(this.backupPath);
+                if (this.instance.status() !== Instance.STATUS_STOP) {
+                    this.instance.println("INFO", t("TXT_CODE_INSTANCE_BACKUP_STOPPING"));
+                    await this.instance.execPreset("stop");
+                    let retry = 0;
+                    while (this.instance.status() !== Instance.STATUS_STOP && retry < 60) {
+                        await new Promise((resolve) => setTimeout(resolve, 1000));
+                        retry++;
+                    }
+                    if (this.instance.status() !== Instance.STATUS_STOP) {
+                        throw new Error(t("TXT_CODE_INSTANCE_BACKUP_STOP_TIMEOUT"));
+                    }
+                }
+                this.instance.status(Instance.STATUS_BUSY);
+                this.ownsBusyState = true;
+                this.instance.println("INFO", t("TXT_CODE_INSTANCE_BACKUP_COMPRESSING"));
+                const now = new Date();
+                const dateStr = now.getFullYear() +
+                    "-" +
+                    String(now.getMonth() + 1).padStart(2, "0") +
+                    "-" +
+                    String(now.getDate()).padStart(2, "0") +
+                    "_" +
+                    String(now.getHours()).padStart(2, "0") +
+                    "-" +
+                    String(now.getMinutes()).padStart(2, "0") +
+                    "-" +
+                    String(now.getSeconds()).padStart(2, "0");
+                const backupId = (0, uuid_1.v4)().split("-")[0];
+                const configuredFormat = ctx.settings.config.instanceBackupFormat;
+                const backupFormat = configuredFormat === "tar.gz" || configuredFormat === "7z" ? configuredFormat : "zip";
+                const configuredLevel = ctx.settings.config.instanceBackupCompressionLevel;
+                const compressionLevel = Number.isInteger(configuredLevel)
+                    ? Math.min(9, Math.max(0, configuredLevel))
+                    : 9;
+                this.backupFileName = `${backupId}-${dateStr}.${backupFormat}`;
+                const instanceBackupDir = path_1.default.join(this.backupPath, this.instance.instanceUuid);
+                await fs_extra_1.default.ensureDir(instanceBackupDir);
+                const targetArchivePath = path_1.default.join(instanceBackupDir, this.backupFileName);
+                const instanceCwd = this.instance.absoluteCwdPath();
+                const epbaklstPath = path_1.default.join(instanceCwd, ".epbaklst");
+                let gitignoreMatcher = null;
+                let blacklistedCount = 0;
+                if (await fs_extra_1.default.pathExists(epbaklstPath)) {
+                    const content = await fs_extra_1.default.readFile(epbaklstPath, "utf-8");
+                    const firstLine = content.split(/\r?\n/)[0]?.trim() || "";
+                    const whitelistMode = firstLine.toLowerCase() === "$white";
+                    gitignoreMatcher = new GitignoreMatcher(content, instanceCwd, whitelistMode);
+                }
+                const whitelistMode = gitignoreMatcher ? gitignoreMatcher.isWhitelistMode() : false;
+                const allFiles = [];
+                let totalSize = 0;
+                const walkDir = async (dir, relativePath = "", whitelistedParent = false) => {
+                    const entries = await fs_extra_1.default.readdir(dir, { withFileTypes: true });
+                    for (const entry of entries) {
+                        const fullPath = path_1.default.join(dir, entry.name);
+                        // A backup directory inside the instance must not back up itself.
+                        if (path_1.default.resolve(fullPath) === path_1.default.resolve(instanceBackupDir))
+                            continue;
+                        const relPath = path_1.default.join(relativePath, entry.name);
+                        if (entry.isDirectory()) {
+                            let dirWhitelisted = whitelistedParent;
+                            if (!dirWhitelisted && gitignoreMatcher) {
+                                const dirIgnored = gitignoreMatcher.isIgnored(relPath, true);
+                                if (whitelistMode) {
+                                    dirWhitelisted = !dirIgnored;
+                                }
+                                else if (dirIgnored) {
+                                    blacklistedCount++;
+                                    continue;
+                                }
+                            }
+                            await walkDir(fullPath, relPath, dirWhitelisted);
+                        }
+                        else {
+                            if (!whitelistedParent &&
+                                gitignoreMatcher &&
+                                gitignoreMatcher.isIgnored(relPath, false)) {
+                                blacklistedCount++;
+                                continue;
+                            }
+                            const stat = await fs_extra_1.default.stat(fullPath);
+                            allFiles.push({ filePath: relPath, stat });
+                            totalSize += stat.size;
+                        }
+                    }
+                };
+                await walkDir(instanceCwd);
+                if (gitignoreMatcher && blacklistedCount > 0) {
+                    this.instance.println("INFO", t("TXT_CODE_INSTANCE_BACKUP_EXCLUDED", { num: String(blacklistedCount) }));
+                }
+                const progressPrefix = `\x1b[K\r`;
+                let lastPercent = -1;
+                const printProgress = (percent) => {
+                    const normalizedPercent = Math.min(100, Math.max(0, Math.floor(percent)));
+                    if (normalizedPercent <= lastPercent)
+                        return;
+                    lastPercent = normalizedPercent;
+                    const barLength = 30;
+                    const filled = Math.floor((normalizedPercent / 100) * barLength);
+                    const empty = barLength - filled;
+                    const bar = "[" + "#".repeat(filled) + " ".repeat(empty) + "]";
+                    this.instance.print(`${progressPrefix}${bar} ${normalizedPercent}%`);
+                };
+                if (backupFormat === "7z") {
+                    if (!(await check7zipStatus()))
+                        throw new Error(t("TXT_CODE_a0ede210"));
+                    const absoluteTargetArchivePath = path_1.default.resolve(targetArchivePath);
+                    const listFilePath = path_1.default.join(os_1.default.tmpdir(), `elements-panel-instance-backup-${backupId}.lst`);
+                    try {
+                        await fs_extra_1.default.writeFile(listFilePath, allFiles.map((file) => file.filePath.replace(/\\/g, "/")).join("\n"), "utf8");
+                        const result = await new Promise((resolve, reject) => {
+                            const child = (0, child_process_1.spawn)(sevenZipPath, [
+                                "a",
+                                absoluteTargetArchivePath,
+                                "-t7z",
+                                `-mx=${compressionLevel}`,
+                                "-scsUTF-8",
+                                "-spd",
+                                "-bsp1",
+                                `@${listFilePath}`
+                            ], { cwd: instanceCwd, windowsHide: true });
+                            let stdout = "";
+                            let stderr = "";
+                            let progressOutput = "";
+                            let settled = false;
+                            const timeout = setTimeout(() => {
+                                child.kill();
+                                if (!settled) {
+                                    settled = true;
+                                    reject(new Error(t("TXT_CODE_1d1ec400")));
+                                }
+                            }, zipTimeoutSeconds * 1000);
+                            const consume = (chunk, isStderr) => {
+                                const text = chunk.toString();
+                                if (isStderr) {
+                                    stderr += text;
+                                }
+                                else {
+                                    stdout += text;
+                                    progressOutput = `${progressOutput}${text}`.slice(-128);
+                                    const matches = progressOutput.match(/(?:^|\D)(\d{1,3})%/g) || [];
+                                    for (const match of matches) {
+                                        const percent = Number(match.match(/\d+/)?.[0]);
+                                        if (Number.isFinite(percent))
+                                            printProgress(percent);
+                                    }
+                                    const lastPercentIndex = progressOutput.lastIndexOf("%");
+                                    if (lastPercentIndex >= 0)
+                                        progressOutput = progressOutput.slice(lastPercentIndex + 1);
+                                }
+                            };
+                            printProgress(0);
+                            child.stdout.on("data", (chunk) => consume(chunk, false));
+                            child.stderr.on("data", (chunk) => consume(chunk, true));
+                            child.on("error", (error) => {
+                                clearTimeout(timeout);
+                                if (!settled) {
+                                    settled = true;
+                                    reject(error);
+                                }
+                            });
+                            child.on("close", (code) => {
+                                clearTimeout(timeout);
+                                if (settled)
+                                    return;
+                                settled = true;
+                                if (code === 0)
+                                    resolve({ stdout, stderr });
+                                else
+                                    reject(new Error(`${stdout}\n${stderr}`.trim() || `7-Zip exited with code ${code}`));
+                            });
+                        });
+                        const output = `${result.stdout}\n${result.stderr}`;
+                        const archiveStat = await fs_extra_1.default.stat(absoluteTargetArchivePath).catch(() => null);
+                        if (!archiveStat?.isFile() || archiveStat.size === 0) {
+                            throw new Error(output.trim() || t("TXT_CODE_11ecd5a9"));
+                        }
+                        printProgress(100);
+                    }
+                    catch (error) {
+                        await fs_extra_1.default.remove(absoluteTargetArchivePath).catch(() => undefined);
+                        throw error;
+                    }
+                    finally {
+                        await fs_extra_1.default.remove(listFilePath).catch(() => undefined);
+                    }
+                }
+                else {
+                    const output = fs_extra_1.default.createWriteStream(targetArchivePath);
+                    const archive = backupFormat === "tar.gz"
+                        ? (0, archiver_1.default)("tar", { gzip: true, gzipOptions: { level: compressionLevel } })
+                        : (0, archiver_1.default)("zip", { zlib: { level: compressionLevel } });
+                    for (const file of allFiles) {
+                        archive.file(path_1.default.join(instanceCwd, file.filePath), { name: file.filePath });
+                    }
+                    const progressInterval = setInterval(() => {
+                        const processedBytes = archive.pointer();
+                        printProgress(totalSize > 0 ? (processedBytes / totalSize) * 100 : 0);
+                    }, 200);
+                    try {
+                        await Promise.all([(0, promises_1.pipeline)(archive, output), archive.finalize()]);
+                        printProgress(100);
+                    }
+                    catch (error) {
+                        archive.abort();
+                        output.destroy();
+                        await fs_extra_1.default.remove(targetArchivePath).catch(() => { });
+                        throw error;
+                    }
+                    finally {
+                        clearInterval(progressInterval);
+                    }
+                }
+                this.instance.print("\n");
+                this.instance.println("INFO", t("TXT_CODE_INSTANCE_BACKUP_SUCCESS", { name: this.backupFileName }));
+                logger.info(`Instance backup success: ${this.instance.config.nickname} -> ${targetArchivePath}`);
+                await this.stop();
+            }
+            catch (error) {
+                this.instance.println("ERROR", t("TXT_CODE_INSTANCE_BACKUP_FAILED", { err: error.message }));
+                await this.error(error);
+            }
+        }
+        async onStop() {
+            // Release the busy state here rather than in `onStart`'s finally: `wait()`
+            // resolves from this stop, so a following scheduled action would otherwise
+            // still read STATUS_BUSY and skip itself.
+            if (this.ownsBusyState) {
+                this.ownsBusyState = false;
+                if (this.instance.status() === Instance.STATUS_BUSY) {
+                    this.instance.status(Instance.STATUS_STOP);
+                }
+            }
+            this.instance.print("\n");
+        }
+        async onError(error) {
+            logger.error(`InstanceBackupTask Error: ${error.message}`);
+        }
+        toObject() {
+            return {
+                taskId: this.taskId,
+                status: this.status(),
+                instanceUuid: this.instance.instanceUuid,
+                backupFileName: this.backupFileName,
+                backupPath: this.backupPath
+            };
+        }
+    }
+    const createBackupTask = (instance) => new InstanceBackupTask(instance);
+    const getBackupPath = (instanceUuid, backupName) => {
+        if (typeof backupName !== "string" || !backupName || path_1.default.basename(backupName) !== backupName) {
+            throw new Error(t("TXT_CODE_Instance_router.accessFileErr"));
+        }
+        const backupRoot = path_1.default.resolve(ctx.settings.config.instanceBackupPath || path_1.default.join(process.cwd(), "data/backups"));
+        const instanceBackupDir = path_1.default.resolve(backupRoot, instanceUuid);
+        const archivePath = path_1.default.resolve(instanceBackupDir, backupName);
+        const relativePath = path_1.default.relative(instanceBackupDir, archivePath);
+        if (!relativePath ||
+            relativePath === ".." ||
+            relativePath.startsWith(".." + path_1.default.sep) ||
+            path_1.default.isAbsolute(relativePath)) {
+            throw new Error(t("TXT_CODE_Instance_router.accessFileErr"));
+        }
+        return archivePath;
+    };
+    ctx.tasks.register("instance_backup", {
+        type: InstanceBackupTask.TYPE,
+        create: createBackupTask
+    });
+    // A scheduled backup must not be blocked by a full budget, so the oldest
+    // archives are dropped until a new one fits. The task's own check then passes.
+    const freeBackupBudget = async (instance) => {
+        const instanceBackupDir = getBackupDirPath(instance.instanceUuid);
+        let backups = await listBackupFiles(instance.instanceUuid);
+        let budget = getBackupBudget(backups);
+        while (budget.exceeded && backups.length > 0) {
+            const oldest = backups[backups.length - 1];
+            await fs_extra_1.default.remove(path_1.default.join(instanceBackupDir, oldest.name));
+            instance.println("INFO", t("TXT_CODE_INSTANCE_BACKUP_AUTO_DELETE_OLDEST", { name: oldest.name }));
+            backups = await listBackupFiles(instance.instanceUuid);
+            budget = getBackupBudget(backups);
+        }
+    };
+    ctx.schedules.register("backup", async (instance) => {
+        const runningBackup = TaskCenter.getTasks(InstanceBackupTask.TYPE).find((task) => task.toObject().instanceUuid === instance.instanceUuid && task.status() === 1);
+        const backupTask = runningBackup || createBackupTask(instance);
+        if (!runningBackup) {
+            await freeBackupBudget(instance);
+            TaskCenter.addTask(backupTask);
+        }
+        await backupTask.wait();
+    });
+    ctx.protocol.on("instance/backup/list", async (routerCtx, data) => {
+        try {
+            const instanceUuid = data.instanceUuid;
+            if (!instances.getInstance(instanceUuid))
+                throw new Error(t("TXT_CODE_3bfb9e04"));
+            const backups = await listBackupFiles(instanceUuid);
+            protocol.response(routerCtx, backups.map((backup) => ({ ...backup, time: new Date(backup.time).toLocaleString() })));
+        }
+        catch (error) {
+            protocol.responseError(routerCtx, error);
+        }
+    });
+    ctx.protocol.on("instance/backup/delete", async (routerCtx, data) => {
+        try {
+            if (!instances.getInstance(data.instanceUuid))
+                throw new Error(t("TXT_CODE_3bfb9e04"));
+            const filePath = getBackupPath(data.instanceUuid, data.backupName);
+            if (fs_extra_1.default.existsSync(filePath))
+                await fs_extra_1.default.remove(filePath);
+            protocol.response(routerCtx, true);
+        }
+        catch (error) {
+            protocol.responseError(routerCtx, error);
+        }
+    });
+    ctx.protocol.on("instance/backup/restore", async (routerCtx, data) => {
+        try {
+            const instance = instances.getInstance(data.instanceUuid);
+            if (!instance)
+                throw new Error(t("TXT_CODE_3bfb9e04"));
+            if (instance.status() !== Instance.STATUS_STOP) {
+                if (instance.status() === Instance.STATUS_BUSY) {
+                    throw new Error(t("TXT_CODE_instanceConf.instanceBusy"));
+                }
+                if (instance.status() === Instance.STATUS_RUNNING ||
+                    instance.status() === Instance.STATUS_STARTING) {
+                    instance.println("INFO", t("TXT_CODE_INSTANCE_BACKUP_STOPPING"));
+                    await instance.execPreset("stop");
+                }
+                let stopSuccess = false;
+                for (let i = 0; i < 60; i++) {
+                    if (instance.status() === Instance.STATUS_STOP) {
+                        stopSuccess = true;
+                        break;
+                    }
+                    await new Promise((resolve) => setTimeout(resolve, 1000));
+                }
+                if (!stopSuccess)
+                    throw new Error(t("TXT_CODE_INSTANCE_BACKUP_STOP_TIMEOUT"));
+            }
+            const archivePath = getBackupPath(data.instanceUuid, data.backupName);
+            if (!fs_extra_1.default.existsSync(archivePath))
+                throw new Error(t("TXT_CODE_Instance_router.accessFileErr"));
+            instance.status(Instance.STATUS_BUSY);
+            instance.println("INFO", t("TXT_CODE_INSTANCE_BACKUP_RESTORING"));
+            const tasks = ctx.get("backgroundTasks");
+            let current = 0;
+            tasks?.progress(() => ({ current, total: 100 }));
+            const pending = (async () => {
+                try {
+                    const destDir = instance.absoluteCwdPath();
+                    const progressPrefix = `\x1b[K\r`;
+                    let lastPercent = -1;
+                    await decompressWithProgress(archivePath, destDir, (percent) => {
+                        current = percent;
+                        if (percent === lastPercent)
+                            return;
+                        lastPercent = percent;
+                        const barLength = 30;
+                        const filled = Math.floor((percent / 100) * barLength);
+                        const bar = "[" + "#".repeat(filled) + " ".repeat(barLength - filled) + "]";
+                        instance.print(`${progressPrefix}${bar} ${percent}%`);
+                    }, instance.config.fileCode);
+                    instance.print("\n");
+                    instance.println("INFO", t("TXT_CODE_INSTANCE_BACKUP_RESTORE_SUCCESS"));
+                }
+                catch (error) {
+                    tasks?.fail(error);
+                    instance.print("\n");
+                    logger.error(t("TXT_CODE_INSTANCE_BACKUP_RESTORE_FAILED", { err: error.message }));
+                    instance.println("ERROR", t("TXT_CODE_INSTANCE_BACKUP_RESTORE_FAILED", { err: error.message }));
+                }
+                finally {
+                    instance.status(Instance.STATUS_STOP);
+                }
+            })();
+            tasks?.follow(pending);
+            protocol.response(routerCtx, true);
+        }
+        catch (error) {
+            protocol.responseError(routerCtx, error);
+        }
+    });
+    ctx.features.add("instanceBackup");
+}
+
+
+/***/ },
+
+/***/ "./plugins/backup/src/i18n/index.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.localeMessages = void 0;
+const de_DE_json_1 = __importDefault(__webpack_require__("./plugins/backup/src/i18n/de_DE.json"));
+const en_US_json_1 = __importDefault(__webpack_require__("./plugins/backup/src/i18n/en_US.json"));
+const es_ES_json_1 = __importDefault(__webpack_require__("./plugins/backup/src/i18n/es_ES.json"));
+const fr_FR_json_1 = __importDefault(__webpack_require__("./plugins/backup/src/i18n/fr_FR.json"));
+const ja_JP_json_1 = __importDefault(__webpack_require__("./plugins/backup/src/i18n/ja_JP.json"));
+const ko_KR_json_1 = __importDefault(__webpack_require__("./plugins/backup/src/i18n/ko_KR.json"));
+const pt_BR_json_1 = __importDefault(__webpack_require__("./plugins/backup/src/i18n/pt_BR.json"));
+const ru_RU_json_1 = __importDefault(__webpack_require__("./plugins/backup/src/i18n/ru_RU.json"));
+const th_TH_json_1 = __importDefault(__webpack_require__("./plugins/backup/src/i18n/th_TH.json"));
+const tr_TR_json_1 = __importDefault(__webpack_require__("./plugins/backup/src/i18n/tr_TR.json"));
+const zh_CN_json_1 = __importDefault(__webpack_require__("./plugins/backup/src/i18n/zh_CN.json"));
+const zh_TW_json_1 = __importDefault(__webpack_require__("./plugins/backup/src/i18n/zh_TW.json"));
+// The lines a backup prints into the instance console, plus the errors its
+// protocol handlers throw. Registered with the daemon's i18next instance at
+// setup, so the daemon catalogue carries nothing backup-specific.
+exports.localeMessages = {
+    de_de: de_DE_json_1.default,
+    en_us: en_US_json_1.default,
+    es_es: es_ES_json_1.default,
+    fr_fr: fr_FR_json_1.default,
+    ja_jp: ja_JP_json_1.default,
+    ko_kr: ko_KR_json_1.default,
+    pt_br: pt_BR_json_1.default,
+    ru_ru: ru_RU_json_1.default,
+    th_th: th_TH_json_1.default,
+    tr_tr: tr_TR_json_1.default,
+    zh_cn: zh_CN_json_1.default,
+    zh_tw: zh_TW_json_1.default
+};
+
+
+/***/ },
+
+/***/ "archiver"
+(module) {
+
+module.exports = require("archiver");
+
+/***/ },
+
+/***/ "fs-extra"
+(module) {
+
+module.exports = require("fs-extra");
+
+/***/ },
+
+/***/ "uuid"
+(module) {
+
+module.exports = require("uuid");
+
+/***/ },
+
+/***/ "child_process"
+(module) {
+
+module.exports = require("child_process");
+
+/***/ },
+
+/***/ "os"
+(module) {
+
+module.exports = require("os");
+
+/***/ },
+
+/***/ "path"
+(module) {
+
+module.exports = require("path");
+
+/***/ },
+
+/***/ "stream/promises"
+(module) {
+
+module.exports = require("stream/promises");
+
+/***/ },
+
+/***/ "./plugins/backup/src/i18n/de_DE.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_DBACKUP_FORMAT":"Archivformat","TXT_CODE_DBACKUP_LEVEL":"Kompressionsstufe","TXT_CODE_DBACKUP_LEVEL_TIP":"0 speichert ohne Kompression, 9 komprimiert am stärksten. Wird von tar.gz- und 7z-Voreinstellungen mit eigener Stufe ignoriert.","TXT_CODE_DBACKUP_MAX_SIZE":"Maximale Backup-Größe pro Instanz (GB)","TXT_CODE_DBACKUP_MAX_SIZE_TIP":"Gesamtspeicherplatz, den die Backups einer Instanz belegen dürfen. 0 bedeutet unbegrenzt. Reicht der verbleibende Platz nicht für ein durchschnittliches Backup, werden manuelle Backups abgelehnt und geplante Backups löschen das älteste Archiv.","TXT_CODE_DBACKUP_PATH":"Backup-Verzeichnis","TXT_CODE_DBACKUP_PATH_TIP":"Wohin Instanz-Backups geschrieben werden. Relative Pfade gelten ab dem Daemon-Verzeichnis; leer bedeutet data/backups.","TXT_CODE_INSTANCE_BACKUP_AUTO_DELETE_OLDEST":"Backup-Speicherplatz erschöpft, das älteste Backup wurde automatisch gelöscht: {{name}}","TXT_CODE_INSTANCE_BACKUP_COMPRESSING":"Instanzdateien werden komprimiert, bitte warten...","TXT_CODE_INSTANCE_BACKUP_EXCLUDED":"{{num}} Dateien/Verzeichnisse durch .epbaklst-Regeln ausgeschlossen","TXT_CODE_INSTANCE_BACKUP_FAILED":"Instanzsicherung fehlgeschlagen: {{err}}","TXT_CODE_INSTANCE_BACKUP_QUOTA_EXCEEDED":"Nicht genügend Backup-Speicherplatz: Das Limit dieser Instanz beträgt {{limit}}GB, {{used}}GB sind belegt und ein Backup ist durchschnittlich {{average}}GB groß. Löschen Sie alte Backups und versuchen Sie es erneut.","TXT_CODE_INSTANCE_BACKUP_RESTORE_FAILED":"Wiederherstellung der Sicherung fehlgeschlagen: {{err}}","TXT_CODE_INSTANCE_BACKUP_RESTORE_SUCCESS":"Sicherung erfolgreich wiederhergestellt!","TXT_CODE_INSTANCE_BACKUP_RESTORING":"Sicherung wird wiederhergestellt...","TXT_CODE_INSTANCE_BACKUP_START":"Instanzsicherung wird gestartet...","TXT_CODE_INSTANCE_BACKUP_STOPPING":"Instanz wird angehalten...","TXT_CODE_INSTANCE_BACKUP_STOP_TIMEOUT":"Zeitüberschreitung beim Anhalten der Instanz, Sicherung abgebrochen.","TXT_CODE_INSTANCE_BACKUP_SUCCESS":"Instanzsicherung erfolgreich! Datei: {{name}}","TXT_CODE_instanceConf.instanceBusy":"Die Instanz befindet sich derzeit in einem ausgelasteten Zustand und kann keine Aktionen ausführen."}');
+
+/***/ },
+
+/***/ "./plugins/backup/src/i18n/en_US.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_DBACKUP_FORMAT":"Archive Format","TXT_CODE_DBACKUP_LEVEL":"Compression Level","TXT_CODE_DBACKUP_LEVEL_TIP":"0 stores without compressing, 9 compresses hardest. Ignored by tar.gz and 7z presets that set their own.","TXT_CODE_DBACKUP_MAX_SIZE":"Max Backup Size per Instance (GB)","TXT_CODE_DBACKUP_MAX_SIZE_TIP":"Total space one instance\'s backups may occupy. 0 means unlimited. When the space left is smaller than an average backup, manual backups are refused and scheduled backups delete the oldest archive.","TXT_CODE_DBACKUP_PATH":"Backup Directory","TXT_CODE_DBACKUP_PATH_TIP":"Where instance backups are written. Relative paths resolve against the daemon directory; empty means data/backups.","TXT_CODE_INSTANCE_BACKUP_AUTO_DELETE_OLDEST":"Backup space is full, the oldest backup was deleted automatically: {{name}}","TXT_CODE_INSTANCE_BACKUP_COMPRESSING":"Compressing instance files, please wait...","TXT_CODE_INSTANCE_BACKUP_EXCLUDED":"{{num}} files/directories excluded by .epbaklst rules","TXT_CODE_INSTANCE_BACKUP_FAILED":"Instance backup failed: {{err}}","TXT_CODE_INSTANCE_BACKUP_QUOTA_EXCEEDED":"Not enough backup space: the limit for this instance is {{limit}}GB, {{used}}GB is used and a backup averages {{average}}GB. Delete old backups before trying again.","TXT_CODE_INSTANCE_BACKUP_RESTORE_FAILED":"Backup restoration failed: {{err}}","TXT_CODE_INSTANCE_BACKUP_RESTORE_SUCCESS":"Backup restored successfully!","TXT_CODE_INSTANCE_BACKUP_RESTORING":"Restoring backup...","TXT_CODE_INSTANCE_BACKUP_START":"Starting instance backup...","TXT_CODE_INSTANCE_BACKUP_STOPPING":"Stopping instance...","TXT_CODE_INSTANCE_BACKUP_STOP_TIMEOUT":"Stop instance timeout, backup cancelled.","TXT_CODE_INSTANCE_BACKUP_SUCCESS":"Instance backup successful! File: {{name}}","TXT_CODE_instanceConf.instanceBusy":"The current instance is busy and cannot perform any operations."}');
+
+/***/ },
+
+/***/ "./plugins/backup/src/i18n/es_ES.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_DBACKUP_FORMAT":"Formato de archivo","TXT_CODE_DBACKUP_LEVEL":"Nivel de compresión","TXT_CODE_DBACKUP_LEVEL_TIP":"0 almacena sin comprimir, 9 comprime al máximo. Se ignora en tar.gz y 7z cuando fijan el suyo.","TXT_CODE_DBACKUP_MAX_SIZE":"Tamaño máximo de copias por instancia (GB)","TXT_CODE_DBACKUP_MAX_SIZE_TIP":"Espacio total que pueden ocupar las copias de una instancia. 0 significa sin límite. Si el espacio restante es menor que el tamaño medio de una copia, las copias manuales se rechazan y las copias programadas eliminan el archivo más antiguo.","TXT_CODE_DBACKUP_PATH":"Directorio de copias","TXT_CODE_DBACKUP_PATH_TIP":"Dónde se escriben las copias de seguridad. Las rutas relativas se resuelven desde el directorio del demonio; vacío significa data/backups.","TXT_CODE_INSTANCE_BACKUP_AUTO_DELETE_OLDEST":"Espacio de copias agotado, se eliminó automáticamente la copia más antigua: {{name}}","TXT_CODE_INSTANCE_BACKUP_COMPRESSING":"Comprimiendo los archivos de la instancia, espera...","TXT_CODE_INSTANCE_BACKUP_EXCLUDED":"{{num}} archivos/directorios excluidos por las reglas de .epbaklst","TXT_CODE_INSTANCE_BACKUP_FAILED":"Error al crear la copia de la instancia: {{err}}","TXT_CODE_INSTANCE_BACKUP_QUOTA_EXCEEDED":"Espacio de copias insuficiente: el límite de esta instancia es {{limit}}GB, se usan {{used}}GB y una copia ocupa {{average}}GB de media. Elimine copias antiguas antes de reintentar.","TXT_CODE_INSTANCE_BACKUP_RESTORE_FAILED":"Error al restaurar la copia: {{err}}","TXT_CODE_INSTANCE_BACKUP_RESTORE_SUCCESS":"¡Copia restaurada correctamente!","TXT_CODE_INSTANCE_BACKUP_RESTORING":"Restaurando copia...","TXT_CODE_INSTANCE_BACKUP_START":"Iniciando la copia de la instancia...","TXT_CODE_INSTANCE_BACKUP_STOPPING":"Deteniendo la instancia...","TXT_CODE_INSTANCE_BACKUP_STOP_TIMEOUT":"Se agotó el tiempo al detener la instancia; se canceló la copia.","TXT_CODE_INSTANCE_BACKUP_SUCCESS":"¡Copia de la instancia creada! Archivo: {{name}}","TXT_CODE_instanceConf.instanceBusy":"La instancia se encuentra actualmente en un estado ocupado y no puede realizar ninguna acción."}');
+
+/***/ },
+
+/***/ "./plugins/backup/src/i18n/fr_FR.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_DBACKUP_FORMAT":"Format d archive","TXT_CODE_DBACKUP_LEVEL":"Niveau de compression","TXT_CODE_DBACKUP_LEVEL_TIP":"0 stocke sans compresser, 9 compresse au maximum. Ignoré par tar.gz et 7z qui fixent le leur.","TXT_CODE_DBACKUP_MAX_SIZE":"Taille maximale des sauvegardes par instance (GB)","TXT_CODE_DBACKUP_MAX_SIZE_TIP":"Espace total que les sauvegardes d’une instance peuvent occuper. 0 signifie illimité. Lorsque l’espace restant est inférieur à la taille moyenne d’une sauvegarde, les sauvegardes manuelles sont refusées et les sauvegardes planifiées suppriment l’archive la plus ancienne.","TXT_CODE_DBACKUP_PATH":"Répertoire de sauvegarde","TXT_CODE_DBACKUP_PATH_TIP":"Où les sauvegardes d instances sont écrites. Les chemins relatifs partent du répertoire du démon ; vide signifie data/backups.","TXT_CODE_INSTANCE_BACKUP_AUTO_DELETE_OLDEST":"Espace de sauvegarde insuffisant, la sauvegarde la plus ancienne a été supprimée automatiquement : {{name}}","TXT_CODE_INSTANCE_BACKUP_COMPRESSING":"Compression des fichiers de l’instance, veuillez patienter...","TXT_CODE_INSTANCE_BACKUP_EXCLUDED":"{{num}} fichiers/répertoires exclus par les règles .epbaklst","TXT_CODE_INSTANCE_BACKUP_FAILED":"Échec de la sauvegarde de l’instance : {{err}}","TXT_CODE_INSTANCE_BACKUP_QUOTA_EXCEEDED":"Espace de sauvegarde insuffisant : la limite de cette instance est de {{limit}}GB, {{used}}GB sont utilisés et une sauvegarde fait en moyenne {{average}}GB. Supprimez d’anciennes sauvegardes avant de réessayer.","TXT_CODE_INSTANCE_BACKUP_RESTORE_FAILED":"Échec de la restauration : {{err}}","TXT_CODE_INSTANCE_BACKUP_RESTORE_SUCCESS":"Sauvegarde restaurée avec succès !","TXT_CODE_INSTANCE_BACKUP_RESTORING":"Restauration de la sauvegarde...","TXT_CODE_INSTANCE_BACKUP_START":"Démarrage de la sauvegarde de l’instance...","TXT_CODE_INSTANCE_BACKUP_STOPPING":"Arrêt de l’instance...","TXT_CODE_INSTANCE_BACKUP_STOP_TIMEOUT":"Délai d’arrêt de l’instance dépassé, sauvegarde annulée.","TXT_CODE_INSTANCE_BACKUP_SUCCESS":"Sauvegarde de l’instance réussie ! Fichier : {{name}}","TXT_CODE_instanceConf.instanceBusy":"L\'instance est actuellement dans un état occupé et ne peut effectuer aucune action."}');
+
+/***/ },
+
+/***/ "./plugins/backup/src/i18n/ja_JP.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_DBACKUP_FORMAT":"アーカイブ形式","TXT_CODE_DBACKUP_LEVEL":"圧縮レベル","TXT_CODE_DBACKUP_LEVEL_TIP":"0 は無圧縮で格納、9 が最高圧縮です。独自のレベルを持つ tar.gz と 7z では無視されます。","TXT_CODE_DBACKUP_MAX_SIZE":"インスタンスごとの最大バックアップ容量 (GB)","TXT_CODE_DBACKUP_MAX_SIZE_TIP":"1 つのインスタンスのバックアップが占有できる合計容量です。0 は無制限を意味します。残り容量が平均バックアップサイズを下回る場合、手動バックアップは拒否され、スケジュールされたバックアップは最も古いアーカイブを削除します。","TXT_CODE_DBACKUP_PATH":"バックアップ先ディレクトリ","TXT_CODE_DBACKUP_PATH_TIP":"インスタンスのバックアップの保存先。相対パスはデーモンディレクトリ基準です。空欄の場合は data/backups になります。","TXT_CODE_INSTANCE_BACKUP_AUTO_DELETE_OLDEST":"バックアップ容量が不足しているため、最も古いバックアップを自動削除しました：{{name}}","TXT_CODE_INSTANCE_BACKUP_COMPRESSING":"インスタンスファイルを圧縮中です。お待ちください...","TXT_CODE_INSTANCE_BACKUP_EXCLUDED":".epbaklstルールにより{{num}}個のファイル/ディレクトリを除外しました","TXT_CODE_INSTANCE_BACKUP_FAILED":"インスタンスのバックアップに失敗しました：{{err}}","TXT_CODE_INSTANCE_BACKUP_QUOTA_EXCEEDED":"バックアップ容量が不足しています：このインスタンスの上限は {{limit}}GB、使用量は {{used}}GB、平均バックアップサイズは {{average}}GB です。古いバックアップを削除してから再試行してください。","TXT_CODE_INSTANCE_BACKUP_RESTORE_FAILED":"バックアップの復元に失敗しました：{{err}}","TXT_CODE_INSTANCE_BACKUP_RESTORE_SUCCESS":"バックアップを復元しました！","TXT_CODE_INSTANCE_BACKUP_RESTORING":"バックアップを復元中...","TXT_CODE_INSTANCE_BACKUP_START":"インスタンスのバックアップを開始中...","TXT_CODE_INSTANCE_BACKUP_STOPPING":"インスタンスを停止中...","TXT_CODE_INSTANCE_BACKUP_STOP_TIMEOUT":"インスタンスの停止がタイムアウトしたため、バックアップをキャンセルしました。","TXT_CODE_INSTANCE_BACKUP_SUCCESS":"インスタンスのバックアップに成功しました！ファイル：{{name}}","TXT_CODE_instanceConf.instanceBusy":"インスタンスは現在ビジー状態にあるため、アクションを実行できません。"}');
+
+/***/ },
+
+/***/ "./plugins/backup/src/i18n/ko_KR.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_DBACKUP_FORMAT":"압축 형식","TXT_CODE_DBACKUP_LEVEL":"압축 수준","TXT_CODE_DBACKUP_LEVEL_TIP":"0은 압축 없이 저장하고 9는 가장 강하게 압축합니다. 자체 수준을 쓰는 tar.gz와 7z에서는 무시됩니다.","TXT_CODE_DBACKUP_MAX_SIZE":"인스턴스별 최대 백업 용량 (GB)","TXT_CODE_DBACKUP_MAX_SIZE_TIP":"한 인스턴스의 백업이 차지할 수 있는 총 용량입니다. 0은 무제한입니다. 남은 용량이 평균 백업 크기보다 작으면 수동 백업은 거부되고, 예약 백업은 가장 오래된 백업을 삭제합니다.","TXT_CODE_DBACKUP_PATH":"백업 디렉터리","TXT_CODE_DBACKUP_PATH_TIP":"인스턴스 백업을 저장할 위치입니다. 상대 경로는 데몬 디렉터리를 기준으로 하며, 비워 두면 data/backups 입니다.","TXT_CODE_INSTANCE_BACKUP_AUTO_DELETE_OLDEST":"백업 공간이 부족하여 가장 오래된 백업을 자동으로 삭제했습니다: {{name}}","TXT_CODE_INSTANCE_BACKUP_COMPRESSING":"인스턴스 파일을 압축하는 중입니다. 잠시 기다려 주세요...","TXT_CODE_INSTANCE_BACKUP_EXCLUDED":".epbaklst 규칙으로 {{num}}개 파일/디렉터리 제외","TXT_CODE_INSTANCE_BACKUP_FAILED":"인스턴스 백업 실패: {{err}}","TXT_CODE_INSTANCE_BACKUP_QUOTA_EXCEEDED":"백업 공간이 부족합니다: 이 인스턴스의 한도는 {{limit}}GB, 사용량은 {{used}}GB, 평균 백업 크기는 {{average}}GB입니다. 이전 백업을 삭제한 후 다시 시도하세요.","TXT_CODE_INSTANCE_BACKUP_RESTORE_FAILED":"백업 복원 실패: {{err}}","TXT_CODE_INSTANCE_BACKUP_RESTORE_SUCCESS":"백업을 복원했습니다!","TXT_CODE_INSTANCE_BACKUP_RESTORING":"백업 복원 중...","TXT_CODE_INSTANCE_BACKUP_START":"인스턴스 백업 시작 중...","TXT_CODE_INSTANCE_BACKUP_STOPPING":"인스턴스 중지 중...","TXT_CODE_INSTANCE_BACKUP_STOP_TIMEOUT":"인스턴스 중지 시간이 초과되어 백업이 취소되었습니다.","TXT_CODE_INSTANCE_BACKUP_SUCCESS":"인스턴스 백업 성공! 파일: {{name}}","TXT_CODE_instanceConf.instanceBusy":"인스턴스가 현재 사용 중 상태이므로 어떤 작업도 수행할 수 없습니다."}');
+
+/***/ },
+
+/***/ "./plugins/backup/src/i18n/pt_BR.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_DBACKUP_FORMAT":"Formato do arquivo","TXT_CODE_DBACKUP_LEVEL":"Nível de compressão","TXT_CODE_DBACKUP_LEVEL_TIP":"0 armazena sem compactar, 9 compacta ao máximo. Ignorado por tar.gz e 7z que definem o seu.","TXT_CODE_DBACKUP_MAX_SIZE":"Tamanho máximo de backup por instância (GB)","TXT_CODE_DBACKUP_MAX_SIZE_TIP":"Espaço total que os backups de uma instância podem ocupar. 0 significa ilimitado. Quando o espaço restante é menor que o tamanho médio de um backup, backups manuais são recusados e backups agendados excluem o arquivo mais antigo.","TXT_CODE_DBACKUP_PATH":"Diretório de backups","TXT_CODE_DBACKUP_PATH_TIP":"Onde os backups de instâncias são gravados. Caminhos relativos partem do diretório do daemon; vazio significa data/backups.","TXT_CODE_INSTANCE_BACKUP_AUTO_DELETE_OLDEST":"Espaço de backup insuficiente, o backup mais antigo foi excluído automaticamente: {{name}}","TXT_CODE_INSTANCE_BACKUP_COMPRESSING":"Compactando os arquivos da instância, aguarde...","TXT_CODE_INSTANCE_BACKUP_EXCLUDED":"{{num}} arquivos/diretórios excluídos pelas regras de .epbaklst","TXT_CODE_INSTANCE_BACKUP_FAILED":"Falha no backup da instância: {{err}}","TXT_CODE_INSTANCE_BACKUP_QUOTA_EXCEEDED":"Espaço de backup insuficiente: o limite desta instância é {{limit}}GB, {{used}}GB estão em uso e um backup tem em média {{average}}GB. Exclua backups antigos antes de tentar novamente.","TXT_CODE_INSTANCE_BACKUP_RESTORE_FAILED":"Falha ao restaurar o backup: {{err}}","TXT_CODE_INSTANCE_BACKUP_RESTORE_SUCCESS":"Backup restaurado com sucesso!","TXT_CODE_INSTANCE_BACKUP_RESTORING":"Restaurando backup...","TXT_CODE_INSTANCE_BACKUP_START":"Iniciando o backup da instância...","TXT_CODE_INSTANCE_BACKUP_STOPPING":"Parando a instância...","TXT_CODE_INSTANCE_BACKUP_STOP_TIMEOUT":"O tempo limite para parar a instância foi atingido; o backup foi cancelado.","TXT_CODE_INSTANCE_BACKUP_SUCCESS":"Backup da instância concluído! Arquivo: {{name}}","TXT_CODE_instanceConf.instanceBusy":"A instância atual está ocupada e não pode realizar nenhuma operação."}');
+
+/***/ },
+
+/***/ "./plugins/backup/src/i18n/ru_RU.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_DBACKUP_FORMAT":"Формат архива","TXT_CODE_DBACKUP_LEVEL":"Уровень сжатия","TXT_CODE_DBACKUP_LEVEL_TIP":"0 — без сжатия, 9 — максимальное. Игнорируется для tar.gz и 7z, задающих свой уровень.","TXT_CODE_DBACKUP_MAX_SIZE":"Максимальный объем резервных копий на экземпляр (GB)","TXT_CODE_DBACKUP_MAX_SIZE_TIP":"Общий объем, который могут занимать резервные копии одного экземпляра. 0 означает без ограничений. Если оставшегося места меньше среднего размера копии, ручное резервное копирование отклоняется, а запланированное удаляет самый старый архив.","TXT_CODE_DBACKUP_PATH":"Каталог резервных копий","TXT_CODE_DBACKUP_PATH_TIP":"Куда записываются резервные копии экземпляров. Относительные пути отсчитываются от каталога демона; пусто означает data/backups.","TXT_CODE_INSTANCE_BACKUP_AUTO_DELETE_OLDEST":"Недостаточно места для резервных копий, самая старая копия удалена автоматически: {{name}}","TXT_CODE_INSTANCE_BACKUP_COMPRESSING":"Сжатие файлов экземпляра, подождите...","TXT_CODE_INSTANCE_BACKUP_EXCLUDED":"{{num}} файлов/каталогов исключено правилами .epbaklst","TXT_CODE_INSTANCE_BACKUP_FAILED":"Ошибка резервного копирования экземпляра: {{err}}","TXT_CODE_INSTANCE_BACKUP_QUOTA_EXCEEDED":"Недостаточно места для резервной копии: лимит этого экземпляра — {{limit}}GB, использовано {{used}}GB, средний размер копии — {{average}}GB. Удалите старые резервные копии и повторите попытку.","TXT_CODE_INSTANCE_BACKUP_RESTORE_FAILED":"Ошибка восстановления резервной копии: {{err}}","TXT_CODE_INSTANCE_BACKUP_RESTORE_SUCCESS":"Резервная копия успешно восстановлена!","TXT_CODE_INSTANCE_BACKUP_RESTORING":"Восстановление резервной копии...","TXT_CODE_INSTANCE_BACKUP_START":"Запуск резервного копирования экземпляра...","TXT_CODE_INSTANCE_BACKUP_STOPPING":"Остановка экземпляра...","TXT_CODE_INSTANCE_BACKUP_STOP_TIMEOUT":"Превышено время остановки экземпляра, резервное копирование отменено.","TXT_CODE_INSTANCE_BACKUP_SUCCESS":"Резервная копия экземпляра создана! Файл: {{name}}","TXT_CODE_instanceConf.instanceBusy":"Текущий экземпляр занят и не может выполнять операции."}');
+
+/***/ },
+
+/***/ "./plugins/backup/src/i18n/th_TH.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_DBACKUP_FORMAT":"รูปแบบไฟล์บีบอัด","TXT_CODE_DBACKUP_LEVEL":"ระดับการบีบอัด","TXT_CODE_DBACKUP_LEVEL_TIP":"0 คือเก็บโดยไม่บีบอัด 9 คือบีบอัดสูงสุด จะถูกละเว้นสำหรับ tar.gz และ 7z ที่กำหนดระดับของตัวเอง","TXT_CODE_DBACKUP_MAX_SIZE":"ขนาดสำรองข้อมูลสูงสุดต่ออินสแตนซ์ (GB)","TXT_CODE_DBACKUP_MAX_SIZE_TIP":"พื้นที่รวมที่ข้อมูลสำรองของอินสแตนซ์หนึ่งสามารถใช้ได้ 0 หมายถึงไม่จำกัด เมื่อพื้นที่ที่เหลือน้อยกว่าขนาดเฉลี่ยของข้อมูลสำรอง การสำรองข้อมูลด้วยตนเองจะถูกปฏิเสธ และการสำรองข้อมูลตามกำหนดจะลบข้อมูลที่เก่าที่สุด","TXT_CODE_DBACKUP_PATH":"ไดเรกทอรีสำรองข้อมูล","TXT_CODE_DBACKUP_PATH_TIP":"ตำแหน่งที่เก็บข้อมูลสำรองของอินสแตนซ์ เส้นทางแบบสัมพัทธ์อ้างอิงจากไดเรกทอรีของดีมอน เว้นว่างไว้จะเป็น data/backups","TXT_CODE_INSTANCE_BACKUP_AUTO_DELETE_OLDEST":"พื้นที่สำรองข้อมูลไม่เพียงพอ ลบข้อมูลสำรองที่เก่าที่สุดโดยอัตโนมัติแล้ว: {{name}}","TXT_CODE_INSTANCE_BACKUP_COMPRESSING":"กำลังบีบอัดไฟล์อินสแตนซ์ โปรดรอ...","TXT_CODE_INSTANCE_BACKUP_EXCLUDED":"ยกเว้นไฟล์/ไดเรกทอรี {{num}} รายการตามกฎ .epbaklst","TXT_CODE_INSTANCE_BACKUP_FAILED":"สำรองข้อมูลอินสแตนซ์ล้มเหลว: {{err}}","TXT_CODE_INSTANCE_BACKUP_QUOTA_EXCEEDED":"พื้นที่สำรองข้อมูลไม่เพียงพอ: ขีดจำกัดของอินสแตนซ์นี้คือ {{limit}}GB ใช้งานไป {{used}}GB และข้อมูลสำรองเฉลี่ย {{average}}GB กรุณาลบข้อมูลสำรองเก่าก่อนลองใหม่","TXT_CODE_INSTANCE_BACKUP_RESTORE_FAILED":"กู้คืนข้อมูลสำรองล้มเหลว: {{err}}","TXT_CODE_INSTANCE_BACKUP_RESTORE_SUCCESS":"กู้คืนข้อมูลสำรองสำเร็จ!","TXT_CODE_INSTANCE_BACKUP_RESTORING":"กำลังกู้คืนข้อมูลสำรอง...","TXT_CODE_INSTANCE_BACKUP_START":"กำลังเริ่มสำรองข้อมูลอินสแตนซ์...","TXT_CODE_INSTANCE_BACKUP_STOPPING":"กำลังหยุดอินสแตนซ์...","TXT_CODE_INSTANCE_BACKUP_STOP_TIMEOUT":"หยุดอินสแตนซ์หมดเวลา ยกเลิกการสำรองข้อมูลแล้ว","TXT_CODE_INSTANCE_BACKUP_SUCCESS":"สำรองข้อมูลอินสแตนซ์สำเร็จ! ไฟล์: {{name}}","TXT_CODE_instanceConf.instanceBusy":"อินสแตนซ์ปัจจุบันกำลังยุ่งและไม่สามารถดำเนินการใดๆ ได้"}');
+
+/***/ },
+
+/***/ "./plugins/backup/src/i18n/tr_TR.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_DBACKUP_FORMAT":"Arşiv biçimi","TXT_CODE_DBACKUP_LEVEL":"Sıkıştırma düzeyi","TXT_CODE_DBACKUP_LEVEL_TIP":"0 sıkıştırmadan saklar, 9 en çok sıkıştırır. Kendi düzeyini belirleyen tar.gz ve 7z için yok sayılır.","TXT_CODE_DBACKUP_MAX_SIZE":"Örnek başına maksimum yedek boyutu (GB)","TXT_CODE_DBACKUP_MAX_SIZE_TIP":"Bir örneğin yedeklerinin kullanabileceği toplam alan. 0 sınırsız anlamına gelir. Kalan alan ortalama bir yedekten küçükse elle yedekleme reddedilir ve zamanlanmış yedekleme en eski arşivi siler.","TXT_CODE_DBACKUP_PATH":"Yedek dizini","TXT_CODE_DBACKUP_PATH_TIP":"Örnek yedeklerinin yazılacağı yer. Göreli yollar daemon dizinine göre çözümlenir; boş bırakılırsa data/backups kullanılır.","TXT_CODE_INSTANCE_BACKUP_AUTO_DELETE_OLDEST":"Yedek alanı yetersiz, en eski yedek otomatik olarak silindi: {{name}}","TXT_CODE_INSTANCE_BACKUP_COMPRESSING":"Örnek dosyaları sıkıştırılıyor, lütfen bekleyin...","TXT_CODE_INSTANCE_BACKUP_EXCLUDED":".epbaklst kurallarıyla {{num}} dosya/dizin hariç tutuldu","TXT_CODE_INSTANCE_BACKUP_FAILED":"Örnek yedekleme başarısız: {{err}}","TXT_CODE_INSTANCE_BACKUP_QUOTA_EXCEEDED":"Yedek alanı yetersiz: bu örneğin sınırı {{limit}}GB, {{used}}GB kullanılıyor ve bir yedek ortalama {{average}}GB. Yeniden denemeden önce eski yedekleri silin.","TXT_CODE_INSTANCE_BACKUP_RESTORE_FAILED":"Yedek geri yüklenemedi: {{err}}","TXT_CODE_INSTANCE_BACKUP_RESTORE_SUCCESS":"Yedek başarıyla geri yüklendi!","TXT_CODE_INSTANCE_BACKUP_RESTORING":"Yedek geri yükleniyor...","TXT_CODE_INSTANCE_BACKUP_START":"Örnek yedeklemesi başlatılıyor...","TXT_CODE_INSTANCE_BACKUP_STOPPING":"Örnek durduruluyor...","TXT_CODE_INSTANCE_BACKUP_STOP_TIMEOUT":"Örneği durdurma zaman aşımına uğradı, yedekleme iptal edildi.","TXT_CODE_INSTANCE_BACKUP_SUCCESS":"Örnek yedekleme başarılı! Dosya: {{name}}","TXT_CODE_instanceConf.instanceBusy":"Geçerli örnek meşgul ve herhangi bir işlem gerçekleştiremiyor."}');
+
+/***/ },
+
+/***/ "./plugins/backup/src/i18n/zh_CN.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_DBACKUP_FORMAT":"压缩格式","TXT_CODE_DBACKUP_LEVEL":"压缩等级","TXT_CODE_DBACKUP_LEVEL_TIP":"0 表示只打包不压缩，9 为最高压缩率。tar.gz 与 7z 自带等级时会忽略此项。","TXT_CODE_DBACKUP_MAX_SIZE":"每个实例最大备份数据量 (GB)","TXT_CODE_DBACKUP_MAX_SIZE_TIP":"单个实例全部备份文件可占用的总空间上限，0 表示不限制。当剩余空间小于平均每个备份的大小时，手动备份会被拒绝并提示删除旧备份，计划任务备份会自动删除最旧的备份。","TXT_CODE_DBACKUP_PATH":"备份目录","TXT_CODE_DBACKUP_PATH_TIP":"实例备份的存放位置。相对路径相对于守护进程目录；留空则为 data/backups。","TXT_CODE_INSTANCE_BACKUP_AUTO_DELETE_OLDEST":"备份空间不足，已自动删除最旧的备份：{{name}}","TXT_CODE_INSTANCE_BACKUP_COMPRESSING":"正在压缩实例文件...","TXT_CODE_INSTANCE_BACKUP_EXCLUDED":"已有 {{num}} 个文件/目录被 .epbaklst 规则排除","TXT_CODE_INSTANCE_BACKUP_FAILED":"实例备份失败：{{err}}","TXT_CODE_INSTANCE_BACKUP_QUOTA_EXCEEDED":"备份空间不足，无法备份：该实例的备份上限为 {{limit}}GB，已使用 {{used}}GB，平均每个备份 {{average}}GB。请先删除旧备份后重试。","TXT_CODE_INSTANCE_BACKUP_RESTORE_FAILED":"备份恢复失败：{{err}}","TXT_CODE_INSTANCE_BACKUP_RESTORE_SUCCESS":"备份恢复成功！","TXT_CODE_INSTANCE_BACKUP_RESTORING":"正在恢复备份...","TXT_CODE_INSTANCE_BACKUP_START":"开始备份实例...","TXT_CODE_INSTANCE_BACKUP_STOPPING":"正在停止实例...","TXT_CODE_INSTANCE_BACKUP_STOP_TIMEOUT":"停止实例超时，备份已取消。","TXT_CODE_INSTANCE_BACKUP_SUCCESS":"实例备份成功：{{name}}","TXT_CODE_instanceConf.instanceBusy":"当前实例正处于忙碌状态，无法执行任何操作."}');
+
+/***/ },
+
+/***/ "./plugins/backup/src/i18n/zh_TW.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_DBACKUP_FORMAT":"壓縮格式","TXT_CODE_DBACKUP_LEVEL":"壓縮等級","TXT_CODE_DBACKUP_LEVEL_TIP":"0 表示只打包不壓縮，9 為最高壓縮率。tar.gz 與 7z 自帶等級時會忽略此項。","TXT_CODE_DBACKUP_MAX_SIZE":"每個實例最大備份資料量 (GB)","TXT_CODE_DBACKUP_MAX_SIZE_TIP":"單個實例全部備份檔案可佔用的總空間上限，0 表示不限制。當剩餘空間小於平均每個備份的大小時，手動備份會被拒絕並提示刪除舊備份，排程任務備份會自動刪除最舊的備份。","TXT_CODE_DBACKUP_PATH":"備份目錄","TXT_CODE_DBACKUP_PATH_TIP":"實例備份的存放位置。相對路徑相對於守護行程目錄；留空則為 data/backups。","TXT_CODE_INSTANCE_BACKUP_AUTO_DELETE_OLDEST":"備份空間不足，已自動刪除最舊的備份：{{name}}","TXT_CODE_INSTANCE_BACKUP_COMPRESSING":"正在壓縮實例文件...","TXT_CODE_INSTANCE_BACKUP_EXCLUDED":"已有 {{num}} 个文件/目錄被 .epbaklst 規則排除","TXT_CODE_INSTANCE_BACKUP_FAILED":"實例備份失败：{{err}}","TXT_CODE_INSTANCE_BACKUP_QUOTA_EXCEEDED":"備份空間不足，無法備份：此實例的備份上限為 {{limit}}GB，已使用 {{used}}GB，平均每個備份 {{average}}GB。請先刪除舊備份後再試。","TXT_CODE_INSTANCE_BACKUP_RESTORE_FAILED":"備份恢復失败：{{err}}","TXT_CODE_INSTANCE_BACKUP_RESTORE_SUCCESS":"備份恢復成功！","TXT_CODE_INSTANCE_BACKUP_RESTORING":"正在恢復備份...","TXT_CODE_INSTANCE_BACKUP_START":"開始備份實例...","TXT_CODE_INSTANCE_BACKUP_STOPPING":"正在停止實例...","TXT_CODE_INSTANCE_BACKUP_STOP_TIMEOUT":"停止實例超時，備份已取消。","TXT_CODE_INSTANCE_BACKUP_SUCCESS":"實例備份成功：{{name}}","TXT_CODE_instanceConf.instanceBusy":"目前實例正處於忙碌狀態，無法執行任何動作."}');
+
+/***/ }
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	
+/******/ 	// startup
+/******/ 	// Load entry module and return exports
+/******/ 	// This entry module is referenced by other modules so it can't be inlined
+/******/ 	var __webpack_exports__ = __webpack_require__("./plugins/backup/src/backend/index.ts");
+/******/ 	module.exports = __webpack_exports__;
+/******/ 	
+/******/ })()
+;