@elementspanel/epanel-plugin-instance 1.0.2 → 1.0.4

package/daemon/backend/index.cjs

@@ -2142,6 +2142,10 @@ class Instance extends events_1.EventEmitter {
     outputBuffer;
     stopping;
     resourceCleanup;
+    dispatcher;
+    reloading = false;
+    restartPending = false;
+    shuttingDown = false;
     // Track whether the current stop was initiated by a user action (stop/kill command)
     userRequestedStop = false;
     // When initializing an instance, the instance must be initialized through uuid and configuration class, otherwise the instance will be unavailable
@@ -2169,19 +2173,19 @@ class Instance extends events_1.EventEmitter {
             if (!this.isStoppedOrBusy())
                 throw new Error((0, i18n_1.$t)("TXT_CODE_instanceConf.cantModifyInstanceType"));
             (0, mcsmanager_common_1.configureEntityParams)(this.config, cfg, "type", String);
-            this.forceExec(new dispatcher_1.default());
+            this.forceExec(this.dispatcher ?? new dispatcher_1.default());
         }
         if (cfg?.enableRcon != null && cfg?.enableRcon !== this.config.enableRcon) {
             if (!this.isStoppedOrBusy())
                 throw new Error((0, i18n_1.$t)("TXT_CODE_bdfa3457"));
             (0, mcsmanager_common_1.configureEntityParams)(this.config, cfg, "enableRcon", Boolean);
-            this.forceExec(new dispatcher_1.default());
+            this.forceExec(this.dispatcher ?? new dispatcher_1.default());
         }
         if (cfg?.processType && cfg?.processType !== this.config.processType) {
             if (!this.isStoppedOrBusy())
                 throw new Error((0, i18n_1.$t)("TXT_CODE_instanceConf.cantModifyProcessType"));
             (0, mcsmanager_common_1.configureEntityParams)(this.config, cfg, "processType", String);
-            this.forceExec(new dispatcher_1.default());
+            this.forceExec(this.dispatcher ?? new dispatcher_1.default());
         }
         // If the terminal type is changed, the default command must be reset
         if (cfg?.terminalOption?.pty != null &&
@@ -2189,7 +2193,7 @@ class Instance extends events_1.EventEmitter {
             if (!this.isStoppedOrBusy())
                 throw new Error((0, i18n_1.$t)("TXT_CODE_instanceConf.cantModifyPtyModel"));
             (0, mcsmanager_common_1.configureEntityParams)(this.config.terminalOption, cfg.terminalOption, "pty", Boolean);
-            this.forceExec(new dispatcher_1.default());
+            this.forceExec(this.dispatcher ?? new dispatcher_1.default());
         }
         // Only allow some configuration items to be modified when the server is stopped
         if (this.isStoppedOrBusy() && cfg.terminalOption) {
@@ -2350,10 +2354,19 @@ class Instance extends events_1.EventEmitter {
         });
         this.process = process;
         this.instanceStatus = Instance.STATUS_RUNNING;
+        if (this.shuttingDown) {
+            this.userRequestedStop = true;
+            void Promise.resolve()
+                .then(() => process.kill("SIGKILL"))
+                .catch((error) => log_1.default.error(`Instance ${this.instanceUuid} failed to stop:`, error));
+            return;
+        }
         this.emit("open", this);
         // start all lifecycle tasks
-        void this.lifeCycleTaskManager.execLifeCycleTask(1);
-        this.startOutputLoop();
+        if (!this.reloading) {
+            void this.lifeCycleTaskManager.execLifeCycleTask(1);
+            this.startOutputLoop();
+        }
     }
     // If the instance performs any operation exception, it must throw an exception through this function
     // trigger failure event
@@ -2393,22 +2406,11 @@ class Instance extends events_1.EventEmitter {
                 this.println("ERROR", (0, i18n_1.$t)("TXT_CODE_aae2918f"));
             // Release this stop before a restarted process can emit its own exit.
             this.stopping = undefined;
-            if (shouldRestart) {
-                const maxAutoRestartCount = this.config.eventTask.autoRestartMaxTimes;
-                if (maxAutoRestartCount === -1 || this.autoRestartCount < maxAutoRestartCount) {
-                    this.execPreset("start")
-                        .then(() => {
-                        this.autoRestartCount++;
-                        this.println((0, i18n_1.$t)("TXT_CODE_instanceConf.info"), (0, i18n_1.$t)("TXT_CODE_instanceConf.autoRestart"));
-                        this.emit("autoRestarted", { count: this.autoRestartCount });
-                    })
-                        .catch((err) => {
-                        this.println((0, i18n_1.$t)("TXT_CODE_instanceConf.error"), (0, i18n_1.$t)("TXT_CODE_instanceConf.autoRestartErr", { err }));
-                    });
-                }
-                else {
-                    this.println((0, i18n_1.$t)("TXT_CODE_instanceConf.error"), (0, i18n_1.$t)("TXT_CODE_894b8e52"));
-                }
+            if (shouldRestart && !this.shuttingDown) {
+                if (this.reloading)
+                    this.restartPending = true;
+                else
+                    this.restartAfterCrash();
             }
         }).finally(() => {
             if (this.stopping === operation)
@@ -2417,6 +2419,60 @@ class Instance extends events_1.EventEmitter {
         this.stopping = operation;
         return operation;
     }
+    restartAfterCrash() {
+        if (this.shuttingDown)
+            return;
+        const maxAutoRestartCount = this.config.eventTask.autoRestartMaxTimes;
+        if (maxAutoRestartCount !== -1 && this.autoRestartCount >= maxAutoRestartCount) {
+            this.println((0, i18n_1.$t)("TXT_CODE_instanceConf.error"), (0, i18n_1.$t)("TXT_CODE_894b8e52"));
+            return;
+        }
+        void this.execPreset("start")
+            .then(() => {
+            this.autoRestartCount++;
+            this.println((0, i18n_1.$t)("TXT_CODE_instanceConf.info"), (0, i18n_1.$t)("TXT_CODE_instanceConf.autoRestart"));
+            this.emit("autoRestarted", { count: this.autoRestartCount });
+        })
+            .catch((err) => {
+            this.println((0, i18n_1.$t)("TXT_CODE_instanceConf.error"), (0, i18n_1.$t)("TXT_CODE_instanceConf.autoRestartErr", { err }));
+        });
+    }
+    /** Keep the process and its pipe readers alive while plugin services change. */
+    async suspendForReload() {
+        this.stopOutputLoop();
+        this.reloading = true;
+        this.watchers.clear();
+        await this.lifeCycleTaskManager.clearLifeCycleTask();
+    }
+    async resumeAfterReload(dispatcher) {
+        if (this.shuttingDown)
+            return;
+        await this.stopping;
+        if (this.shuttingDown)
+            return;
+        this.dispatcher = dispatcher;
+        await this.forceExec(dispatcher);
+        if (this.shuttingDown)
+            return;
+        this.reloading = false;
+        this.flushOutputBuffer();
+        if (this.status() === Instance.STATUS_RUNNING) {
+            await this.lifeCycleTaskManager.execLifeCycleTask(1);
+            if (!this.shuttingDown && this.status() === Instance.STATUS_RUNNING) {
+                this.startOutputLoop(false);
+            }
+        }
+        else if (this.status() === Instance.STATUS_STOP && this.restartPending) {
+            this.restartPending = false;
+            this.restartAfterCrash();
+        }
+    }
+    beginShutdown() {
+        this.restartPending = false;
+        this.reloading = false;
+        this.shuttingDown = true;
+        this.ignoreEventTaskOnce();
+    }
     ignoreEventTaskOnce() {
         if (this.config.eventTask)
             this.config.eventTask.ignore = true;
@@ -2430,11 +2486,14 @@ class Instance extends events_1.EventEmitter {
     // custom output method, formatting
     println(level, text) {
         const str = `[${level}] ${text}\n`;
-        this.emit("data", str);
+        this.print(str);
     }
     // custom output method
     print(data) {
-        this.emit("data", data);
+        if (this.reloading)
+            this.pushOutput(String(data));
+        else
+            this.emit("data", data);
     }
     // Release resources (mainly release process-related resources)
     releaseResources() {
@@ -2572,6 +2631,8 @@ class Instance extends events_1.EventEmitter {
         this.outputBuffer.pushLog(data);
     }
     flushOutputBuffer(shouldClear = false) {
+        if (this.reloading)
+            return;
         const { items, wasDeleted } = this.outputBuffer.getCache();
         if (!items.length)
             return;
@@ -2581,8 +2642,11 @@ class Instance extends events_1.EventEmitter {
             this.outputBuffer.clear();
         this.emit("data", items.join(""));
     }
-    startOutputLoop() {
-        this.outputBuffer = new string_cache_1.CircularBuffer(config_1.globalConfiguration.config.outputBufferSize || 256);
+    startOutputLoop(resetBuffer = true) {
+        if (this.outputLoopTask)
+            return;
+        if (resetBuffer)
+            this.outputBuffer = new string_cache_1.CircularBuffer(config_1.globalConfiguration.config.outputBufferSize || 256);
         this.outputLoopTask = setInterval(() => {
             this.flushOutputBuffer();
         }, 50);
@@ -2927,7 +2991,18 @@ function apply(ctx) {
     ctx.plugin(registries_1.LifecycleService);
     ctx.plugin(registries_1.PresetsService);
     ctx.plugin(registries_1.SchedulesService);
-    (0, runtime_1.setPluginContext)(ctx);
+    const runtime = (0, runtime_1.setPluginContext)(ctx);
+    let preserving = false;
+    let subsystem;
+    let disposeSchedules;
+    ctx.on("plugins/reloading", async () => {
+        const inventory = ctx.get("plugins")?.inventory();
+        preserving = inventory?.some((plugin) => plugin.id === "instance" && plugin.enabled) ?? true;
+        if (preserving) {
+            disposeSchedules?.();
+            await subsystem?.suspendForReload();
+        }
+    });
     (0, version_adapter_1.migrateConfig)(ctx);
     void (0, steam_cmd_1.initSteamCmd)(ctx);
     // The registry services above are created as child plugins, so their values
@@ -2946,6 +3021,57 @@ function apply(ctx) {
         const { commandStringToArray } = __webpack_require__("../../plugins/instance/daemon/src/backend/entity/commands/base/command_parser.ts");
         const { default: FunctionDispatcher } = __webpack_require__("../../plugins/instance/daemon/src/backend/entity/commands/dispatcher.ts");
         const { DockerManager } = __webpack_require__("../../plugins/instance/daemon/src/backend/service/docker_service.ts");
+        const { default: InstanceControlSubsystem } = __webpack_require__("../../plugins/instance/daemon/src/backend/service/system_instance_control.ts");
+        subsystem = InstanceSubsystem;
+        disposeSchedules = () => InstanceControlSubsystem.dispose();
+        const previous = runtime.handover;
+        let recovering = Boolean(previous);
+        let disposeInstanceEvents;
+        let shuttingDown;
+        const config = instanceCtx.settings.config;
+        const shutdown = () => (shuttingDown ??= (async () => {
+            for (const instance of InstanceSubsystem.instances.values())
+                instance.beginShutdown();
+            try {
+                if (config.enableSoftShutdown) {
+                    await InstanceSubsystem.softExit(Boolean(config.softShutdownSkipDocker), Number(config.softShutdownWaitSeconds) || 10);
+                }
+                else {
+                    await InstanceSubsystem.exit(true);
+                }
+            }
+            catch (error) {
+                instanceCtx.logger.error("Failed to stop application instances:", error);
+            }
+        })());
+        const retain = () => {
+            runtime.handover = {
+                instances: [...InstanceSubsystem.instances.values()],
+                shutdown,
+                release: () => InstanceSubsystem.releaseAfterReload()
+            };
+        };
+        // Own the processes before any asynchronous initialization. A failed Java
+        // manager or replacement must leave them available for another attempt.
+        if (previous) {
+            InstanceControlSubsystem.dispose();
+            InstanceSubsystem.adoptInstances(previous.instances);
+            retain();
+            previous.release();
+        }
+        instanceCtx.on("dispose", async () => {
+            await disposeInstanceEvents?.();
+            InstanceControlSubsystem.dispose();
+            router_1.routerApp.dispose();
+            if ((preserving || recovering) && !runtime.stopping && ctx.root.scope.isActive) {
+                await InstanceSubsystem.suspendForReload();
+                retain();
+            }
+            else {
+                await shutdown();
+            }
+            InstanceSubsystem.detachListeners();
+        });
         const services = {
             subsystem: InstanceSubsystem,
             Instance,
@@ -2987,11 +3113,10 @@ function apply(ctx) {
         const { registerInstanceEvents } = __webpack_require__("../../plugins/instance/daemon/src/backend/routers/instance_event_router.ts");
         __webpack_require__("../../plugins/instance/daemon/src/backend/routers/schedule_router.ts");
         __webpack_require__("../../plugins/instance/daemon/src/backend/routers/environment_router.ts");
-        const disposeInstanceEvents = registerInstanceEvents();
-        const { default: InstanceControlSubsystem } = __webpack_require__("../../plugins/instance/daemon/src/backend/service/system_instance_control.ts");
-        instanceCtx.on("dispose", () => router_1.routerApp.dispose());
+        disposeInstanceEvents = registerInstanceEvents();
         try {
-            InstanceSubsystem.loadInstances();
+            if (!previous)
+                InstanceSubsystem.loadInstances();
             instanceCtx.logger.info(`Loaded ${InstanceSubsystem.getInstances().length} application instances.`);
         }
         catch (error) {
@@ -3018,22 +3143,24 @@ function apply(ctx) {
                 dockerPlatforms
             };
         });
-        instanceCtx.on("dispose", async () => {
-            disposeInstanceEvents();
-            InstanceControlSubsystem.dispose();
-            try {
-                const config = instanceCtx.settings.config;
-                if (config.enableSoftShutdown) {
-                    await InstanceSubsystem.softExit(Boolean(config.softShutdownSkipDocker), Number(config.softShutdownWaitSeconds) || 10);
-                }
-                else {
-                    await InstanceSubsystem.exit(true);
-                }
-            }
-            catch (error) {
-                instanceCtx.logger.error("Failed to stop application instances:", error);
-            }
-        });
+        if (previous) {
+            let resuming;
+            const resume = () => (resuming ??= (async () => {
+                if (runtime.stopping || !instanceCtx.scope.isActive || !ctx.root.scope.isActive)
+                    return;
+                await InstanceSubsystem.resumeAfterReload();
+                if (runtime.stopping || !instanceCtx.scope.isActive || !ctx.root.scope.isActive)
+                    return;
+                InstanceControlSubsystem.loadSchedules();
+                recovering = false;
+                runtime.handover = undefined;
+            })());
+            // Rebuild commands after other plugins have registered their presets and
+            // lifecycle tasks, and before the replacement server starts listening.
+            instanceCtx.on("plugins/reloaded", resume);
+            // Also allow recovery by enabling/retrying only the instance plugin.
+            instanceCtx.on("ready", resume);
+        }
     });
 }
 
@@ -5218,29 +5345,41 @@ const fs_extra_1 = __importDefault(__webpack_require__("fs-extra"));
 const ctx_1 = __importDefault(__webpack_require__("../../plugins/instance/daemon/src/backend/entity/ctx.ts"));
 const protocol = __importStar(__webpack_require__("../../plugins/instance/daemon/src/backend/service/protocol.ts"));
 const system_instance_1 = __importDefault(__webpack_require__("../../plugins/instance/daemon/src/backend/service/system_instance.ts"));
+const log_1 = __importDefault(__webpack_require__("../../plugins/instance/daemon/src/backend/service/log.ts"));
 const MAX_LOG_SIZE = 512;
-const buffer = new Map();
 function registerInstanceEvents() {
-    const flushTimer = setInterval(() => {
+    const buffer = new Map();
+    const pending = new Map();
+    const flush = async () => {
         buffer.forEach((buf, instanceUuid) => {
             if (!buf || !instanceUuid)
                 return;
-            const logFilePath = path_1.default.join(system_instance_1.default.LOG_DIR, `${instanceUuid}.log`);
-            if (!fs_extra_1.default.existsSync(system_instance_1.default.LOG_DIR))
-                fs_extra_1.default.mkdirsSync(system_instance_1.default.LOG_DIR);
-            try {
-                const fileInfo = fs_extra_1.default.statSync(logFilePath);
-                if (fileInfo && fileInfo.size > 1024 * MAX_LOG_SIZE)
-                    fs_extra_1.default.removeSync(logFilePath);
-            }
-            catch (err) {
-                // A concurrently removed log file can be recreated on the next flush.
-            }
-            fs_extra_1.default.writeFile(logFilePath, buf, { encoding: "utf-8", flag: "a" }, () => {
-                buffer.set(instanceUuid, "");
+            buffer.delete(instanceUuid);
+            const work = (pending.get(instanceUuid) ?? Promise.resolve())
+                .then(async () => {
+                const logFilePath = path_1.default.join(system_instance_1.default.LOG_DIR, `${instanceUuid}.log`);
+                await fs_extra_1.default.ensureDir(system_instance_1.default.LOG_DIR);
+                try {
+                    const fileInfo = await fs_extra_1.default.stat(logFilePath);
+                    if (fileInfo.size > 1024 * MAX_LOG_SIZE)
+                        await fs_extra_1.default.remove(logFilePath);
+                }
+                catch (err) {
+                    if (err.code !== "ENOENT")
+                        throw err;
+                }
+                await fs_extra_1.default.writeFile(logFilePath, buf, { encoding: "utf-8", flag: "a" });
+            })
+                .catch((error) => log_1.default.error(`Failed to write instance ${instanceUuid} output:`, error))
+                .finally(() => {
+                if (pending.get(instanceUuid) === work)
+                    pending.delete(instanceUuid);
             });
+            pending.set(instanceUuid, work);
         });
-    }, 500);
+        await Promise.all(pending.values());
+    };
+    const flushTimer = setInterval(() => void flush(), 500);
     const outputLog = (instanceUuid, text) => {
         const buf = (buffer.get(instanceUuid) ?? "") + text;
         if (buf.length > 1024 * 1024)
@@ -5301,13 +5440,14 @@ function registerInstanceEvents() {
         });
     };
     system_instance_1.default.on("autoRestarted", onAutoRestarted);
-    return () => {
+    return async () => {
         clearInterval(flushTimer);
         system_instance_1.default.off("data", onData);
         system_instance_1.default.off("exit", onExit);
         system_instance_1.default.off("open", onOpen);
         system_instance_1.default.off("failure", onFailure);
         system_instance_1.default.off("autoRestarted", onAutoRestarted);
+        await flush();
         buffer.clear();
     };
 }
@@ -5399,17 +5539,45 @@ exports.core = core;
 const os_1 = __importDefault(__webpack_require__("os"));
 const path_1 = __importDefault(__webpack_require__("path"));
 const mcsmanager_common_1 = __webpack_require__("../common/src/index.ts");
-let context;
+const INSTANCE_RUNTIME = Symbol.for("elementspanel.daemon.instance-runtime");
+let runtime;
 function setPluginContext(value) {
-    context = value;
+    // Retained process callbacks can come from an evicted module. Give every
+    // generation the same bridge, owned by this daemon rather than the module.
+    const host = value.root;
+    runtime = host[INSTANCE_RUNTIME];
+    if (!runtime) {
+        const state = {
+            context: value,
+            settings: value.settings,
+            storage: value.storage,
+            stopping: false
+        };
+        host[INSTANCE_RUNTIME] = runtime = state;
+        host.on("dispose", async () => {
+            state.stopping = true;
+            // A replacement may fail before it can claim the retained processes.
+            // The daemon still owns them and must stop them during real shutdown.
+            await state.handover?.shutdown();
+            state.handover = undefined;
+        });
+    }
+    if (runtime.stopping)
+        throw new Error("The daemon is shutting down.");
+    runtime.context = value;
+    runtime.settings = value.settings;
+    runtime.storage = value.storage;
+    return runtime;
 }
 function core() {
-    if (!context)
+    if (!runtime)
         throw new Error("The instance plugin has not been initialized yet.");
-    return context;
+    return runtime.context;
 }
 function required(name) {
-    const value = core().get(name);
+    const value = core().get(name) ??
+        // Process exit and shutdown can happen between foundation generations.
+        (name === "settings" ? runtime?.settings : name === "storage" ? runtime?.storage : undefined);
     if (value === undefined)
         throw new Error(`Daemon service is unavailable: ${name}`);
     return value;
@@ -7195,6 +7363,9 @@ class InstanceSubsystem extends events_1.default {
     instances = new Map();
     instanceStream = new mcsmanager_common_1.InstanceStreamListener();
     instanceDataDir = "";
+    startupCancelled = false;
+    takeover;
+    instanceListeners = new Map();
     constructor() {
         super();
         // init instance default install path
@@ -7214,6 +7385,8 @@ class InstanceSubsystem extends events_1.default {
     async autoStart() {
         await (0, sleep_1.sleep)(1000 * 5);
         for (const instance of this.instances.values()) {
+            if (this.startupCancelled)
+                return;
             if (instance.config.eventTask.autoStart && instance.status() == instance_1.default.STATUS_STOP) {
                 instance
                     .execPreset("start")
@@ -7236,6 +7409,7 @@ class InstanceSubsystem extends events_1.default {
     }
     // init all instances from local files
     loadInstances() {
+        this.startupCancelled = false;
         const instanceConfigs = system_storage_1.default.list("InstanceConfig");
         instanceConfigs.forEach((uuid) => {
             if (uuid === this.GLOBAL_INSTANCE_UUID)
@@ -7290,15 +7464,14 @@ class InstanceSubsystem extends events_1.default {
             processType: globalConfig.processType
         }, true, // allow persistence
         this.GLOBAL_INSTANCE_UUID);
-        (0, takeover_container_1.default)()
-            .catch((error) => {
+        this.takeover = (0, takeover_container_1.default)(() => !this.startupCancelled).catch((error) => {
             const reason = error.message || error;
             if (typeof reason == "string" && reason.includes("connect ENOENT")) {
                 return;
             }
             log_1.default.error(`${(0, i18n_1.$t)("TXT_CODE_8d4c8f7e")}: ${reason}`);
-        })
-            .finally(() => this.autoStart());
+        });
+        void this.takeover.then(() => this.autoStart());
     }
     createInstance(cfg, persistence = true, uuid) {
         const newUuid = uuid || (0, uuid_1.v4)().replace(/-/gim, "");
@@ -7325,37 +7498,74 @@ class InstanceSubsystem extends events_1.default {
         }
         this.instances.set(instance.instanceUuid, instance);
         // Dynamically monitor the newly added instance output stream and pass it to its own event stream
-        instance.on("data", (...arr) => {
+        const onData = (...arr) => {
             this.emit("data", instance.instanceUuid, ...arr);
-        });
-        instance.on("exit", (exitData) => {
+        };
+        const onExit = (exitData) => {
             this.emit("exit", {
                 instanceUuid: instance.instanceUuid,
                 instanceName: instance.config.nickname,
                 exitCode: exitData.code,
                 isCrash: exitData.isCrash
             });
-        });
-        instance.on("open", (...arr) => {
+        };
+        const onOpen = (...arr) => {
             this.emit("open", {
                 instanceUuid: instance.instanceUuid,
                 instanceName: instance.config.nickname
             }, ...arr);
-        });
-        instance.on("failure", (...arr) => {
+        };
+        const onFailure = (...arr) => {
             this.emit("failure", {
                 instanceUuid: instance.instanceUuid,
                 instanceName: instance.config.nickname
             }, ...arr);
-        });
-        instance.on("autoRestarted", (data) => {
+        };
+        const onAutoRestarted = (data) => {
             this.emit("autoRestarted", {
                 instanceUuid: instance.instanceUuid,
                 instanceName: instance.config.nickname,
                 restartCount: data.count
             });
+        };
+        instance.on("data", onData);
+        instance.on("exit", onExit);
+        instance.on("open", onOpen);
+        instance.on("failure", onFailure);
+        instance.on("autoRestarted", onAutoRestarted);
+        this.instanceListeners.set(instance, () => {
+            instance.off("data", onData);
+            instance.off("exit", onExit);
+            instance.off("open", onOpen);
+            instance.off("failure", onFailure);
+            instance.off("autoRestarted", onAutoRestarted);
         });
     }
+    async suspendForReload() {
+        this.startupCancelled = true;
+        await Promise.all([...this.instances.values()].map((instance) => instance.suspendForReload()));
+        await this.takeover;
+    }
+    /** Transfer the existing owners, including ordinary child/PTY/Docker handles. */
+    adoptInstances(instances) {
+        this.startupCancelled = true;
+        for (const instance of instances)
+            this.addInstance(instance);
+    }
+    async resumeAfterReload() {
+        for (const instance of this.instances.values()) {
+            await instance.resumeAfterReload(new dispatcher_1.default());
+        }
+    }
+    detachListeners() {
+        for (const dispose of this.instanceListeners.values())
+            dispose();
+        this.instanceListeners.clear();
+    }
+    releaseAfterReload() {
+        this.detachListeners();
+        this.instances.clear();
+    }
     async removeInstance(instanceUuid, deleteFile) {
         const instance = this.getInstance(instanceUuid);
         if (instance) {
@@ -7374,6 +7584,8 @@ class InstanceSubsystem extends events_1.default {
                 system_instance_control_1.default.deleteInstanceAllTask(instanceUuid);
                 system_storage_1.default.delete("InstanceConfig", instanceUuid);
                 await instance.destroy();
+                this.instanceListeners.get(instance)?.();
+                this.instanceListeners.delete(instance);
                 this.instances.delete(instanceUuid);
                 return true;
             }
@@ -7415,8 +7627,14 @@ class InstanceSubsystem extends events_1.default {
         return this.instances.has(instanceUuid);
     }
     async exitInstance(instance, force = true) {
-        if (!this.isGlobalInstance(instance))
-            system_storage_1.default.store("InstanceConfig", instance.instanceUuid, instance.config);
+        if (!this.isGlobalInstance(instance)) {
+            try {
+                system_storage_1.default.store("InstanceConfig", instance.instanceUuid, instance.config);
+            }
+            catch (error) {
+                log_1.default.error(`Failed to save instance ${instance.instanceUuid} before shutdown:`, error);
+            }
+        }
         if (instance.status() === instance_1.default.STATUS_BUSY) {
             log_1.default.info(`Killing ${instance.config.nickname} (${instance.instanceUuid})...`);
             await instance.execPreset("kill");
@@ -7606,6 +7824,11 @@ class InstanceControlSubsystem {
     taskMap = new Map();
     taskJobMap = new Map();
     constructor() {
+        this.loadSchedules();
+    }
+    loadSchedules() {
+        if (this.taskMap.size)
+            return;
         // Initialize all persistent data and load into memory one by one
         system_storage_1.default.list("TaskConfig").forEach((uuid) => {
             try {
@@ -7876,7 +8099,7 @@ async function killContainer(containerInfo) {
     container.kill().catch(() => { });
     container.remove().catch(() => { });
 }
-async function takeoverContainer() {
+async function takeoverContainer(isActive = () => true) {
     const docker = new docker_service_1.DefaultDocker();
     const containers = new Map();
     (await docker.listContainers()).forEach((containerInfo) => {
@@ -7890,10 +8113,12 @@ async function takeoverContainer() {
         containers.set(label, containerInfo);
     });
     for (const item of containers) {
+        if (!isActive())
+            return;
         const [uuid, container] = item;
         const instance = system_instance_1.default.getInstance(uuid);
         try {
-            if (instance && instance.config.processType == "docker") {
+            if (instance && !instance.process && instance.config.processType == "docker") {
                 await instance.forceExec(new docker_takeover_1.default(container));
             }
         }
@@ -9449,9 +9674,9 @@ function recordFromPackage(pluginId, name, source, packageRoot, metadata, side)
 /**
  * Every npm plugin the runtime can load for a side, built-in and project-installed.
  *
- * Built-in mappings win over a project mapping for the same id: a third-party
- * package must not shadow a plugin that ships with the runtime. A project package
- * that does not describe the requested side is skipped instead of failing, which
+ * Built-in package names win over a project mapping for the same id. An explicit
+ * project dependency on that same package selects the user's installed version.
+ * A project package that does not describe the requested side is skipped instead of failing, which
  * is what lets a two-sided project share one dependency list between sides.
  */
 function listNpmPlugins(side, options = {}) {
@@ -9488,7 +9713,10 @@ function listNpmPlugins(side, options = {}) {
             continue;
         if (dependenciesOf(host)[name] === undefined)
             continue;
-        mappings.set(pluginId, { name, source: "bundled" });
+        mappings.set(pluginId, {
+            name,
+            source: dependenciesOf(project)[name] === undefined ? "bundled" : "project"
+        });
     }
     const hostDependencies = dependenciesOf(host);
     const projectDependencies = dependenciesOf(project);
@@ -9663,9 +9891,9 @@ async function installNpmPlugin(options) {
         if (!host)
             throw new Error(`Missing runtime package metadata: ${packageRoot}`);
         const hostId = Object.entries(mappingsOf(host)).find(([, value]) => value === name && dependenciesOf(host)[name] !== undefined)?.[0];
-        const targetRoot = hostId ? packageRoot : projectRoot;
-        if (hostId && isEssentialNpmPlugin(hostId))
-            throw new Error(`The essential plugin "${hostId}" cannot be replaced while running.`);
+        const targetRoot = hostId && dependenciesOf(readProjectManifest(projectRoot))[name] === undefined
+            ? packageRoot
+            : projectRoot;
         if (options.pluginId &&
             mappingsOf(host)[options.pluginId] &&
             dependenciesOf(host)[String(mappingsOf(host)[options.pluginId])] !== undefined &&
@@ -9712,7 +9940,7 @@ async function installNpmPlugin(options) {
             const mapped = mappingsOf(readProjectManifest(targetRoot))[pluginId];
             if (mapped !== undefined && mapped !== name)
                 throw new Error(`Plugin id ${pluginId} is already installed as ${String(mapped)}.`);
-            const record = recordFromPackage(pluginId, name, hostId ? "bundled" : "project", entry.root, entry.metadata, side);
+            const record = recordFromPackage(pluginId, name, targetRoot === packageRoot ? "bundled" : "project", entry.root, entry.metadata, side);
             if (!record)
                 throw new Error(`The package ${name} does not provide a ${side} plugin named ${pluginId}.`);
             if (/^[0-9]/.test(version) && record.version !== version)
@@ -9795,7 +10023,9 @@ async function uninstallNpmPlugin(pluginId, options = {}) {
     return withProjectLock(projectRoot, async () => {
         const host = readJson(path_1.default.join(packageRoot, "package.json"));
         const bundledName = mappingsOf(host)[pluginId];
-        const targetRoot = typeof bundledName === "string" && dependenciesOf(host)[bundledName] !== undefined
+        const targetRoot = typeof bundledName === "string" &&
+            dependenciesOf(host)[bundledName] !== undefined &&
+            dependenciesOf(readProjectManifest(projectRoot))[bundledName] === undefined
             ? packageRoot
             : projectRoot;
         const manifest = readProjectManifest(targetRoot);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elementspanel/epanel-plugin-instance",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Application instance and Java runtime management.",
   "license": "Apache-2.0",
   "author": "Csituka_D <694428809@qq.com> (https://github.com/JessDaodao)",
@@ -50,8 +50,8 @@
     }
   },
   "peerDependencies": {
-    "@elementspanel/panel": "1.0.1",
-    "@elementspanel/daemon": "1.0.1"
+    "@elementspanel/panel": "^1.0.2",
+    "@elementspanel/daemon": "^1.0.2"
   },
   "peerDependenciesMeta": {
     "@elementspanel/panel": {

package/panel/backend/index.cjs

@@ -10536,9 +10536,9 @@ function recordFromPackage(pluginId, name, source, packageRoot, metadata, side)
 /**
  * Every npm plugin the runtime can load for a side, built-in and project-installed.
  *
- * Built-in mappings win over a project mapping for the same id: a third-party
- * package must not shadow a plugin that ships with the runtime. A project package
- * that does not describe the requested side is skipped instead of failing, which
+ * Built-in package names win over a project mapping for the same id. An explicit
+ * project dependency on that same package selects the user's installed version.
+ * A project package that does not describe the requested side is skipped instead of failing, which
  * is what lets a two-sided project share one dependency list between sides.
  */
 function listNpmPlugins(side, options = {}) {
@@ -10576,7 +10576,10 @@ function listNpmPlugins(side, options = {}) {
             continue;
         if (dependenciesOf(host)[name] === undefined)
             continue;
-        mappings.set(pluginId, { name, source: "bundled" });
+        mappings.set(pluginId, {
+            name,
+            source: dependenciesOf(project)[name] === undefined ? "bundled" : "project"
+        });
     }
     const hostDependencies = dependenciesOf(host);
     const projectDependencies = dependenciesOf(project);
@@ -10755,9 +10758,9 @@ async function installNpmPlugin(options) {
         if (!host)
             throw new Error(`Missing runtime package metadata: ${packageRoot}`);
         const hostId = (_a = Object.entries(mappingsOf(host)).find(([, value]) => value === name && dependenciesOf(host)[name] !== undefined)) === null || _a === void 0 ? void 0 : _a[0];
-        const targetRoot = hostId ? packageRoot : projectRoot;
-        if (hostId && isEssentialNpmPlugin(hostId))
-            throw new Error(`The essential plugin "${hostId}" cannot be replaced while running.`);
+        const targetRoot = hostId && dependenciesOf(readProjectManifest(projectRoot))[name] === undefined
+            ? packageRoot
+            : projectRoot;
         if (options.pluginId &&
             mappingsOf(host)[options.pluginId] &&
             dependenciesOf(host)[String(mappingsOf(host)[options.pluginId])] !== undefined &&
@@ -10804,7 +10807,7 @@ async function installNpmPlugin(options) {
             const mapped = mappingsOf(readProjectManifest(targetRoot))[pluginId];
             if (mapped !== undefined && mapped !== name)
                 throw new Error(`Plugin id ${pluginId} is already installed as ${String(mapped)}.`);
-            const record = recordFromPackage(pluginId, name, hostId ? "bundled" : "project", entry.root, entry.metadata, side);
+            const record = recordFromPackage(pluginId, name, targetRoot === packageRoot ? "bundled" : "project", entry.root, entry.metadata, side);
             if (!record)
                 throw new Error(`The package ${name} does not provide a ${side} plugin named ${pluginId}.`);
             if (/^[0-9]/.test(version) && record.version !== version)
@@ -10888,7 +10891,9 @@ async function uninstallNpmPlugin(pluginId, options = {}) {
         var _a, _b;
         const host = readJson(path_1.default.join(packageRoot, "package.json"));
         const bundledName = mappingsOf(host)[pluginId];
-        const targetRoot = typeof bundledName === "string" && dependenciesOf(host)[bundledName] !== undefined
+        const targetRoot = typeof bundledName === "string" &&
+            dependenciesOf(host)[bundledName] !== undefined &&
+            dependenciesOf(readProjectManifest(projectRoot))[bundledName] === undefined
             ? packageRoot
             : projectRoot;
         const manifest = readProjectManifest(targetRoot);