feat.尝试弄了AOT的启动器。

LanMountainDesktop.Launcher/Services/Commands.cs

@@ -165,10 +165,27 @@ internal static class Commands
         }
 
         var baseDir = AppContext.BaseDirectory;
+        
+        // 发布版结构：Launcher 和 app-* 目录在同一目录
+        // 检查当前目录是否有 app-* 子目录（发布版）
+        var appDirs = Directory.GetDirectories(baseDir, "app-*", SearchOption.TopDirectoryOnly);
+        if (appDirs.Length > 0)
+        {
+            // 找到 app-* 目录，说明是发布版结构
+            return baseDir;
+        }
+        
+        // 开发环境：检查父目录是否有主程序
         var parent = Path.GetFullPath(Path.Combine(baseDir, ".."));
         var parentHost = OperatingSystem.IsWindows()
             ? Path.Combine(parent, "LanMountainDesktop.exe")
             : Path.Combine(parent, "LanMountainDesktop");
-        return File.Exists(parentHost) ? parent : baseDir;
+        if (File.Exists(parentHost))
+        {
+            return parent;
+        }
+        
+        // 默认返回 baseDir
+        return baseDir;
     }
 }

LanMountainDesktop.Launcher/Services/DeferredSplashStageReporter.cs

@@ -29,4 +29,12 @@ internal sealed class DeferredSplashStageReporter : ISplashStageReporter
             _pending.Add((stage, message));
         }
     }
+
+    public void ReportStage(string stage, int progress)
+    {
+        if (_inner is not null)
+        {
+            _inner.ReportStage(stage, progress);
+        }
+    }
 }

LanMountainDesktop.Launcher/Services/DeploymentLocator.cs

@@ -1,4 +1,6 @@
 using System.Globalization;
+using System.Text.Json;
+using LanMountainDesktop.Shared.Contracts.Launcher;
 
 namespace LanMountainDesktop.Launcher.Services;
 
@@ -56,6 +58,38 @@ internal sealed class DeploymentLocator
     }
 
     public string? ResolveHostExecutablePath()
+    {
+        // 使用新的灵活定位器
+        var options = new HostDiscoveryOptions
+        {
+            ExecutableName = "LanMountainDesktop",
+            PreferDevModeConfig = true,
+            RecursiveSearch = false, // 默认不启用递归搜索以提高性能
+            AdditionalSearchPaths = new List<string>
+            {
+                // 可以通过配置文件或环境变量添加更多路径
+                "${AppRoot}",
+                "${AppRoot}/..",
+                "${BaseDirectory}/../..",
+            }
+        };
+
+        var locator = new FlexibleHostLocator(_appRoot, options);
+        var result = locator.ResolveHostExecutablePath();
+        
+        if (result != null)
+        {
+            return result;
+        }
+
+        // 回退到旧逻辑（作为备选）
+        return ResolveHostExecutablePathLegacy();
+    }
+
+    /// <summary>
+    /// 传统的主程序路径解析（作为备选）
+    /// </summary>
+    private string? ResolveHostExecutablePathLegacy()
     {
         var executable = OperatingSystem.IsWindows() ? "LanMountainDesktop.exe" : "LanMountainDesktop";
         
@@ -85,9 +119,17 @@ internal sealed class DeploymentLocator
             return inParent;
         }
 
-        // 4. 开发模式：如果启用了开发模式，优先扫描开发路径
+        // 4. 开发模式：如果启用了开发模式，优先使用保存的自定义路径
         if (Views.ErrorWindow.CheckDevModeEnabled())
         {
+            // 4.1 首先检查保存的自定义路径
+            var savedCustomPath = Views.ErrorWindow.GetSavedCustomHostPath();
+            if (!string.IsNullOrWhiteSpace(savedCustomPath) && File.Exists(savedCustomPath))
+            {
+                return savedCustomPath;
+            }
+
+            // 4.2 扫描开发路径
             var devPath = ScanDevelopmentPaths(executable);
             if (!string.IsNullOrWhiteSpace(devPath))
             {
@@ -242,4 +284,39 @@ internal sealed class DeploymentLocator
 
         return segments[1];
     }
+
+    /// <summary>
+    /// 从部署目录读取版本信息
+    /// </summary>
+    public AppVersionInfo GetVersionInfo()
+    {
+        var deploymentDir = FindCurrentDeploymentDirectory();
+        if (!string.IsNullOrWhiteSpace(deploymentDir))
+        {
+            var versionFile = Path.Combine(deploymentDir, "version.json");
+            if (File.Exists(versionFile))
+            {
+                try
+                {
+                    var json = File.ReadAllText(versionFile);
+                    var info = JsonSerializer.Deserialize<AppVersionInfo>(json);
+                    if (info is not null)
+                    {
+                        return info;
+                    }
+                }
+                catch
+                {
+                    // 忽略读取失败，回退到默认值
+                }
+            }
+        }
+
+        // 回退：从目录名解析版本，使用默认开发代号
+        return new AppVersionInfo
+        {
+            Version = GetCurrentVersion(),
+            Codename = "Administrate" // 默认开发代号
+        };
+    }
 }

LanMountainDesktop.Launcher/Services/FlexibleHostLocator.cs

@@ -0,0 +1,612 @@
+using System.Diagnostics;
+using System.Text.Json;
+
+namespace LanMountainDesktop.Launcher.Services;
+
+/// <summary>
+/// 灵活的主程序定位器
+/// </summary>
+internal sealed class FlexibleHostLocator
+{
+    private readonly HostDiscoveryOptions _options;
+    private readonly string _appRoot;
+
+    public FlexibleHostLocator(string appRoot, HostDiscoveryOptions? options = null)
+    {
+        _appRoot = appRoot;
+        _options = options ?? new HostDiscoveryOptions();
+    }
+
+    /// <summary>
+    /// 解析主程序可执行文件路径
+    /// </summary>
+    public string? ResolveHostExecutablePath()
+    {
+        var executable = GetExecutableName();
+        var searchContext = new SearchContext
+        {
+            ExecutableName = executable,
+            AppRoot = _appRoot,
+            Options = _options
+        };
+
+        // ========== 第一阶段：标准路径查找（快速路径）==========
+        
+        // 1. 检查环境变量指定的路径（最高优先级 - 用于调试和特殊场景）
+        var envPath = GetPathFromEnvironment();
+        if (!string.IsNullOrWhiteSpace(envPath))
+        {
+            var validated = ValidateAndReturn(envPath, "environment variable");
+            if (validated != null) return validated;
+        }
+
+        // 2. 搜索部署目录（app-*）- 生产环境标准路径
+        var deploymentPath = SearchDeploymentDirectories(searchContext);
+        if (!string.IsNullOrWhiteSpace(deploymentPath))
+        {
+            return deploymentPath;
+        }
+
+        // 3. 检查 Launcher 同级目录（便携模式）
+        var portablePath = SearchPortableLocation(searchContext);
+        if (!string.IsNullOrWhiteSpace(portablePath))
+        {
+            return portablePath;
+        }
+
+        // ========== 第二阶段：灵活查找（标准路径找不到时）==========
+        
+        // 4. 检查配置文件中的路径 - 用户自定义配置
+        var configPath = GetPathFromConfigFile();
+        if (!string.IsNullOrWhiteSpace(configPath))
+        {
+            var validated = ValidateAndReturn(configPath, "config file");
+            if (validated != null) return validated;
+        }
+
+        // 5. 搜索附近目录（向上、向下各一层）
+        var nearbyPath = SearchNearbyDirectories(searchContext);
+        if (!string.IsNullOrWhiteSpace(nearbyPath))
+        {
+            return nearbyPath;
+        }
+
+        // 6. 开发模式：检查保存的自定义路径
+        if (_options.PreferDevModeConfig && Views.ErrorWindow.CheckDevModeEnabled())
+        {
+            var savedPath = Views.ErrorWindow.GetSavedCustomHostPath();
+            if (!string.IsNullOrWhiteSpace(savedPath))
+            {
+                var validated = ValidateAndReturn(savedPath, "saved dev mode path");
+                if (validated != null) return validated;
+            }
+        }
+
+        // 7. 搜索标准开发路径
+        var devPath = SearchDevelopmentPaths(searchContext);
+        if (!string.IsNullOrWhiteSpace(devPath))
+        {
+            return devPath;
+        }
+
+        // 8. 搜索额外的配置路径
+        var additionalPath = SearchAdditionalPaths(searchContext);
+        if (!string.IsNullOrWhiteSpace(additionalPath))
+        {
+            return additionalPath;
+        }
+
+        // 9. 递归搜索（如果启用）
+        if (_options.RecursiveSearch)
+        {
+            var recursivePath = SearchRecursively(searchContext);
+            if (!string.IsNullOrWhiteSpace(recursivePath))
+            {
+                return recursivePath;
+            }
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// 从环境变量获取路径
+    /// </summary>
+    private string? GetPathFromEnvironment()
+    {
+        if (string.IsNullOrWhiteSpace(_options.CustomPathEnvVar))
+        {
+            return null;
+        }
+
+        var path = Environment.GetEnvironmentVariable(_options.CustomPathEnvVar);
+        return path;
+    }
+
+    /// <summary>
+    /// 从配置文件获取路径
+    /// </summary>
+    private string? GetPathFromConfigFile()
+    {
+        if (string.IsNullOrWhiteSpace(_options.ConfigFileName))
+        {
+            return null;
+        }
+
+        var configPath = Path.Combine(_appRoot, _options.ConfigFileName);
+        if (!File.Exists(configPath))
+        {
+            return null;
+        }
+
+        try
+        {
+            var json = File.ReadAllText(configPath);
+            var config = JsonSerializer.Deserialize<HostDiscoveryConfig>(json);
+            if (config?.HostPath != null && File.Exists(config.HostPath))
+            {
+                return config.HostPath;
+            }
+        }
+        catch
+        {
+            // 忽略配置文件读取错误
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// 搜索部署目录
+    /// </summary>
+    private string? SearchDeploymentDirectories(SearchContext context)
+    {
+        if (!Directory.Exists(_appRoot))
+        {
+            return null;
+        }
+
+        try
+        {
+            // 查找 app-* 目录
+            var appDirs = Directory.GetDirectories(_appRoot, "app-*", SearchOption.TopDirectoryOnly)
+                .Where(dir => !File.Exists(Path.Combine(dir, ".destroy")))
+                .Where(dir => !File.Exists(Path.Combine(dir, ".partial")))
+                .ToList();
+
+            // 优先选择带 .current 标记的
+            var currentMarked = appDirs
+                .Where(dir => File.Exists(Path.Combine(dir, ".current")))
+                .Select(dir => Path.Combine(dir, context.ExecutableName))
+                .FirstOrDefault(File.Exists);
+
+            if (currentMarked != null)
+            {
+                return currentMarked;
+            }
+
+            // 选择版本号最高的
+            var latest = appDirs
+                .Select(dir => new
+                {
+                    Dir = dir,
+                    Version = ParseVersionFromDirectoryName(dir)
+                })
+                .OrderByDescending(x => x.Version)
+                .Select(x => Path.Combine(x.Dir, context.ExecutableName))
+                .FirstOrDefault(File.Exists);
+
+            return latest;
+        }
+        catch
+        {
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// 搜索便携模式位置（Launcher 同级目录）
+    /// </summary>
+    private string? SearchPortableLocation(SearchContext context)
+    {
+        try
+        {
+            var launcherDir = AppContext.BaseDirectory;
+            var portablePath = Path.Combine(launcherDir, context.ExecutableName);
+            
+            if (File.Exists(portablePath))
+            {
+                return portablePath;
+            }
+        }
+        catch
+        {
+            // 忽略错误
+        }
+        return null;
+    }
+
+    /// <summary>
+    /// 搜索附近目录（灵活查找，适用于各种部署场景）
+    /// </summary>
+    private string? SearchNearbyDirectories(SearchContext context)
+    {
+        try
+        {
+            var searchDirs = new List<string>();
+            
+            // Launcher 所在目录
+            var launcherDir = AppContext.BaseDirectory;
+            searchDirs.Add(launcherDir);
+            
+            // 上级目录
+            var parentDir = Path.GetFullPath(Path.Combine(launcherDir, ".."));
+            if (Directory.Exists(parentDir))
+            {
+                searchDirs.Add(parentDir);
+            }
+            
+            // 上上级目录
+            var grandparentDir = Path.GetFullPath(Path.Combine(launcherDir, "..", ".."));
+            if (Directory.Exists(grandparentDir))
+            {
+                searchDirs.Add(grandparentDir);
+            }
+            
+            // AppRoot 及其上级
+            if (!string.IsNullOrWhiteSpace(_appRoot) && Directory.Exists(_appRoot))
+            {
+                searchDirs.Add(_appRoot);
+                var appParent = Path.GetFullPath(Path.Combine(_appRoot, ".."));
+                if (Directory.Exists(appParent))
+                {
+                    searchDirs.Add(appParent);
+                }
+            }
+            
+            // 去重后搜索
+            foreach (var dir in searchDirs.Distinct(StringComparer.OrdinalIgnoreCase))
+            {
+                // 直接搜索
+                var directPath = Path.Combine(dir, context.ExecutableName);
+                if (File.Exists(directPath))
+                {
+                    return directPath;
+                }
+                
+                // 搜索子目录（一层）
+                if (Directory.Exists(dir))
+                {
+                    foreach (var subDir in Directory.GetDirectories(dir))
+                    {
+                        var subPath = Path.Combine(subDir, context.ExecutableName);
+                        if (File.Exists(subPath))
+                        {
+                            return subPath;
+                        }
+                    }
+                }
+            }
+        }
+        catch
+        {
+            // 忽略搜索错误
+        }
+        
+        return null;
+    }
+
+    /// <summary>
+    /// 搜索开发路径
+    /// </summary>
+    private string? SearchDevelopmentPaths(SearchContext context)
+    {
+        // 获取 Launcher 所在目录
+        var launcherDir = AppContext.BaseDirectory;
+
+        // 动态构建可能的开发路径（支持不同的项目结构）
+        var possiblePaths = new List<string>();
+
+        // 从解决方案根目录搜索（支持不同的解决方案结构）
+        var solutionRoot = FindSolutionRoot(launcherDir);
+        if (!string.IsNullOrWhiteSpace(solutionRoot))
+        {
+            // 搜索所有可能的 bin 目录
+            possiblePaths.AddRange(SearchBinDirectories(solutionRoot, context.ExecutableName));
+        }
+
+        // 添加硬编码的备用路径
+        possiblePaths.AddRange(new[]
+        {
+            Path.Combine(launcherDir, "..", "..", "LanMountainDesktop", "bin", "Debug", "net10.0", context.ExecutableName),
+            Path.Combine(launcherDir, "..", "..", "LanMountainDesktop", "bin", "Release", "net10.0", context.ExecutableName),
+            Path.Combine(launcherDir, "..", "LanMountainDesktop", "bin", "Debug", "net10.0", context.ExecutableName),
+            Path.Combine(launcherDir, "..", "LanMountainDesktop", "bin", "Release", "net10.0", context.ExecutableName),
+        });
+
+        foreach (var path in possiblePaths.Select(Path.GetFullPath).Distinct())
+        {
+            if (File.Exists(path))
+            {
+                return path;
+            }
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// 搜索额外的配置路径
+    /// </summary>
+    private string? SearchAdditionalPaths(SearchContext context)
+    {
+        if (_options.AdditionalSearchPaths == null || !_options.AdditionalSearchPaths.Any())
+        {
+            return null;
+        }
+
+        foreach (var pattern in _options.AdditionalSearchPaths)
+        {
+            try
+            {
+                // 替换变量
+                var expandedPattern = ExpandVariables(pattern);
+
+                // 支持通配符
+                if (expandedPattern.Contains('*') || expandedPattern.Contains('?'))
+                {
+                    var dir = Path.GetDirectoryName(expandedPattern) ?? _appRoot;
+                    var filePattern = Path.GetFileName(expandedPattern);
+
+                    if (Directory.Exists(dir))
+                    {
+                        var matches = Directory.GetFiles(dir, filePattern, SearchOption.TopDirectoryOnly);
+                        var validMatch = matches.FirstOrDefault(File.Exists);
+                        if (validMatch != null)
+                        {
+                            return validMatch;
+                        }
+                    }
+                }
+                else if (File.Exists(expandedPattern))
+                {
+                    return expandedPattern;
+                }
+            }
+            catch
+            {
+                // 忽略搜索错误
+            }
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// 递归搜索
+    /// </summary>
+    private string? SearchRecursively(SearchContext context)
+    {
+        try
+        {
+            var searchDirs = new[] { _appRoot, Path.GetFullPath(Path.Combine(_appRoot, "..")) };
+
+            foreach (var searchDir in searchDirs.Where(Directory.Exists))
+            {
+                var result = SearchDirectoryRecursively(searchDir, context.ExecutableName, 0);
+                if (result != null)
+                {
+                    return result;
+                }
+            }
+        }
+        catch
+        {
+            // 忽略递归搜索错误
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// 递归搜索目录
+    /// </summary>
+    private string? SearchDirectoryRecursively(string dir, string executableName, int depth)
+    {
+        if (depth > _options.MaxRecursionDepth)
+        {
+            return null;
+        }
+
+        try
+        {
+            // 检查当前目录
+            var directPath = Path.Combine(dir, executableName);
+            if (File.Exists(directPath))
+            {
+                return directPath;
+            }
+
+            // 检查子目录
+            foreach (var subDir in Directory.GetDirectories(dir))
+            {
+                // 跳过某些目录
+                var dirName = Path.GetFileName(subDir).ToLowerInvariant();
+                if (dirName is ".git" or "node_modules" or ".vs" or "obj" or ".launcher")
+                {
+                    continue;
+                }
+
+                var result = SearchDirectoryRecursively(subDir, executableName, depth + 1);
+                if (result != null)
+                {
+                    return result;
+                }
+            }
+        }
+        catch
+        {
+            // 忽略访问错误
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// 查找解决方案根目录
+    /// </summary>
+    private string? FindSolutionRoot(string startDir)
+    {
+        var current = new DirectoryInfo(startDir);
+        while (current != null)
+        {
+            // 查找 .sln 文件
+            if (current.GetFiles("*.sln").Any())
+            {
+                return current.FullName;
+            }
+
+            // 查找 .git 目录作为备选
+            if (current.GetDirectories(".git").Any())
+            {
+                return current.FullName;
+            }
+
+            current = current.Parent;
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// 搜索 bin 目录
+    /// </summary>
+    private IEnumerable<string> SearchBinDirectories(string root, string executableName)
+    {
+        var results = new List<string>();
+
+        try
+        {
+            // 查找所有 bin 目录
+            var binDirs = Directory.GetDirectories(root, "bin", SearchOption.AllDirectories);
+
+            foreach (var binDir in binDirs)
+            {
+                // 检查 Debug 和 Release 子目录
+                var configDirs = new[] { "Debug", "Release" };
+                foreach (var config in configDirs)
+                {
+                    var configPath = Path.Combine(binDir, config);
+                    if (Directory.Exists(configPath))
+                    {
+                        // 检查所有 net* 子目录
+                        var frameworkDirs = Directory.GetDirectories(configPath, "net*");
+                        foreach (var fwDir in frameworkDirs)
+                        {
+                            var exePath = Path.Combine(fwDir, executableName);
+                            if (File.Exists(exePath))
+                            {
+                                results.Add(exePath);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch
+        {
+            // 忽略搜索错误
+        }
+
+        return results;
+    }
+
+    /// <summary>
+    /// 验证路径并返回
+    /// </summary>
+    private string? ValidateAndReturn(string path, string source)
+    {
+        if (File.Exists(path))
+        {
+            Debug.WriteLine($"Found host executable from {source}: {path}");
+            return path;
+        }
+
+        // 尝试添加 .exe（Windows）
+        if (OperatingSystem.IsWindows() && !path.EndsWith(".exe", StringComparison.OrdinalIgnoreCase))
+        {
+            var withExe = path + ".exe";
+            if (File.Exists(withExe))
+            {
+                Debug.WriteLine($"Found host executable from {source}: {withExe}");
+                return withExe;
+            }
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// 获取可执行文件名
+    /// </summary>
+    private string GetExecutableName()
+    {
+        var name = _options.ExecutableName;
+        if (OperatingSystem.IsWindows() && !name.EndsWith(".exe", StringComparison.OrdinalIgnoreCase))
+        {
+            name += ".exe";
+        }
+        return name;
+    }
+
+    /// <summary>
+    /// 展开路径变量
+    /// </summary>
+    private string ExpandVariables(string path)
+    {
+        return path
+            .Replace("${AppRoot}", _appRoot)
+            .Replace("${BaseDirectory}", AppContext.BaseDirectory)
+            .Replace("${UserProfile}", Environment.GetFolderPath(Environment.SpecialFolder.UserProfile))
+            .Replace("${LocalAppData}", Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData));
+    }
+
+    /// <summary>
+    /// 从目录名解析版本
+    /// </summary>
+    private static Version ParseVersionFromDirectoryName(string path)
+    {
+        var fileName = Path.GetFileName(path);
+        if (string.IsNullOrWhiteSpace(fileName))
+        {
+            return new Version(0, 0, 0);
+        }
+
+        var segments = fileName.Split('-');
+        if (segments.Length < 2)
+        {
+            return new Version(0, 0, 0);
+        }
+
+        return Version.TryParse(segments[1], out var version) ? version : new Version(0, 0, 0);
+    }
+
+    /// <summary>
+    /// 搜索上下文
+    /// </summary>
+    private class SearchContext
+    {
+        public required string ExecutableName { get; set; }
+        public required string AppRoot { get; set; }
+        public required HostDiscoveryOptions Options { get; set; }
+    }
+
+    /// <summary>
+    /// 发现配置文件
+    /// </summary>
+    private class HostDiscoveryConfig
+    {
+        public string? HostPath { get; set; }
+        public List<string>? AdditionalPaths { get; set; }
+    }
+}

LanMountainDesktop.Launcher/Services/HostDiscoveryOptions.cs

@@ -0,0 +1,47 @@
+namespace LanMountainDesktop.Launcher.Services;
+
+/// <summary>
+/// 主程序发现选项
+/// </summary>
+public sealed class HostDiscoveryOptions
+{
+    /// <summary>
+    /// 可执行文件名（Windows 下自动添加 .exe）
+    /// </summary>
+    public string ExecutableName { get; set; } = "LanMountainDesktop";
+
+    /// <summary>
+    /// 额外的搜索路径（支持通配符）
+    /// </summary>
+    public List<string> AdditionalSearchPaths { get; set; } = new();
+
+    /// <summary>
+    /// 是否递归搜索子目录
+    /// </summary>
+    public bool RecursiveSearch { get; set; } = false;
+
+    /// <summary>
+    /// 递归搜索的最大深度
+    /// </summary>
+    public int MaxRecursionDepth { get; set; } = 3;
+
+    /// <summary>
+    /// 环境变量名称，用于指定自定义路径
+    /// </summary>
+    public string? CustomPathEnvVar { get; set; } = "LMD_HOST_PATH";
+
+    /// <summary>
+    /// 配置文件路径（相对于 app root）
+    /// </summary>
+    public string? ConfigFileName { get; set; } = "host-discovery.json";
+
+    /// <summary>
+    /// 是否优先使用开发模式配置
+    /// </summary>
+    public bool PreferDevModeConfig { get; set; } = true;
+
+    /// <summary>
+    /// 搜索超时（毫秒）
+    /// </summary>
+    public int SearchTimeoutMs { get; set; } = 5000;
+}

LanMountainDesktop.Launcher/Services/ISplashStageReporter.cs

@@ -3,4 +3,9 @@ namespace LanMountainDesktop.Launcher.Services;
 internal interface ISplashStageReporter
 {
     void Report(string stage, string message);
+    
+    /// <summary>
+    /// 报告阶段和进度（0-100）
+    /// </summary>
+    void ReportStage(string stage, int progress);
 }

LanMountainDesktop.Launcher/Services/Ipc/LauncherIpcServer.cs

@@ -1,3 +1,4 @@
+using System.Buffers;
 using System.IO.Pipes;
 using System.Text.Json;
 using LanMountainDesktop.Shared.Contracts.Launcher;
@@ -6,81 +7,164 @@ namespace LanMountainDesktop.Launcher.Services.Ipc;
 
 /// <summary>
 /// Launcher IPC 服务端 - 接收主程序的启动进度报告
+/// 采用持久连接 + 长度前缀协议，支持客户端在同一连接上多次发送消息。
+/// 跨平台实现：Windows 使用命名管道，Linux/macOS 使用 Unix 域套接字
 /// </summary>
 public class LauncherIpcServer : IDisposable
 {
     private readonly CancellationTokenSource _cts = new();
-    private NamedPipeServerStream? _pipeServer;
     private readonly Action<StartupProgressMessage> _onProgress;
     private Task? _listenTask;
-    
+    private NamedPipeServerStream? _currentPipe;
+
+    /// <summary>
+    /// 协议：每条消息以 4 字节小端 int32 长度前缀开头，后跟 UTF-8 JSON 正文。
+    /// 这在 Windows Message 模式和 Unix Byte 模式下均能可靠工作。
+    /// </summary>
+    private const int LengthPrefixSize = 4;
+
     public LauncherIpcServer(Action<StartupProgressMessage> onProgress)
     {
         _onProgress = onProgress;
     }
-    
+
     /// <summary>
     /// 启动 IPC 服务端监听
     /// </summary>
     public void Start()
     {
-        _listenTask = Task.Run(async () =>
+        _listenTask = Task.Run(ListenLoopAsync, _cts.Token);
+    }
+
+    private async Task ListenLoopAsync()
+    {
+        while (!_cts.Token.IsCancellationRequested)
         {
-            while (!_cts.Token.IsCancellationRequested)
+            NamedPipeServerStream? pipe = null;
+            try
             {
+                pipe = new NamedPipeServerStream(
+                    LauncherIpcConstants.PipeName,
+                    PipeDirection.In,
+                    1,
+                    PipeTransmissionMode.Byte);
+
+                _currentPipe = pipe;
+                await pipe.WaitForConnectionAsync(_cts.Token);
+
+                // 持久连接：在同一连接上循环读取多条消息，直到客户端断开
+                await ReadMessagesFromConnectionAsync(pipe, _cts.Token);
+            }
+            catch (OperationCanceledException)
+            {
+                break;
+            }
+            catch (IOException)
+            {
+                // 客户端断开连接，继续等待新连接
+                continue;
+            }
+            catch (ObjectDisposedException)
+            {
+                break;
+            }
+            catch (Exception ex)
+            {
+                Console.Error.WriteLine($"IPC listen error: {ex.Message}");
                 try
                 {
-                    _pipeServer = new NamedPipeServerStream(
-                        LauncherIpcConstants.PipeName,
-                        PipeDirection.In,
-                        1,
-                        PipeTransmissionMode.Message);
-                    
-                    await _pipeServer.WaitForConnectionAsync(_cts.Token);
-                    
-                    using var reader = new StreamReader(_pipeServer);
-                    var json = await reader.ReadToEndAsync(_cts.Token);
-                    
-                    if (!string.IsNullOrEmpty(json))
-                    {
-                        try
-                        {
-                            var message = JsonSerializer.Deserialize<StartupProgressMessage>(json);
-                            if (message != null)
-                            {
-                                _onProgress(message);
-                            }
-                        }
-                        catch (JsonException)
-                        {
-                            // 忽略解析错误
-                        }
-                    }
-                    
-                    try
-                    {
-                        _pipeServer.Disconnect();
-                    }
-                    catch { }
+                    await Task.Delay(200, _cts.Token);
                 }
                 catch (OperationCanceledException)
                 {
                     break;
                 }
-                catch (IOException)
+            }
+            finally
+            {
+                try
                 {
-                    // 管道断开，继续监听
-                    continue;
+                    pipe?.Dispose();
                 }
-                catch (Exception ex)
+                catch { }
+
+                if (ReferenceEquals(_currentPipe, pipe))
                 {
-                    Console.Error.WriteLine($"IPC error: {ex.Message}");
-                    await Task.Delay(100, _cts.Token);
+                    _currentPipe = null;
                 }
             }
-        }, _cts.Token);
+        }
     }
-    
+
+    /// <summary>
+    /// 从已连接的管道中持续读取消息，直到连接断开或取消
+    /// </summary>
+    private async Task ReadMessagesFromConnectionAsync(NamedPipeServerStream pipe, CancellationToken cancellationToken)
+    {
+        var lengthBuffer = ArrayPool<byte>.Shared.Rent(LengthPrefixSize);
+        try
+        {
+            while (pipe.IsConnected && !cancellationToken.IsCancellationRequested)
+            {
+                // 1. 读取 4 字节长度前缀
+                var totalRead = 0;
+                while (totalRead < LengthPrefixSize)
+                {
+                    var read = await pipe.ReadAsync(lengthBuffer.AsMemory(totalRead, LengthPrefixSize - totalRead), cancellationToken);
+                    if (read == 0)
+                    {
+                        // 连接已关闭
+                        return;
+                    }
+                    totalRead += read;
+                }
+
+                var payloadLength = BitConverter.ToInt32(lengthBuffer, 0);
+                if (payloadLength <= 0 || payloadLength > 1024 * 1024) // 最大 1MB 单条消息
+                {
+                    // 无效长度，跳过此连接
+                    return;
+                }
+
+                // 2. 读取消息正文
+                var payloadBuffer = ArrayPool<byte>.Shared.Rent(payloadLength);
+                try
+                {
+                    totalRead = 0;
+                    while (totalRead < payloadLength)
+                    {
+                        var read = await pipe.ReadAsync(payloadBuffer.AsMemory(totalRead, payloadLength - totalRead), cancellationToken);
+                        if (read == 0)
+                        {
+                            return;
+                        }
+                        totalRead += read;
+                    }
+
+                    // 3. 反序列化并回调
+                    var json = System.Text.Encoding.UTF8.GetString(payloadBuffer, 0, payloadLength);
+                    var message = JsonSerializer.Deserialize<StartupProgressMessage>(json);
+                    if (message is not null)
+                    {
+                        _onProgress(message);
+                    }
+                }
+                catch (JsonException)
+                {
+                    // 忽略解析错误，继续读取下一条消息
+                }
+                finally
+                {
+                    ArrayPool<byte>.Shared.Return(payloadBuffer);
+                }
+            }
+        }
+        finally
+        {
+            ArrayPool<byte>.Shared.Return(lengthBuffer);
+        }
+    }
+
     /// <summary>
     /// 停止 IPC 服务端
     /// </summary>
@@ -89,17 +173,16 @@ public class LauncherIpcServer : IDisposable
         _cts.Cancel();
         try
         {
-            _pipeServer?.Disconnect();
+            _currentPipe?.Dispose();
         }
         catch { }
     }
-    
+
     public void Dispose()
     {
         Stop();
-        _pipeServer?.Dispose();
         _cts.Dispose();
-        
+
         try
         {
             _listenTask?.Wait(TimeSpan.FromSeconds(2));

LanMountainDesktop.Launcher/Services/LauncherFlowCoordinator.cs

@@ -34,15 +34,15 @@ internal sealed class LauncherFlowCoordinator
         _oobeSteps = [new WelcomeOobeStep(_oobeStateService)];
     }
 
-    public async Task<LauncherResult> RunAsync()
+    public async Task<LauncherResult> RunAsync(SplashWindow? existingSplashWindow = null)
     {
         try
         {
             // 清理待删除的旧版本
             _deploymentLocator.CleanupDestroyedDeployments();
 
-            // 显示 Splash 窗口
-            var splashWindow = await Dispatcher.UIThread.InvokeAsync(() =>
+            // 使用传入的 Splash 窗口或创建新的
+            var splashWindow = existingSplashWindow ?? await Dispatcher.UIThread.InvokeAsync(() =>
             {
                 var window = new SplashWindow();
                 window.Show();
@@ -51,12 +51,29 @@ internal sealed class LauncherFlowCoordinator
 
             var reporter = (ISplashStageReporter)splashWindow;
             
+            // 跟踪主程序是否已就绪，就绪后自动关闭 Splash 窗口
+            var hostReadyTcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+            
             // 启动 IPC 服务端监听主程序进度
             using var ipcServer = new LauncherIpcServer(msg =>
             {
                 Dispatcher.UIThread.Post(() =>
                 {
-                    reporter.Report(msg.Stage.ToString().ToLower(), msg.Message ?? "");
+                    try
+                    {
+                        reporter.Report(msg.Stage.ToString().ToLower(), msg.Message ?? "");
+                        
+                        // 主程序报告就绪后，关闭 Splash 窗口
+                        if (msg.Stage == StartupStage.Ready && splashWindow.IsVisible && splashWindow.IsLoaded)
+                        {
+                            splashWindow.Close();
+                            hostReadyTcs.TrySetResult();
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        Console.Error.WriteLine($"[LauncherFlowCoordinator] Error in IPC callback: {ex.Message}");
+                    }
                 });
             });
             ipcServer.Start();
@@ -94,14 +111,53 @@ internal sealed class LauncherFlowCoordinator
 
                 // 启动主程序
                 reporter.Report("launch", "正在启动...");
-                var hostResult = await LaunchHostWithIpcAsync();
+                var (hostResult, hostProcess) = await LaunchHostWithIpcAsync(splashWindow);
                 if (!hostResult.Success)
                 {
                     return hostResult;
                 }
 
-                // 等待主程序就绪或超时
-                await Task.Delay(TimeSpan.FromSeconds(30));
+                // 等待主程序进程退出。Launcher 作为后台守护进程保持运行，
+                // 维持 IPC 管道服务端供主程序报告启动进度。
+                if (hostProcess is not null)
+                {
+                    // 等待主程序就绪或进程退出（取先发生者）
+                    // 如果主程序在 60 秒内未报告 Ready，也关闭 Splash 窗口作为超时保护
+                    var readyOrTimeout = Task.WhenAny(
+                        hostReadyTcs.Task,
+                        Task.Delay(TimeSpan.FromSeconds(60)));
+                    
+                    var processExitTask = hostProcess.WaitForExitAsync();
+                    
+                    // 先等待就绪/超时，然后等待进程退出
+                    await readyOrTimeout;
+                    
+                    // 如果 Splash 窗口仍然打开（超时情况），关闭它
+                    if (splashWindow.IsVisible)
+                    {
+                        await Dispatcher.UIThread.InvokeAsync(() =>
+                        {
+                            try
+                            {
+                                if (splashWindow.IsVisible && splashWindow.IsLoaded)
+                                {
+                                    splashWindow.Close();
+                                }
+                            }
+                            catch (Exception ex)
+                            {
+                                Console.Error.WriteLine($"[LauncherFlowCoordinator] Error closing splash window on timeout: {ex.Message}");
+                            }
+                        });
+                    }
+                    
+                    await processExitTask;
+                }
+                else
+                {
+                    // 如果无法获取进程引用，退回到有限等待
+                    await Task.Delay(TimeSpan.FromSeconds(30));
+                }
 
                 return new LauncherResult
                 {
@@ -113,7 +169,22 @@ internal sealed class LauncherFlowCoordinator
             }
             finally
             {
-                await Dispatcher.UIThread.InvokeAsync(() => splashWindow.Close());
+                // Splash 窗口可能已由 IPC Ready 回调关闭，这里做安全清理
+                await Dispatcher.UIThread.InvokeAsync(() =>
+                {
+                    try
+                    {
+                        if (splashWindow.IsVisible && splashWindow.IsLoaded)
+                        {
+                            splashWindow.Close();
+                            Console.WriteLine("[LauncherFlowCoordinator] Splash window closed in finally block");
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        Console.Error.WriteLine($"[LauncherFlowCoordinator] Error closing splash window in finally: {ex.Message}");
+                    }
+                });
             }
         }
         catch (Exception ex)
@@ -124,12 +195,12 @@ internal sealed class LauncherFlowCoordinator
                 Stage = "launch",
                 Code = "exception",
                 Message = ex.Message,
-                ErrorMessage = ex.Message
+                ErrorMessage = ex.ToString()
             };
         }
     }
 
-    private async Task<LauncherResult> LaunchHostWithIpcAsync(string? customHostPath = null)
+    private async Task<(LauncherResult Result, Process? Process)> LaunchHostWithIpcAsync(SplashWindow? splashWindow = null, string? customHostPath = null)
     {
         // 优先使用自定义路径（调试模式选择的路径）
         var hostPath = customHostPath ?? _deploymentLocator.ResolveHostExecutablePath();
@@ -145,19 +216,19 @@ internal sealed class LauncherFlowCoordinator
                 // 用户选择重试，如果有选择路径则使用，否则重新尝试
                 if (!string.IsNullOrWhiteSpace(selectedPath))
                 {
-                    return await LaunchHostWithIpcAsync(selectedPath);
+                    return await LaunchHostWithIpcAsync(splashWindow, selectedPath);
                 }
-                return await LaunchHostWithIpcAsync();
+                return await LaunchHostWithIpcAsync(splashWindow);
             }
             
             // 用户选择退出
-            return new LauncherResult
+            return (new LauncherResult
             {
                 Success = false,
                 Stage = "launchHost",
                 Code = "host_not_found",
                 Message = "LanMountainDesktop host executable not found."
-            };
+            }, null);
         }
 
         if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
@@ -168,24 +239,40 @@ internal sealed class LauncherFlowCoordinator
         var processStartInfo = new ProcessStartInfo
         {
             FileName = hostPath,
-            UseShellExecute = true,
+            UseShellExecute = false,
             WorkingDirectory = Path.GetDirectoryName(hostPath) ?? _deploymentLocator.GetAppRoot()
         };
 
+        // 转发命令行参数给主程序（排除 Launcher 自己的命令和选项）
+        foreach (var arg in _context.RawArgs)
+        {
+            // 跳过 Launcher 自己的命令和选项，只传递用户原始参数
+            if (arg == _context.Command || arg == _context.SubCommand || arg.StartsWith("--"))
+            {
+                continue;
+            }
+            processStartInfo.ArgumentList.Add(arg);
+        }
+
         // 传递环境变量供 IPC 使用
         processStartInfo.EnvironmentVariables[LauncherIpcConstants.LauncherPidEnvVar] = 
             Environment.ProcessId.ToString();
         processStartInfo.EnvironmentVariables[LauncherIpcConstants.PackageRootEnvVar] = 
             _deploymentLocator.GetAppRoot();
+        
+        // 传递版本信息
+        var versionInfo = _deploymentLocator.GetVersionInfo();
+        processStartInfo.EnvironmentVariables[LauncherIpcConstants.VersionEnvVar] = versionInfo.Version;
+        processStartInfo.EnvironmentVariables[LauncherIpcConstants.CodenameEnvVar] = versionInfo.Codename;
 
-        Process.Start(processStartInfo);
-        return new LauncherResult
+        var hostProcess = Process.Start(processStartInfo);
+        return (new LauncherResult
         {
             Success = true,
             Stage = "launchHost",
             Code = "ok",
             Message = "Host launched."
-        };
+        }, hostProcess);
     }
 
     /// <summary>
@@ -193,19 +280,65 @@ internal sealed class LauncherFlowCoordinator
     /// </summary>
     private async Task<(ErrorWindowResult Result, string? CustomPath)> ShowHostNotFoundErrorAsync()
     {
-        return await Dispatcher.UIThread.InvokeAsync(async () =>
+        ErrorWindow? errorWindow = null;
+        
+        // 在 UI 线程创建并显示错误窗口
+        await Dispatcher.UIThread.InvokeAsync(() =>
         {
-            var errorWindow = new ErrorWindow();
-            errorWindow.SetErrorMessage("找不到阑山桌面应用程序。");
-            errorWindow.Show();
-            
-            var result = await errorWindow.WaitForChoiceAsync();
-            var customPath = errorWindow.GetCustomHostPath();
-            
-            await Dispatcher.UIThread.InvokeAsync(() => errorWindow.Close());
-            
-            return (result, customPath);
+            try
+            {
+                errorWindow = new ErrorWindow();
+                errorWindow.SetErrorMessage("找不到阑山桌面应用程序。");
+                errorWindow.Show();
+                Console.WriteLine("[LauncherFlowCoordinator] ErrorWindow shown for host not found");
+            }
+            catch (Exception ex)
+            {
+                Console.Error.WriteLine($"[LauncherFlowCoordinator] Failed to show ErrorWindow: {ex.Message}");
+            }
         });
+        
+        if (errorWindow is null)
+        {
+            Console.Error.WriteLine("[LauncherFlowCoordinator] ErrorWindow is null, cannot wait for choice");
+            return (ErrorWindowResult.Exit, null);
+        }
+        
+        // 等待用户选择
+        ErrorWindowResult result;
+        string? customPath;
+        
+        try
+        {
+            result = await errorWindow.WaitForChoiceAsync();
+            customPath = errorWindow.GetCustomHostPath();
+            Console.WriteLine($"[LauncherFlowCoordinator] ErrorWindow result: {result}, customPath: {customPath != null}");
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine($"[LauncherFlowCoordinator] Error waiting for choice: {ex.Message}");
+            result = ErrorWindowResult.Exit;
+            customPath = null;
+        }
+        
+        // 安全关闭错误窗口
+        await Dispatcher.UIThread.InvokeAsync(() =>
+        {
+            try
+            {
+                if (errorWindow.IsVisible && errorWindow.IsLoaded)
+                {
+                    errorWindow.Close();
+                    Console.WriteLine("[LauncherFlowCoordinator] ErrorWindow closed successfully");
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.Error.WriteLine($"[LauncherFlowCoordinator] Error closing ErrorWindow: {ex.Message}");
+            }
+        });
+        
+        return (result, customPath);
     }
 
     private static void EnsureExecutable(string path)
@@ -237,22 +370,72 @@ internal sealed class LauncherFlowCoordinator
 
         public async Task RunAsync(CancellationToken cancellationToken)
         {
-            var window = await Dispatcher.UIThread.InvokeAsync(() =>
-            {
-                var oobeWindow = new OobeWindow();
-                oobeWindow.Show();
-                return oobeWindow;
-            });
-
+            OobeWindow? window = null;
+            
             try
             {
-                using var _ = cancellationToken.Register(() => window.Close());
+                window = await Dispatcher.UIThread.InvokeAsync(() =>
+                {
+                    try
+                    {
+                        var oobeWindow = new OobeWindow();
+                        oobeWindow.Show();
+                        Console.WriteLine("[WelcomeOobeStep] OOBE window shown");
+                        return oobeWindow;
+                    }
+                    catch (Exception ex)
+                    {
+                        Console.Error.WriteLine($"[WelcomeOobeStep] Failed to show OOBE window: {ex.Message}");
+                        return null;
+                    }
+                });
+
+                if (window is null)
+                {
+                    Console.Error.WriteLine("[WelcomeOobeStep] OOBE window is null, skipping OOBE");
+                    _stateService.MarkCompleted();
+                    return;
+                }
+
+                using var _ = cancellationToken.Register(() =>
+                {
+                    try
+                    {
+                        if (window.IsVisible && window.IsLoaded)
+                        {
+                            window.Close();
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        Console.Error.WriteLine($"[WelcomeOobeStep] Error closing OOBE window on cancel: {ex.Message}");
+                    }
+                });
+                
                 await window.WaitForEnterAsync().ConfigureAwait(false);
+                Console.WriteLine("[WelcomeOobeStep] OOBE completed by user");
                 _stateService.MarkCompleted();
             }
             finally
             {
-                await Dispatcher.UIThread.InvokeAsync(() => window.Close());
+                if (window is not null)
+                {
+                    await Dispatcher.UIThread.InvokeAsync(() =>
+                    {
+                        try
+                        {
+                            if (window.IsVisible && window.IsLoaded)
+                            {
+                                window.Close();
+                                Console.WriteLine("[WelcomeOobeStep] OOBE window closed in finally");
+                            }
+                        }
+                        catch (Exception ex)
+                        {
+                            Console.Error.WriteLine($"[WelcomeOobeStep] Error closing OOBE window in finally: {ex.Message}");
+                        }
+                    });
+                }
             }
         }
     }

LanMountainDesktop.Launcher/Services/OobeStateService.cs

@@ -6,7 +6,12 @@ internal sealed class OobeStateService
 
     public OobeStateService(string appRoot)
     {
-        var stateDir = Path.Combine(appRoot, ".launcher", "state");
+        // 将 OOBE 状态文件存储在用户可写的 LocalApplicationData 目录中，
+        // 而不是安装目录（Program Files 下普通用户没有写入权限）。
+        var appDataDir = Path.Combine(
+            Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
+            "LanMountainDesktop");
+        var stateDir = Path.Combine(appDataDir, ".launcher", "state");
         Directory.CreateDirectory(stateDir);
         _markerPath = Path.Combine(stateDir, "first_run_completed");
     }