feat: 新增 HMCLMonitor 子项目，降低启动器隐藏时的内存占用

.gitignore

@@ -33,6 +33,7 @@ language-subtag-registry
 /HMCL/build/
 /HMCLCore/build/
 /HMCLBoot/build/
+/HMCLMonitor/build/
 /minecraft/libraries/HMCLTransformerDiscoveryService/build/
 /minecraft/libraries/HMCLMultiMCBootstrap/build/
 /buildSrc/build/
@@ -42,6 +43,7 @@ language-subtag-registry
 /out/
 /HMCL/out/
 /HMCLCore/out/
+/HMCLMonitor/out/
 /minecraft/libraries/HMCLTransformerDiscoveryService/out/
 /minecraft/libraries/HMCLMultiMCBootstrap/out/
 
@@ -50,6 +52,7 @@ language-subtag-registry
 /HMCL/bin/
 /HMCLBoot/bin/
 /HMCLCore/bin/
+/HMCLMonitor/bin/
 /minecraft/libraries/HMCLTransformerDiscoveryService/bin/
 /minecraft/libraries/HMCLMultiMCBootstrap/bin/
 .classpath

HMCL/build.gradle.kts

@@ -58,6 +58,7 @@ val embedResources = configurations.register("embedResources")
 dependencies {
     implementation(project(":HMCLCore"))
     implementation(project(":HMCLBoot"))
+    implementation(project(":HMCLMonitor"))
     implementation("libs:JFoenix")
     implementation(libs.jwebp)
     implementation(libs.fxsvgimage)
@@ -211,6 +212,7 @@ tasks.shadowJar {
         exclude(dependency("net.java.dev.jna:jna:.*"))
         exclude(dependency("libs:JFoenix:.*"))
         exclude(project(":HMCLBoot"))
+        exclude(project(":HMCLMonitor"))
     }
 
     manifest.attributes(

HMCL/src/main/java/org/jackhuang/hmcl/EntryPoint.java

@@ -20,6 +20,7 @@
 import org.jackhuang.hmcl.util.FileSaver;
 import org.jackhuang.hmcl.util.SelfDependencyPatcher;
 import org.jackhuang.hmcl.util.SwingUtils;
+import org.jackhuang.hmcl.monitor.MonitorSupervisor;
 import org.jackhuang.hmcl.java.JavaRuntime;
 import org.jackhuang.hmcl.util.io.FileUtils;
 import org.jackhuang.hmcl.util.io.JarUtils;
@@ -50,6 +51,11 @@ public static void main(String[] args) {
         createHMCLDirectories();
         LOG.start(Metadata.HMCL_LOCAL_HOME.resolve("logs"));
 
+        // start HMCL monitor before JavaFX initialized
+        if (MonitorSupervisor.processArguments(args)) {
+            exit(0);
+        }
+
         checkWine();
 
         if (OperatingSystem.CURRENT_OS == OperatingSystem.MACOS) {

HMCL/src/main/java/org/jackhuang/hmcl/Launcher.java

@@ -34,6 +34,7 @@
 import javafx.stage.Screen;
 import javafx.stage.Stage;
 import javafx.util.Duration;
+import org.jackhuang.hmcl.monitor.MonitorCrashReporter;
 import org.jackhuang.hmcl.game.HMCLCacheRepository;
 import org.jackhuang.hmcl.setting.*;
 import org.jackhuang.hmcl.task.AsyncTaskExecutor;
@@ -145,6 +146,11 @@ public void start(Stage primaryStage) {
                 UpdateChecker.init();
 
                 primaryStage.show();
+
+                // check wheather to show log from HMCL monitor
+                Path pendingCrashReport = MonitorCrashReporter.processArguments(getParameters().getRaw().toArray(new String[0]));
+                if (pendingCrashReport != null)
+                    MonitorCrashReporter.show(pendingCrashReport);
             });
         } catch (Throwable e) {
             CRASH_REPORTER.uncaughtException(Thread.currentThread(), e);

HMCL/src/main/java/org/jackhuang/hmcl/game/HMCLGameLauncher.java

@@ -21,16 +21,21 @@
 import org.jackhuang.hmcl.auth.AuthInfo;
 import org.jackhuang.hmcl.launch.DefaultLauncher;
 import org.jackhuang.hmcl.launch.ProcessListener;
+import org.jackhuang.hmcl.monitor.MonitorClient;
+import org.jackhuang.hmcl.setting.GameSettings;
+import org.jackhuang.hmcl.setting.LauncherVisibility;
 import org.jackhuang.hmcl.util.NativePatcher;
+import org.jackhuang.hmcl.util.StringUtils;
 import org.jackhuang.hmcl.util.i18n.LocaleUtils;
 import org.jackhuang.hmcl.util.io.FileUtils;
 import org.jackhuang.hmcl.util.io.JarUtils;
 import org.jackhuang.hmcl.util.platform.CommandBuilder;
-import org.jackhuang.hmcl.util.platform.ManagedProcess;
+import org.jackhuang.hmcl.util.platform.ProcessInfo;
 import org.jackhuang.hmcl.util.versioning.GameVersionNumber;
 
 import java.io.IOException;
 import java.io.InputStream;
+import java.nio.charset.Charset;
 import java.nio.file.*;
 import java.util.*;
 import java.util.stream.Stream;
@@ -154,11 +159,41 @@ private static String normalizedLanguageTag(Locale locale, GameVersionNumber gam
     }
 
     @Override
-    public ManagedProcess launch() throws IOException, InterruptedException {
+    public ProcessInfo launch() throws IOException, InterruptedException {
         generateOptionsTxt();
         return super.launch();
     }
 
+    @Override
+    protected ProcessInfo startProcess(ProcessBuilder builder, Charset encoding, Path nativeFolder) throws IOException {
+        if (!MonitorClient.isEnabled())
+            return super.startProcess(builder, encoding, nativeFolder);
+
+        String gameDirectoryId = null;
+        MonitorClient.RelaunchPolicy relaunchPolicy = MonitorClient.RelaunchPolicy.NEVER;
+        if (instance instanceof HMCLGameInstance hmclGameInstance) {
+            gameDirectoryId = hmclGameInstance.getRepository().getGameDirectory().getId().toString();
+
+            GameSettings.Effective setting = hmclGameInstance.getEffectiveSettings();
+            LauncherVisibility x = setting.getInheritable(GameSettings::launcherVisibilityProperty);
+            boolean showLogs = setting.getInheritable(GameSettings::showLogsProperty);
+            relaunchPolicy = showLogs
+                    ? MonitorClient.RelaunchPolicy.NEVER
+                    : switch (x) {
+                case HIDE_AND_REOPEN -> MonitorClient.RelaunchPolicy.ALWAYS;
+                case HIDE -> MonitorClient.RelaunchPolicy.ON_CRASH;
+                default -> MonitorClient.RelaunchPolicy.NEVER;
+            };
+        }
+
+        List<String> postExitCommand = null;
+        if (StringUtils.isNotBlank(options.getPostExitCommand()))
+            postExitCommand = StringUtils.tokenize(options.getPostExitCommand(), getEnvVars(nativeFolder));
+
+        return MonitorClient.launchNewMonitor(new MonitorClient.MonitorLaunchContext(builder, listener,
+                encoding, options, gameDirectoryId, postExitCommand, relaunchPolicy));
+    }
+
     @Override
     public void makeLaunchScript(Path scriptFile) throws IOException {
         generateOptionsTxt();

HMCL/src/main/java/org/jackhuang/hmcl/game/LauncherHelper.java

@@ -23,6 +23,7 @@
 import org.jackhuang.hmcl.auth.*;
 import org.jackhuang.hmcl.auth.authlibinjector.AuthlibInjectorDownloadException;
 import org.jackhuang.hmcl.auth.offline.OfflineAccount;
+import org.jackhuang.hmcl.monitor.MonitorClient;
 import org.jackhuang.hmcl.download.DefaultDependencyManager;
 import org.jackhuang.hmcl.download.DownloadProvider;
 import org.jackhuang.hmcl.download.game.*;
@@ -836,7 +837,7 @@ private final class HMCLProcessListener implements ProcessListener {
 
         private final ReentrantLock lock = new ReentrantLock();
         private final LaunchOptions launchOptions;
-        private ManagedProcess process;
+        private ProcessInfo process;
         private volatile boolean lwjgl;
         private LogWindow logWindow;
         private final boolean detectWindow;
@@ -855,7 +856,7 @@ public HMCLProcessListener(AuthInfo authInfo, LaunchOptions launchOptions, Count
         }
 
         @Override
-        public void setProcess(ManagedProcess process) {
+        public void setProcess(ProcessInfo process) {
             this.process = process;
 
             String command = new CommandBuilder().addAll(process.getCommands()).toString();
@@ -993,7 +994,14 @@ public void onLog(String log, boolean isErrorStream) {
                     try {
                         if (!lwjgl) {
                             lwjgl = true;
-                            finishLaunch();
+                            if (MonitorClient.isEnabled() && !showLogs
+                                    && (launcherVisibility == LauncherVisibility.HIDE
+                                    || launcherVisibility == LauncherVisibility.HIDE_AND_REOPEN)) {
+                                launchingLatch.countDown();
+                                runLater(Launcher::stopApplication);
+                            } else {
+                                finishLaunch();
+                            }
                         }
                     } finally {
                         lock.unlock();
@@ -1040,18 +1048,18 @@ public void onExit(int exitCode, ExitType exitType) {
 
     }
 
-    private static final Queue<WeakReference<ManagedProcess>> PROCESSES = new ConcurrentLinkedQueue<>();
+    private static final Queue<WeakReference<ProcessInfo>> PROCESSES = new ConcurrentLinkedQueue<>();
 
     public static int countMangedProcesses() {
         PROCESSES.removeIf(it -> {
-            ManagedProcess process = it.get();
+            ProcessInfo process = it.get();
             return process == null || !process.isRunning();
         });
         return PROCESSES.size();
     }
 
     public static void stopManagedProcesses() {
         while (!PROCESSES.isEmpty())
-            Optional.ofNullable(PROCESSES.poll()).map(WeakReference::get).ifPresent(ManagedProcess::stop);
+            Optional.ofNullable(PROCESSES.poll()).map(WeakReference::get).ifPresent(ProcessInfo::stop);
     }
 }

HMCL/src/main/java/org/jackhuang/hmcl/monitor/MonitorCrashReporter.java

@@ -0,0 +1,173 @@
+/*
+ * Hello Minecraft! Launcher
+ * Copyright (C) 2026 huangyuhui <huanghongxun2008@126.com> and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package org.jackhuang.hmcl.monitor;
+
+import com.google.gson.JsonParseException;
+import org.jackhuang.hmcl.game.GameInstanceID;
+import org.jackhuang.hmcl.game.HMCLGameInstance;
+import org.jackhuang.hmcl.game.HMCLGameRepository;
+import org.jackhuang.hmcl.game.Log;
+import org.jackhuang.hmcl.launch.ProcessListener;
+import org.jackhuang.hmcl.setting.GameDirectory;
+import org.jackhuang.hmcl.setting.GameDirectoryID;
+import org.jackhuang.hmcl.setting.GameDirectoryManager;
+import org.jackhuang.hmcl.task.Schedulers;
+import org.jackhuang.hmcl.task.Task;
+import org.jackhuang.hmcl.ui.GameCrashWindow;
+import org.jackhuang.hmcl.util.CircularArrayList;
+import org.jackhuang.hmcl.util.Log4jLevel;
+import org.jackhuang.hmcl.util.gson.JsonUtils;
+import org.jetbrains.annotations.NotNullByDefault;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+import static javafx.application.Platform.runLater;
+import static org.jackhuang.hmcl.util.logging.Logger.LOG;
+
+/// The relaunched launcher role of the monitor feature: presenting the crash window of a supervised
+/// game process, reusing the regular JavaFX user interface.
+@NotNullByDefault
+public final class MonitorCrashReporter {
+
+    private MonitorCrashReporter() {
+    }
+
+    public static @Nullable Path processArguments(String[] args) {
+        if (args.length == 2 && args[0].equals("--crash-report"))
+            return Path.of(args[1]);
+        return null;
+    }
+
+    public static void show(Path resultFile) {
+        ResultSpec result;
+        try {
+            result = JsonUtils.fromJsonFile(resultFile, ResultSpec.class);
+        } catch (IOException | JsonParseException e) {
+            LOG.warning("Failed to read the monitor result file " + resultFile, e);
+            return;
+        }
+        try {
+            Files.deleteIfExists(resultFile);
+        } catch (IOException e) {
+            LOG.warning("Failed to delete the monitor result file " + resultFile, e);
+        }
+        if (result == null || result.launchOptions == null || result.gameDirectoryId == null)
+            return;
+
+        // find repository
+        GameDirectoryID id = GameDirectoryID.parse(result.gameDirectoryId);
+        Optional<GameDirectory> match = GameDirectoryManager.getGameDirectories().stream()
+                .filter(directory -> directory.getId().equals(id))
+                .findFirst();
+        if (match.isEmpty())
+            return;
+        GameDirectoryManager.setSelectedGameDirectory(match.get());
+        HMCLGameRepository repository = GameDirectoryManager.getSelectedRepository();
+
+        // find instance
+        GameInstanceID instanceId = result.launchOptions.getInstanceId();
+        HMCLGameInstance instance = repository.findInstance(instanceId);
+
+        // instance found
+        if (instance != null) {
+            presentCrashWindow(result, instance);
+            return;
+        }
+
+        // repository found but cannot find instance
+        if (repository.isLoaded()) {
+            logFail(instanceId, result.logFile, repository);
+            return;
+        }
+
+        LOG.info("Waiting for the game repository to load before showing the crash window");
+        repository.refreshAsync().whenComplete(Schedulers.defaultScheduler(), exception -> {
+            if (exception == null) {
+                runLater(() -> {
+                    HMCLGameInstance loaded = repository.findInstance(instanceId);
+                    if (loaded != null)
+                        presentCrashWindow(result, loaded);
+                    else
+                        logFail(instanceId, result.logFile, repository);
+                });
+            } else {
+                LOG.warning("Failed to load the game repository while waiting to show the crash window", exception);
+                logFail(instanceId, result.logFile, repository);
+            }
+        }).start();
+    }
+
+    private static void logFail(GameInstanceID instanceId, @Nullable String logFile,
+                                @Nullable HMCLGameRepository repository) {
+        LOG.warning("Cannot resolve the launched instance " + instanceId + " ("
+                + (repository != null
+                        ? repository.getSnapshot().getInstanceCount() + " instances, loaded="
+                                + repository.isLoaded() + ", base directory "
+                                + repository.getLayout().getBaseDirectory()
+                        : "no registered game directory has the recorded id")
+                + "), skip showing the crash window."
+                + " The session log is at " + logFile);
+    }
+
+    private static void presentCrashWindow(ResultSpec result, HMCLGameInstance instance) {
+        MonitorGameProcess process = new MonitorGameProcess(
+                ProcessHandle.of(result.pid).orElse(null),
+                Objects.requireNonNullElseGet(result.commands, List::of),
+                result.processStartTime,
+                null); // pretend this is the real process.
+
+        @Nullable Path logFile = result.logFile != null ? Path.of(result.logFile) : null;
+
+        ProcessListener.ExitType exitType = ProcessListener.ExitType.valueOf(result.exitType);
+        Task.supplyAsync(() -> {
+            if (logFile == null)
+                return List.<Log>of();
+
+            // limit the lines of log
+            int limit = Log.getLogLines();
+            CircularArrayList<String> tail = new CircularArrayList<>(limit);
+            try (Stream<String> lines = Files.lines(logFile, MonitorProtocol.CHARSET)) {
+                lines.forEach(line -> {
+                    if (tail.size() == limit)
+                        tail.removeFirst();
+                    tail.addLast(line);
+                });
+            } catch (IOException | UncheckedIOException e) {
+                LOG.warning("Failed to read the session log file " + logFile, e);
+            }
+
+            Files.deleteIfExists(logFile);
+            return tail.stream()
+                    .map(line -> new Log(line, Log4jLevel.guessLevel(line)))
+                    .toList();
+        }).whenComplete(Schedulers.javafx(), (logs, exception) -> {
+            if (exception != null)
+                LOG.warning("Failed to read the session log file " + result.logFile, exception);
+            new GameCrashWindow(process, exitType, instance, Objects.requireNonNull(result.launchOptions),
+                    exception == null ? logs : List.of()).show();
+        }).start();
+    }
+}