refactor(launcher): reorganize into responsibility folders

Co-authored-by: Cursor <cursoragent@cursor.com>

LanMountainDesktop.Launcher/Infrastructure/Commands.cs

@@ -0,0 +1,191 @@
+using System.Text;
+using System.Text.Json;
+using LanMountainDesktop.Launcher.Models;
+
+namespace LanMountainDesktop.Launcher.Infrastructure;
+
+internal static class Commands
+{
+    public static async Task<int> RunLegacyPluginInstallAsync(CommandContext context, PluginInstallerService installer)
+    {
+        var resultPath = context.GetOption("result");
+        LauncherResult result;
+        try
+        {
+            var source = context.GetOption("source") ?? string.Empty;
+            var pluginsDir = context.GetOption("plugins-dir") ?? string.Empty;
+            result = installer.InstallPackage(source, pluginsDir);
+        }
+        catch (Exception ex)
+        {
+            result = new LauncherResult
+            {
+                Success = false,
+                Stage = "plugin.install",
+                Code = "failed",
+                Message = ex.Message,
+                ErrorMessage = ex.Message
+            };
+        }
+
+        await WriteResultIfNeededAsync(resultPath, result).ConfigureAwait(false);
+        return result.Success ? 0 : 1;
+    }
+
+    public static async Task<int> RunCliCommandAsync(CommandContext context)
+    {
+        var appRoot = ResolveAppRoot(context);
+        var deploymentLocator = new DeploymentLocator(appRoot);
+        var updateEngine = new UpdateEngineService(deploymentLocator);
+        var pluginInstaller = new PluginInstallerService();
+        var pluginUpgrades = new PluginUpgradeQueueService(pluginInstaller);
+
+        LauncherResult result;
+        try
+        {
+            result = await ExecuteCoreAsync(context, updateEngine, pluginInstaller, pluginUpgrades).ConfigureAwait(false);
+        }
+        catch (Exception ex)
+        {
+            result = new LauncherResult
+            {
+                Success = false,
+                Stage = "command",
+                Code = "exception",
+                Message = ex.Message,
+                ErrorMessage = ex.Message
+            };
+        }
+
+        await WriteResultIfNeededAsync(context.GetOption("result"), result).ConfigureAwait(false);
+        return result.Success ? 0 : 1;
+    }
+
+    private static async Task<LauncherResult> ExecuteCoreAsync(
+        CommandContext context,
+        UpdateEngineService updateEngine,
+        PluginInstallerService pluginInstaller,
+        PluginUpgradeQueueService pluginUpgrades)
+    {
+        switch (context.Command.ToLowerInvariant())
+        {
+            case "update":
+                return await ExecuteUpdateAsync(context, updateEngine).ConfigureAwait(false);
+            case "plugin":
+                return ExecutePluginCommand(context, pluginInstaller, pluginUpgrades);
+            default:
+                return new LauncherResult
+                {
+                    Success = false,
+                    Stage = "command",
+                    Code = "unsupported_command",
+                    Message = $"Unsupported command '{context.Command}'."
+                };
+        }
+    }
+
+    private static async Task<LauncherResult> ExecuteUpdateAsync(CommandContext context, UpdateEngineService updateEngine)
+    {
+        return context.SubCommand.ToLowerInvariant() switch
+        {
+            "check" => updateEngine.CheckPendingUpdate(),
+            "apply" => await updateEngine.ApplyPendingUpdateAsync().ConfigureAwait(false),
+            "rollback" => updateEngine.RollbackLatest(),
+            "download" => await DownloadUpdatePayloadAsync(context, updateEngine).ConfigureAwait(false),
+            _ => new LauncherResult
+            {
+                Success = false,
+                Stage = "update",
+                Code = "unsupported_subcommand",
+                Message = $"Unsupported update sub-command '{context.SubCommand}'."
+            }
+        };
+    }
+
+    private static async Task<LauncherResult> DownloadUpdatePayloadAsync(CommandContext context, UpdateEngineService updateEngine)
+    {
+        return await updateEngine.DownloadAsync(
+            context.GetOption("manifest-url") ?? throw new InvalidOperationException("Missing --manifest-url."),
+            context.GetOption("signature-url") ?? throw new InvalidOperationException("Missing --signature-url."),
+            context.GetOption("archive-url") ?? throw new InvalidOperationException("Missing --archive-url."),
+            CancellationToken.None).ConfigureAwait(false);
+    }
+
+    private static LauncherResult ExecutePluginCommand(
+        CommandContext context,
+        PluginInstallerService pluginInstaller,
+        PluginUpgradeQueueService pluginUpgrades)
+    {
+        switch (context.SubCommand.ToLowerInvariant())
+        {
+            case "install":
+            {
+                var source = context.GetOption("source") ?? throw new InvalidOperationException("Missing --source.");
+                var pluginsDir = context.GetOption("plugins-dir") ?? throw new InvalidOperationException("Missing --plugins-dir.");
+                return pluginInstaller.InstallPackage(source, pluginsDir);
+            }
+            case "update":
+            {
+                var pluginsDir = context.GetOption("plugins-dir") ?? throw new InvalidOperationException("Missing --plugins-dir.");
+                return pluginUpgrades.ApplyPendingUpgrades(pluginsDir);
+            }
+            default:
+                return new LauncherResult
+                {
+                    Success = false,
+                    Stage = "plugin",
+                    Code = "unsupported_subcommand",
+                    Message = $"Unsupported plugin sub-command '{context.SubCommand}'."
+                };
+        }
+    }
+
+    public static async Task WriteResultIfNeededAsync(string? resultPath, LauncherResult result)
+    {
+        if (string.IsNullOrWhiteSpace(resultPath))
+        {
+            return;
+        }
+
+        var fullPath = Path.GetFullPath(resultPath);
+        var dir = Path.GetDirectoryName(fullPath);
+        if (!string.IsNullOrWhiteSpace(dir))
+        {
+            Directory.CreateDirectory(dir);
+        }
+
+        var json = JsonSerializer.Serialize(result, AppJsonContext.Default.LauncherResult);
+        await File.WriteAllTextAsync(fullPath, json, Encoding.UTF8).ConfigureAwait(false);
+    }
+
+    public static string ResolveAppRoot(CommandContext context)
+    {
+        var configured = context.GetOption("app-root");
+        if (!string.IsNullOrWhiteSpace(configured))
+        {
+            return Path.GetFullPath(configured);
+        }
+
+        var launcherDir = Path.GetDirectoryName(Environment.ProcessPath);
+        var baseDir = Path.GetFullPath(!string.IsNullOrWhiteSpace(launcherDir)
+            ? launcherDir
+            : AppContext.BaseDirectory);
+        
+        var appDirs = Directory.GetDirectories(baseDir, "app-*", SearchOption.TopDirectoryOnly);
+        if (appDirs.Length > 0)
+        {
+            return baseDir;
+        }
+        
+        var parent = Path.GetFullPath(Path.Combine(baseDir, ".."));
+        var parentHost = OperatingSystem.IsWindows()
+            ? Path.Combine(parent, "LanMountainDesktop.exe")
+            : Path.Combine(parent, "LanMountainDesktop");
+        if (File.Exists(parentHost))
+        {
+            return parent;
+        }
+        
+        return baseDir;
+    }
+}

LanMountainDesktop.Launcher/Infrastructure/DataLocationResolver.cs

@@ -0,0 +1,295 @@
+using System.Text.Json;
+using LanMountainDesktop.Launcher.Models;
+
+namespace LanMountainDesktop.Launcher.Infrastructure;
+
+/// <summary>
+/// 解析应用数据目录位置。
+/// </summary>
+/// <remarks>
+/// 安装后的目录结构：
+/// <code>
+/// {AppRoot}/                          ← 应用安装根目录
+///   LanMountainDesktop.Launcher.exe   ← Launcher 可执行文件
+///   .Launcher/                        ← Launcher 数据目录（日志、状态、配置等）
+///   app-{version}/                    ← Host 部署目录
+///     LanMountainDesktop.exe
+///     ...
+/// </code>
+///
+/// Launcher 数据目录固定位于应用安装根目录下的 <c>.Launcher</c> 文件夹中，
+/// 与 app-* 部署目录同级。此目录不随数据位置模式改变。
+///
+/// Desktop（Host）数据目录则根据用户选择可位于系统目录或便携目录。
+/// </remarks>
+internal sealed class DataLocationResolver
+{
+    private const string ConfigFileName = "data-location.config.json";
+    private const string DesktopFolderName = "Desktop";
+    private const string LauncherDataFolderName = ".Launcher";
+
+    private readonly string _appRoot;
+    private readonly string _defaultSystemDataPath;
+
+    public DataLocationResolver(string appRoot)
+    {
+        _appRoot = Path.GetFullPath(appRoot);
+        _defaultSystemDataPath = Path.Combine(
+            Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
+            "LanMountainDesktop");
+    }
+
+    public string AppRoot => _appRoot;
+
+    /// <summary>
+    /// 默认系统数据路径（用户目录）
+    /// </summary>
+    public string DefaultSystemDataPath => _defaultSystemDataPath;
+
+    /// <summary>
+    /// 默认便携模式数据路径（应用目录下的 Desktop 文件夹）
+    /// </summary>
+    public string DefaultPortableDataPath => Path.Combine(_appRoot, DesktopFolderName);
+
+    /// <summary>
+    /// Launcher 数据目录，固定位于应用安装根目录下的 .Launcher 文件夹。
+    /// 该目录与 app-* 部署目录同级，不随数据位置模式改变。
+    /// </summary>
+    public string ResolveLauncherDataPath()
+    {
+        return Path.Combine(_appRoot, LauncherDataFolderName);
+    }
+
+    /// <summary>
+    /// 桌面应用数据目录（组件、设置、插件等）
+    /// </summary>
+    public string ResolveDesktopDataPath()
+    {
+        return Path.Combine(ResolveDataRoot(), DesktopFolderName);
+    }
+
+    /// <summary>
+    /// 数据位置配置文件路径（保存在 Launcher 数据目录下）
+    /// </summary>
+    public string ResolveConfigPath()
+    {
+        return Path.Combine(ResolveLauncherDataPath(), ConfigFileName);
+    }
+
+    /// <summary>
+    /// 启动器日志目录
+    /// </summary>
+    public string ResolveLauncherLogsPath()
+    {
+        return Path.Combine(ResolveLauncherDataPath(), "logs");
+    }
+
+    /// <summary>
+    /// 启动器状态目录
+    /// </summary>
+    public string ResolveLauncherStatePath()
+    {
+        return Path.Combine(ResolveLauncherDataPath(), "state");
+    }
+
+    /// <summary>
+    /// 检查是否允许便携模式（应用目录是否可写）
+    /// </summary>
+    public bool IsPortableModeAllowed()
+    {
+        try
+        {
+            var testFile = Path.Combine(_appRoot, $".write-test-{Guid.NewGuid():N}.tmp");
+            File.WriteAllText(testFile, string.Empty);
+            File.Delete(testFile);
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    public DataLocationMode ResolveMode()
+    {
+        var config = LoadConfig();
+        if (config is null)
+        {
+            return DataLocationMode.System;
+        }
+
+        return string.Equals(config.DataLocationMode, "Portable", StringComparison.OrdinalIgnoreCase)
+            ? DataLocationMode.Portable
+            : DataLocationMode.System;
+    }
+
+    /// <summary>
+    /// 解析数据根目录（用户选择的位置）
+    /// </summary>
+    public string ResolveDataRoot()
+    {
+        var config = LoadConfig();
+        return ResolveDataRoot(config);
+    }
+
+    private string ResolveDataRoot(DataLocationConfig? config)
+    {
+        if (config is null)
+        {
+            return _defaultSystemDataPath;
+        }
+
+        if (string.Equals(config.DataLocationMode, "Portable", StringComparison.OrdinalIgnoreCase))
+        {
+            var portablePath = !string.IsNullOrWhiteSpace(config.PortableDataPath)
+                ? config.PortableDataPath
+                : DefaultPortableDataPath;
+            return Path.GetFullPath(portablePath);
+        }
+
+        return !string.IsNullOrWhiteSpace(config.SystemDataPath)
+            ? Path.GetFullPath(config.SystemDataPath)
+            : _defaultSystemDataPath;
+    }
+
+    public DataLocationConfig? LoadConfig()
+    {
+        try
+        {
+            var configPath = ResolveConfigPath();
+            if (!File.Exists(configPath))
+            {
+                return null;
+            }
+
+            var json = File.ReadAllText(configPath);
+            return JsonSerializer.Deserialize(json, AppJsonContext.Default.DataLocationConfig);
+        }
+        catch (Exception ex)
+        {
+            Logger.Warn($"Failed to load data location config. Error='{ex.Message}'.");
+            return null;
+        }
+    }
+
+    public bool SaveConfig(DataLocationConfig config)
+    {
+        try
+        {
+            var launcherDataPath = ResolveLauncherDataPath();
+            Directory.CreateDirectory(launcherDataPath);
+
+            var configPath = ResolveConfigPath();
+            var json = JsonSerializer.Serialize(config, AppJsonContext.Default.DataLocationConfig);
+            File.WriteAllText(configPath, json);
+            return true;
+        }
+        catch (Exception ex)
+        {
+            Logger.Warn($"Failed to save data location config. Error='{ex.Message}'.");
+            return false;
+        }
+    }
+
+    public bool ApplyLocationChoice(DataLocationMode mode, string? customPath = null, bool migrateExistingData = false)
+    {
+        var targetDataRoot = mode == DataLocationMode.Portable && !string.IsNullOrWhiteSpace(customPath)
+            ? Path.GetFullPath(customPath)
+            : _defaultSystemDataPath;
+
+        var config = new DataLocationConfig
+        {
+            DataLocationMode = mode.ToString(),
+            SystemDataPath = _defaultSystemDataPath,
+            PortableDataPath = mode == DataLocationMode.Portable ? targetDataRoot : null
+        };
+
+        // 先创建目录结构
+        try
+        {
+            Directory.CreateDirectory(ResolveLauncherDataPath());
+            Directory.CreateDirectory(Path.Combine(ResolveDataRoot(config), DesktopFolderName));
+        }
+        catch (Exception ex)
+        {
+            Logger.Warn($"Failed to create data directories. Error='{ex.Message}'.");
+            return false;
+        }
+
+        // 保存配置
+        if (!SaveConfig(config))
+        {
+            return false;
+        }
+
+        if (migrateExistingData && mode == DataLocationMode.Portable)
+        {
+            MigrateSystemDataToPortable(targetDataRoot);
+        }
+
+        return true;
+    }
+
+    public bool HasExistingSystemData()
+    {
+        var desktopPath = Path.Combine(_defaultSystemDataPath, DesktopFolderName);
+        if (!Directory.Exists(desktopPath))
+        {
+            return false;
+        }
+
+        var markerFiles = new[]
+        {
+            Path.Combine(desktopPath, "settings.json"),
+            Path.Combine(desktopPath, "component-state.db"),
+            Path.Combine(desktopPath, "app.db")
+        };
+
+        return markerFiles.Any(File.Exists);
+    }
+
+    private void MigrateSystemDataToPortable(string targetDataRoot)
+    {
+        if (!HasExistingSystemData())
+        {
+            return;
+        }
+
+        var sourceDesktopPath = Path.Combine(_defaultSystemDataPath, DesktopFolderName);
+        var targetDesktopPath = Path.Combine(targetDataRoot, DesktopFolderName);
+
+        try
+        {
+            Directory.CreateDirectory(targetDesktopPath);
+
+            // 迁移桌面数据
+            if (Directory.Exists(sourceDesktopPath))
+            {
+                CopyDirectory(sourceDesktopPath, targetDesktopPath);
+            }
+
+            Logger.Info($"Data migration completed. Target='{targetDataRoot}'.");
+        }
+        catch (Exception ex)
+        {
+            Logger.Warn($"Data migration failed. Target='{targetDataRoot}'. Error='{ex.Message}'.");
+        }
+    }
+
+    private static void CopyDirectory(string sourceDir, string destDir)
+    {
+        Directory.CreateDirectory(destDir);
+
+        foreach (var file in Directory.GetFiles(sourceDir))
+        {
+            var destFile = Path.Combine(destDir, Path.GetFileName(file));
+            File.Copy(file, destFile, overwrite: true);
+        }
+
+        foreach (var subDir in Directory.GetDirectories(sourceDir))
+        {
+            var destSubDir = Path.Combine(destDir, Path.GetFileName(subDir));
+            CopyDirectory(subDir, destSubDir);
+        }
+    }
+}

LanMountainDesktop.Launcher/Infrastructure/DeferredSplashStageReporter.cs

@@ -0,0 +1,40 @@
+using Avalonia.Threading;
+using LanMountainDesktop.Launcher.Views;
+
+namespace LanMountainDesktop.Launcher.Infrastructure;
+
+internal sealed class DeferredSplashStageReporter : ISplashStageReporter
+{
+    private ISplashStageReporter? _inner;
+    private readonly List<(string Stage, string Message)> _pending = [];
+
+    public void SetInner(ISplashStageReporter inner)
+    {
+        _inner = inner;
+        foreach (var (stage, message) in _pending)
+        {
+            _inner.Report(stage, message);
+        }
+        _pending.Clear();
+    }
+
+    public void Report(string stage, string message)
+    {
+        if (_inner is not null)
+        {
+            _inner.Report(stage, message);
+        }
+        else
+        {
+            _pending.Add((stage, message));
+        }
+    }
+
+    public void ReportStage(string stage, int progress)
+    {
+        if (_inner is not null)
+        {
+            _inner.ReportStage(stage, progress);
+        }
+    }
+}

LanMountainDesktop.Launcher/Infrastructure/DotNetRuntimeProbe.cs

@@ -0,0 +1,401 @@
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using Microsoft.Win32;
+
+namespace LanMountainDesktop.Launcher.Infrastructure;
+
+internal enum DotNetRuntimeArchitecture
+{
+    X64,
+    X86
+}
+
+internal sealed record DotNetRuntimeInfo(
+    string Name,
+    string Version,
+    string Source,
+    string? Location);
+
+internal sealed record DotNetRuntimeProbeOptions
+{
+    public int RequiredMajorVersion { get; init; } = 10;
+
+    public DotNetRuntimeArchitecture Architecture { get; init; } = DotNetRuntimeProbe.GetCurrentArchitecture();
+
+    public string? ProgramFilesPath { get; init; }
+
+    public string? ProgramFilesX86Path { get; init; }
+
+    public string? LocalAppDataPath { get; init; }
+
+    public IReadOnlyList<string>? DotNetHostCandidates { get; init; }
+
+    public bool IncludeRegistry { get; init; } = true;
+
+    public bool IncludeDotNetCli { get; init; } = true;
+}
+
+internal sealed record DotNetRuntimeProbeResult(
+    bool IsAvailable,
+    int RequiredMajorVersion,
+    DotNetRuntimeArchitecture Architecture,
+    string? DotNetHostPath,
+    IReadOnlyList<string> SearchedPaths,
+    IReadOnlyList<DotNetRuntimeInfo> DetectedRuntimes,
+    string Message)
+{
+    public Dictionary<string, string> ToDetails(string prefix = "dotnetRuntime")
+    {
+        return new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
+        {
+            [$"{prefix}Available"] = IsAvailable.ToString(),
+            [$"{prefix}RequiredMajorVersion"] = RequiredMajorVersion.ToString(),
+            [$"{prefix}Architecture"] = Architecture.ToString(),
+            [$"{prefix}DotNetHostPath"] = DotNetHostPath ?? string.Empty,
+            [$"{prefix}SearchedPaths"] = string.Join(" | ", SearchedPaths),
+            [$"{prefix}DetectedRuntimes"] = string.Join(
+                " | ",
+                DetectedRuntimes.Select(runtime =>
+                    $"{runtime.Name} {runtime.Version} [{runtime.Source}{(string.IsNullOrWhiteSpace(runtime.Location) ? string.Empty : $": {runtime.Location}")}]")),
+            [$"{prefix}Message"] = Message
+        };
+    }
+}
+
+internal static class DotNetRuntimeProbe
+{
+    public const string RequiredSharedFrameworkName = "Microsoft.NETCore.App";
+    public const string WindowsDesktopSharedFrameworkName = "Microsoft.WindowsDesktop.App";
+
+    private static readonly string[] RequiredSharedFrameworkNames =
+    [
+        RequiredSharedFrameworkName,
+        WindowsDesktopSharedFrameworkName
+    ];
+
+    public static DotNetRuntimeProbeResult Probe(DotNetRuntimeProbeOptions? options = null)
+    {
+        options ??= new DotNetRuntimeProbeOptions();
+
+        var searchedPaths = new List<string>();
+        var detected = new List<DotNetRuntimeInfo>();
+        var requiredMajor = options.RequiredMajorVersion;
+
+        var localAppDataRoot = GetLocalAppDataPath(options);
+        var perUserDotnetRoot = !string.IsNullOrWhiteSpace(localAppDataRoot)
+            ? Path.Combine(localAppDataRoot, "dotnet")
+            : null;
+
+        foreach (var frameworkName in RequiredSharedFrameworkNames)
+        {
+            foreach (var basePath in EnumerateDotNetInstallRoots(options))
+            {
+                var sharedFrameworkDirectory = Path.Combine(basePath, "shared", frameworkName);
+                searchedPaths.Add(sharedFrameworkDirectory);
+                var isPerUser = perUserDotnetRoot is not null &&
+                    string.Equals(basePath, perUserDotnetRoot, StringComparison.OrdinalIgnoreCase);
+                AddDirectoryRuntimes(sharedFrameworkDirectory, frameworkName,
+                    isPerUser ? "shared-framework-directory-per-user" : "shared-framework-directory",
+                    detected);
+            }
+        }
+
+        string? dotNetHostPath = null;
+        foreach (var candidate in EnumerateDotNetHostCandidates(options))
+        {
+            searchedPaths.Add(candidate);
+            if (dotNetHostPath is null && File.Exists(candidate))
+            {
+                dotNetHostPath = candidate;
+            }
+        }
+
+        if (OperatingSystem.IsWindows() && options.IncludeRegistry)
+        {
+            foreach (var frameworkName in RequiredSharedFrameworkNames)
+            {
+                AddRegistryRuntimes(options.Architecture, frameworkName, detected);
+            }
+        }
+
+        if (options.IncludeDotNetCli)
+        {
+            AddDotNetCliRuntimes(dotNetHostPath, detected);
+        }
+
+        var isAvailable = detected.Any(runtime =>
+            string.Equals(runtime.Name, RequiredSharedFrameworkName, StringComparison.OrdinalIgnoreCase) &&
+            IsRequiredMajor(runtime.Version, requiredMajor));
+
+        var message = isAvailable
+            ? $".NET {requiredMajor} runtime found for {options.Architecture}."
+            : $".NET {requiredMajor} runtime was not found for {options.Architecture}.";
+
+        return new DotNetRuntimeProbeResult(
+            isAvailable,
+            requiredMajor,
+            options.Architecture,
+            dotNetHostPath,
+            searchedPaths
+                .Where(path => !string.IsNullOrWhiteSpace(path))
+                .Distinct(StringComparer.OrdinalIgnoreCase)
+                .ToList(),
+            detected
+                .DistinctBy(runtime => $"{runtime.Name}|{runtime.Version}|{runtime.Source}|{runtime.Location}", StringComparer.OrdinalIgnoreCase)
+                .OrderBy(runtime => runtime.Name, StringComparer.OrdinalIgnoreCase)
+                .ThenBy(runtime => runtime.Version, StringComparer.OrdinalIgnoreCase)
+                .ToList(),
+            message);
+    }
+
+    public static DotNetRuntimeArchitecture GetCurrentArchitecture()
+    {
+        return RuntimeInformation.ProcessArchitecture switch
+        {
+            Architecture.X86 => DotNetRuntimeArchitecture.X86,
+            _ => DotNetRuntimeArchitecture.X64
+        };
+    }
+
+    public static string? FindDotNetHostPath(DotNetRuntimeProbeOptions? options = null)
+    {
+        options ??= new DotNetRuntimeProbeOptions();
+        return EnumerateDotNetHostCandidates(options).FirstOrDefault(File.Exists);
+    }
+
+    public static bool IsFrameworkDependentWindowsApp(string executablePath)
+    {
+        if (!OperatingSystem.IsWindows() || string.IsNullOrWhiteSpace(executablePath))
+        {
+            return false;
+        }
+
+        var directory = Path.GetDirectoryName(Path.GetFullPath(executablePath));
+        if (string.IsNullOrWhiteSpace(directory))
+        {
+            return false;
+        }
+
+        var appName = Path.GetFileNameWithoutExtension(executablePath);
+        var runtimeConfigPath = Path.Combine(directory, $"{appName}.runtimeconfig.json");
+        if (!File.Exists(runtimeConfigPath))
+        {
+            return false;
+        }
+
+        return !File.Exists(Path.Combine(directory, "coreclr.dll")) &&
+               !File.Exists(Path.Combine(directory, "hostfxr.dll")) &&
+               !File.Exists(Path.Combine(directory, "hostpolicy.dll")) &&
+               !File.Exists(Path.Combine(directory, "System.Private.CoreLib.dll"));
+    }
+
+    private static IEnumerable<string> EnumerateDotNetInstallRoots(DotNetRuntimeProbeOptions options)
+    {
+        var programFilesRoot = options.Architecture == DotNetRuntimeArchitecture.X86
+            ? GetProgramFilesX86Path(options)
+            : GetProgramFilesPath(options);
+
+        yield return Path.Combine(programFilesRoot, "dotnet");
+
+        var localAppData = GetLocalAppDataPath(options);
+        if (!string.IsNullOrWhiteSpace(localAppData))
+        {
+            var perUserDotnet = Path.Combine(localAppData, "dotnet");
+            if (!string.Equals(perUserDotnet, Path.Combine(programFilesRoot, "dotnet"), StringComparison.OrdinalIgnoreCase))
+            {
+                yield return perUserDotnet;
+            }
+        }
+    }
+
+    private static IEnumerable<string> EnumerateDotNetHostCandidates(DotNetRuntimeProbeOptions options)
+    {
+        if (options.DotNetHostCandidates is not null)
+        {
+            foreach (var candidate in options.DotNetHostCandidates)
+            {
+                if (!string.IsNullOrWhiteSpace(candidate))
+                {
+                    yield return Path.GetFullPath(candidate);
+                }
+            }
+
+            yield break;
+        }
+
+        var programFilesRoot = options.Architecture == DotNetRuntimeArchitecture.X86
+            ? GetProgramFilesX86Path(options)
+            : GetProgramFilesPath(options);
+
+        yield return Path.Combine(programFilesRoot, "dotnet", OperatingSystem.IsWindows() ? "dotnet.exe" : "dotnet");
+
+        var localAppData = GetLocalAppDataPath(options);
+        if (!string.IsNullOrWhiteSpace(localAppData))
+        {
+            var perUserHost = Path.Combine(localAppData, "dotnet", OperatingSystem.IsWindows() ? "dotnet.exe" : "dotnet");
+            if (!string.Equals(perUserHost, Path.Combine(programFilesRoot, "dotnet", OperatingSystem.IsWindows() ? "dotnet.exe" : "dotnet"), StringComparison.OrdinalIgnoreCase))
+            {
+                yield return perUserHost;
+            }
+        }
+    }
+
+    private static string GetProgramFilesPath(DotNetRuntimeProbeOptions options)
+    {
+        if (!string.IsNullOrWhiteSpace(options.ProgramFilesPath))
+        {
+            return Path.GetFullPath(options.ProgramFilesPath);
+        }
+
+        return Environment.GetEnvironmentVariable("ProgramW6432") ??
+               Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles);
+    }
+
+    private static string GetProgramFilesX86Path(DotNetRuntimeProbeOptions options)
+    {
+        if (!string.IsNullOrWhiteSpace(options.ProgramFilesX86Path))
+        {
+            return Path.GetFullPath(options.ProgramFilesX86Path);
+        }
+
+        return Environment.GetEnvironmentVariable("ProgramFiles(x86)") ??
+               Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86);
+    }
+
+    private static string GetLocalAppDataPath(DotNetRuntimeProbeOptions options)
+    {
+        if (!string.IsNullOrWhiteSpace(options.LocalAppDataPath))
+        {
+            return Path.GetFullPath(options.LocalAppDataPath);
+        }
+
+        return Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
+    }
+
+    private static void AddDirectoryRuntimes(
+        string sharedFrameworkDirectory,
+        string sharedFrameworkName,
+        string source,
+        List<DotNetRuntimeInfo> detected)
+    {
+        if (!Directory.Exists(sharedFrameworkDirectory))
+        {
+            return;
+        }
+
+        foreach (var directory in Directory.GetDirectories(sharedFrameworkDirectory))
+        {
+            var version = Path.GetFileName(directory);
+            if (!string.IsNullOrWhiteSpace(version))
+            {
+                detected.Add(new DotNetRuntimeInfo(sharedFrameworkName, version, source, directory));
+            }
+        }
+    }
+
+    private static void AddRegistryRuntimes(
+        DotNetRuntimeArchitecture architecture,
+        string sharedFrameworkName,
+        List<DotNetRuntimeInfo> detected)
+    {
+        try
+        {
+            var registryView = architecture == DotNetRuntimeArchitecture.X86
+                ? RegistryView.Registry32
+                : RegistryView.Registry64;
+            using var baseKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, registryView);
+            using var key = baseKey.OpenSubKey(
+                $@"SOFTWARE\dotnet\Setup\InstalledVersions\{(architecture == DotNetRuntimeArchitecture.X86 ? "x86" : "x64")}\sharedfx\{sharedFrameworkName}");
+
+            if (key is null)
+            {
+                return;
+            }
+
+            foreach (var valueName in key.GetValueNames())
+            {
+                if (key.GetValue(valueName) is not null)
+                {
+                    detected.Add(new DotNetRuntimeInfo(sharedFrameworkName, valueName, "registry", key.Name));
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Logger.Warn($"Failed to inspect .NET runtime registry keys: {ex.Message}");
+        }
+    }
+
+    private static void AddDotNetCliRuntimes(
+        string? dotNetHostPath,
+        List<DotNetRuntimeInfo> detected)
+    {
+        if (string.IsNullOrWhiteSpace(dotNetHostPath) || !File.Exists(dotNetHostPath))
+        {
+            return;
+        }
+
+        try
+        {
+            using var process = new Process();
+            process.StartInfo = new ProcessStartInfo
+            {
+                FileName = dotNetHostPath,
+                Arguments = "--list-runtimes",
+                UseShellExecute = false,
+                RedirectStandardOutput = true,
+                RedirectStandardError = true,
+                CreateNoWindow = true
+            };
+
+            process.Start();
+            var output = process.StandardOutput.ReadToEnd();
+            process.WaitForExit(3000);
+
+            foreach (var line in output.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries))
+            {
+                var parsed = ParseListRuntimeLine(line);
+                if (parsed is not null &&
+                    RequiredSharedFrameworkNames.Contains(parsed.Value.Name, StringComparer.OrdinalIgnoreCase))
+                {
+                    detected.Add(new DotNetRuntimeInfo(
+                        parsed.Value.Name,
+                        parsed.Value.Version,
+                        "dotnet-cli",
+                        parsed.Value.Location));
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Logger.Warn($"Failed to inspect .NET runtimes via dotnet CLI: {ex.Message}");
+        }
+    }
+
+    private static (string Name, string Version, string? Location)? ParseListRuntimeLine(string line)
+    {
+        var firstSpace = line.IndexOf(' ');
+        if (firstSpace <= 0 || firstSpace + 1 >= line.Length)
+        {
+            return null;
+        }
+
+        var secondSpace = line.IndexOf(' ', firstSpace + 1);
+        if (secondSpace <= firstSpace)
+        {
+            return null;
+        }
+
+        var name = line[..firstSpace].Trim();
+        var version = line[(firstSpace + 1)..secondSpace].Trim();
+        var location = line[(secondSpace + 1)..].Trim().Trim('[', ']');
+        return (name, version, string.IsNullOrWhiteSpace(location) ? null : location);
+    }
+
+    private static bool IsRequiredMajor(string version, int requiredMajor)
+    {
+        var dotIndex = version.IndexOf('.');
+        var majorText = dotIndex < 0 ? version : version[..dotIndex];
+        return int.TryParse(majorText, out var major) && major == requiredMajor;
+    }
+}

LanMountainDesktop.Launcher/Infrastructure/ISplashStageReporter.cs

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

LanMountainDesktop.Launcher/Infrastructure/LanguagePreferenceService.cs

@@ -0,0 +1,56 @@
+using System.Globalization;
+using System.Text.Json.Nodes;
+
+namespace LanMountainDesktop.Launcher.Infrastructure;
+
+internal static class LanguagePreferenceService
+{
+    public static string ResolveLanguageCode(string appRoot)
+    {
+        try
+        {
+            var dataLocationResolver = new DataLocationResolver(appRoot);
+            var settingsPath = HostAppSettingsOobeMerger.GetSettingsFilePath(dataLocationResolver.ResolveDataRoot());
+            if (!File.Exists(settingsPath))
+            {
+                return "zh-CN";
+            }
+
+            var root = JsonNode.Parse(File.ReadAllText(settingsPath))?.AsObject();
+            if (root is not null &&
+                root.TryGetPropertyValue("LanguageCode", out var node) &&
+                node is JsonValue value &&
+                value.TryGetValue<string>(out var code) &&
+                !string.IsNullOrWhiteSpace(code))
+            {
+                return NormalizeLanguageCode(code);
+            }
+        }
+        catch
+        {
+        }
+
+        return "zh-CN";
+    }
+
+    public static void ApplyLanguage(string languageCode)
+    {
+        var normalized = NormalizeLanguageCode(languageCode);
+        var culture = CultureInfo.GetCultureInfo(normalized);
+        CultureInfo.DefaultThreadCurrentCulture = culture;
+        CultureInfo.DefaultThreadCurrentUICulture = culture;
+        Thread.CurrentThread.CurrentCulture = culture;
+        Thread.CurrentThread.CurrentUICulture = culture;
+    }
+
+    private static string NormalizeLanguageCode(string code)
+    {
+        return code.ToLowerInvariant() switch
+        {
+            "en-us" or "en" => "en-US",
+            "ja-jp" or "ja" => "ja-JP",
+            "ko-kr" or "ko" => "ko-KR",
+            _ => "zh-CN"
+        };
+    }
+}

LanMountainDesktop.Launcher/Infrastructure/LauncherBackgroundService.cs

@@ -0,0 +1,174 @@
+using Avalonia.Media.Imaging;
+
+namespace LanMountainDesktop.Launcher.Infrastructure;
+
+/// <summary>
+/// 启动器背景图片服务
+/// </summary>
+internal static class LauncherBackgroundService
+{
+    private const string PictureFileName = "Launcher Picture";
+    private const long MaxFileSize = 10 * 1024 * 1024; // 10MB
+    private const double WindowAspectRatio = 7.0 / 5.0; // 700:500
+    private const double AspectRatioTolerance = 0.15; // 15% 误差
+
+    private static Bitmap? _cachedBitmap;
+    private static string? _cachedPath;
+
+    /// <summary>
+    /// 背景图片信息
+    /// </summary>
+    public record BackgroundImageInfo
+    {
+        public required bool Exists { get; init; }
+        public required bool IsValid { get; init; }
+        public string? FilePath { get; init; }
+        public Bitmap? Bitmap { get; init; }
+        public int Width { get; init; }
+        public int Height { get; init; }
+        public double AspectRatio { get; init; }
+        public string? ErrorMessage { get; init; }
+    }
+
+    /// <summary>
+    /// 加载背景图片
+    /// </summary>
+    public static BackgroundImageInfo LoadBackgroundImage()
+    {
+        try
+        {
+            var resolver = new DataLocationResolver(AppContext.BaseDirectory);
+            var launcherPath = resolver.ResolveLauncherDataPath();
+
+            // 查找图片文件
+            var imagePath = FindImageFile(launcherPath);
+            if (imagePath == null)
+            {
+                return new BackgroundImageInfo
+                {
+                    Exists = false,
+                    IsValid = false,
+                    ErrorMessage = "未找到背景图片文件"
+                };
+            }
+
+            // 检查文件大小
+            var fileInfo = new FileInfo(imagePath);
+            if (fileInfo.Length > MaxFileSize)
+            {
+                return new BackgroundImageInfo
+                {
+                    Exists = true,
+                    IsValid = false,
+                    FilePath = imagePath,
+                    ErrorMessage = $"图片文件过大 ({fileInfo.Length / 1024 / 1024}MB > 10MB)"
+                };
+            }
+
+            // 使用缓存
+            if (_cachedBitmap != null && _cachedPath == imagePath)
+            {
+                return new BackgroundImageInfo
+                {
+                    Exists = true,
+                    IsValid = true,
+                    FilePath = imagePath,
+                    Bitmap = _cachedBitmap,
+                    Width = _cachedBitmap.PixelSize.Width,
+                    Height = _cachedBitmap.PixelSize.Height,
+                    AspectRatio = (double)_cachedBitmap.PixelSize.Width / _cachedBitmap.PixelSize.Height
+                };
+            }
+
+            // 加载图片
+            var bitmap = new Bitmap(imagePath);
+            var width = bitmap.PixelSize.Width;
+            var height = bitmap.PixelSize.Height;
+            var aspectRatio = (double)width / height;
+
+            // 校验比例
+            var ratioDiff = Math.Abs(aspectRatio - WindowAspectRatio) / WindowAspectRatio;
+            if (ratioDiff > AspectRatioTolerance)
+            {
+                bitmap.Dispose();
+                return new BackgroundImageInfo
+                {
+                    Exists = true,
+                    IsValid = false,
+                    FilePath = imagePath,
+                    Width = width,
+                    Height = height,
+                    AspectRatio = aspectRatio,
+                    ErrorMessage = $"图片比例不符合要求 ({aspectRatio:F2}，需要接近 {WindowAspectRatio:F2})"
+                };
+            }
+
+            // 缓存图片
+            _cachedBitmap = bitmap;
+            _cachedPath = imagePath;
+
+            Logger.Info($"[LauncherBackground] 背景图片加载成功: {imagePath} ({width}x{height}, 比例: {aspectRatio:F2})");
+
+            return new BackgroundImageInfo
+            {
+                Exists = true,
+                IsValid = true,
+                FilePath = imagePath,
+                Bitmap = bitmap,
+                Width = width,
+                Height = height,
+                AspectRatio = aspectRatio
+            };
+        }
+        catch (Exception ex)
+        {
+            Logger.Warn($"[LauncherBackground] 加载背景图片失败: {ex.Message}");
+            return new BackgroundImageInfo
+            {
+                Exists = false,
+                IsValid = false,
+                ErrorMessage = $"加载失败: {ex.Message}"
+            };
+        }
+    }
+
+    /// <summary>
+    /// 查找图片文件
+    /// </summary>
+    private static string? FindImageFile(string directory)
+    {
+        var extensions = new[] { ".png", ".jpg", ".jpeg", ".bmp", ".gif", ".webp" };
+
+        foreach (var ext in extensions)
+        {
+            var path = Path.Combine(directory, PictureFileName + ext);
+            if (File.Exists(path))
+            {
+                return path;
+            }
+        }
+
+        // 也尝试不带扩展名的匹配（如果文件本身就有扩展名）
+        var files = Directory.GetFiles(directory, PictureFileName + ".*");
+        foreach (var file in files)
+        {
+            var ext = Path.GetExtension(file).ToLowerInvariant();
+            if (extensions.Contains(ext))
+            {
+                return file;
+            }
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// 清除缓存
+    /// </summary>
+    public static void ClearCache()
+    {
+        _cachedBitmap?.Dispose();
+        _cachedBitmap = null;
+        _cachedPath = null;
+    }
+}

LanMountainDesktop.Launcher/Infrastructure/LauncherDebugSettingsStore.cs

@@ -0,0 +1,134 @@
+namespace LanMountainDesktop.Launcher.Infrastructure;
+
+internal sealed record LauncherDebugSettings(bool DevModeEnabled, string? CustomHostPath);
+
+internal static class LauncherDebugSettingsStore
+{
+    private const string DevModeFileName = "dev-mode.flag";
+    private const string CustomHostPathFileName = "custom-host-path.txt";
+    private const string LegacyDevModeFileName = "devmode.config";
+    private const string LegacyCustomHostPathFileName = "custom-host-path.config";
+
+    internal static string? ConfigBaseDirectoryOverride { get; set; }
+
+    public static string ConfigBaseDirectory => ConfigBaseDirectoryOverride ?? ResolveConfigBaseDirectory();
+
+    public static LauncherDebugSettings Load()
+    {
+        return new LauncherDebugSettings(
+            LoadDevModeState(),
+            LoadCustomHostPath());
+    }
+
+    public static bool IsDevModeEnabled() => Load().DevModeEnabled;
+
+    public static string? GetSavedCustomHostPath() => Load().CustomHostPath;
+
+    public static void Save(LauncherDebugSettings settings)
+    {
+        try
+        {
+            Directory.CreateDirectory(ConfigBaseDirectory);
+            File.WriteAllText(GetPath(DevModeFileName), settings.DevModeEnabled.ToString());
+            File.WriteAllText(GetPath(CustomHostPathFileName), settings.CustomHostPath ?? string.Empty);
+        }
+        catch (Exception ex)
+        {
+            Logger.Warn($"Failed to save launcher debug settings: {ex.Message}");
+        }
+    }
+
+    public static void SaveDevModeState(bool enabled)
+    {
+        var current = Load();
+        Save(current with { DevModeEnabled = enabled });
+    }
+
+    public static void SaveCustomHostPath(string? customHostPath)
+    {
+        var current = Load();
+        Save(current with { CustomHostPath = customHostPath });
+    }
+
+    private static bool LoadDevModeState()
+    {
+        var newValue = TryReadText(GetPath(DevModeFileName));
+        if (!string.IsNullOrWhiteSpace(newValue))
+        {
+            return TryParseDevMode(newValue);
+        }
+
+        var legacyValue = TryReadText(GetPath(LegacyDevModeFileName));
+        return !string.IsNullOrWhiteSpace(legacyValue) && TryParseDevMode(legacyValue);
+    }
+
+    private static string? LoadCustomHostPath()
+    {
+        var newValue = TryReadText(GetPath(CustomHostPathFileName));
+        if (!string.IsNullOrWhiteSpace(newValue))
+        {
+            return newValue.Trim();
+        }
+
+        var legacyValue = TryReadText(GetPath(LegacyCustomHostPathFileName));
+        return string.IsNullOrWhiteSpace(legacyValue) ? null : legacyValue.Trim();
+    }
+
+    private static bool TryParseDevMode(string value)
+    {
+        var normalized = value.Trim();
+        return normalized == "1" ||
+               normalized.Equals("true", StringComparison.OrdinalIgnoreCase) ||
+               normalized.Equals("yes", StringComparison.OrdinalIgnoreCase) ||
+               normalized.Equals("on", StringComparison.OrdinalIgnoreCase);
+    }
+
+    private static string? TryReadText(string path)
+    {
+        try
+        {
+            return File.Exists(path) ? File.ReadAllText(path) : null;
+        }
+        catch (Exception ex)
+        {
+            Logger.Warn($"Failed to read launcher debug setting '{path}': {ex.Message}");
+            return null;
+        }
+    }
+
+    private static string GetPath(string fileName) => Path.Combine(ConfigBaseDirectory, fileName);
+
+    private static string ResolveConfigBaseDirectory()
+    {
+        try
+        {
+            var appRoot = Commands.ResolveAppRoot(CommandContext.FromArgs([]));
+            var resolver = new DataLocationResolver(appRoot);
+            return resolver.ResolveLauncherDataPath();
+        }
+        catch
+        {
+        }
+
+        try
+        {
+            var appData = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
+            if (!string.IsNullOrWhiteSpace(appData))
+            {
+                return Path.Combine(appData, "LanMountainDesktop", "Launcher");
+            }
+        }
+        catch
+        {
+        }
+
+        try
+        {
+            return Path.Combine(AppContext.BaseDirectory, "Launcher");
+        }
+        catch
+        {
+            return Path.Combine(Directory.GetCurrentDirectory(), "Launcher");
+        }
+    }
+}

LanMountainDesktop.Launcher/Infrastructure/LauncherExecutionContext.cs

@@ -0,0 +1,30 @@
+using System.Security.Principal;
+using LanMountainDesktop.Launcher.Models;
+
+namespace LanMountainDesktop.Launcher.Infrastructure;
+
+internal static class LauncherExecutionContext
+{
+    public static LauncherExecutionSnapshot Capture()
+    {
+        var userName = Environment.UserName ?? string.Empty;
+        if (!OperatingSystem.IsWindows())
+        {
+            return new LauncherExecutionSnapshot(false, userName, null);
+        }
+
+        try
+        {
+            using var identity = WindowsIdentity.GetCurrent();
+            var principal = new WindowsPrincipal(identity);
+            return new LauncherExecutionSnapshot(
+                principal.IsInRole(WindowsBuiltInRole.Administrator),
+                userName,
+                identity.User?.Value);
+        }
+        catch
+        {
+            return new LauncherExecutionSnapshot(false, userName, null);
+        }
+    }
+}

LanMountainDesktop.Launcher/Infrastructure/Logger.cs

@@ -0,0 +1,148 @@
+using System.Text;
+
+namespace LanMountainDesktop.Launcher.Infrastructure;
+
+/// <summary>
+/// 简单的日志记录器 - 同时输出到控制台和文件
+/// </summary>
+internal static class Logger
+{
+    private static readonly object _lock = new();
+    private static string? _logFilePath;
+    private static bool _initialized;
+
+    /// <summary>
+    /// 初始化日志记录器
+    /// </summary>
+    public static void Initialize()
+    {
+        if (_initialized)
+        {
+            return;
+        }
+
+        try
+        {
+            var logDir = GetLogDirectory();
+            if (!string.IsNullOrEmpty(logDir))
+            {
+                Directory.CreateDirectory(logDir);
+                var timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
+                _logFilePath = Path.Combine(logDir, $"launcher_{timestamp}.log");
+                Console.WriteLine($"[Logger] Log file initialized: {_logFilePath}");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine($"[Logger] Failed to initialize log file: {ex.Message}");
+        }
+
+        _initialized = true;
+    }
+
+    /// <summary>
+    /// 获取日志文件路径
+    /// </summary>
+    public static string? GetLogFilePath()
+    {
+        return _logFilePath;
+    }
+
+    /// <summary>
+    /// 获取日志目录
+    /// </summary>
+    private static string? GetLogDirectory()
+    {
+        try
+        {
+            var appRoot = Commands.ResolveAppRoot(CommandContext.FromArgs([]));
+            var resolver = new DataLocationResolver(appRoot);
+            return resolver.ResolveLauncherLogsPath();
+        }
+        catch
+        {
+        }
+
+        try
+        {
+            var appData = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
+            if (!string.IsNullOrEmpty(appData))
+            {
+                return Path.Combine(appData, "LanMountainDesktop", "Launcher", "logs");
+            }
+        }
+        catch
+        {
+        }
+
+        try
+        {
+            var launcherDir = AppContext.BaseDirectory;
+            return Path.Combine(launcherDir, "Launcher", "logs");
+        }
+        catch
+        {
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// 记录信息日志
+    /// </summary>
+    public static void Info(string message)
+    {
+        WriteLog("INFO", message);
+    }
+
+    /// <summary>
+    /// 记录警告日志
+    /// </summary>
+    public static void Warn(string message)
+    {
+        WriteLog("WARN", message);
+    }
+
+    /// <summary>
+    /// 记录错误日志
+    /// </summary>
+    public static void Error(string message)
+    {
+        WriteLog("ERROR", message);
+    }
+
+    /// <summary>
+    /// 记录错误日志（带异常）
+    /// </summary>
+    public static void Error(string message, Exception exception)
+    {
+        WriteLog("ERROR", $"{message}\n{exception}");
+    }
+
+    /// <summary>
+    /// 写入日志
+    /// </summary>
+    private static void WriteLog(string level, string message)
+    {
+        var timestamp = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff");
+        var logLine = $"[{timestamp}] [{level}] {message}";
+
+        Console.WriteLine(logLine);
+
+        if (string.IsNullOrEmpty(_logFilePath))
+        {
+            return;
+        }
+
+        try
+        {
+            lock (_lock)
+            {
+                File.AppendAllText(_logFilePath, logLine + Environment.NewLine, Encoding.UTF8);
+            }
+        }
+        catch
+        {
+        }
+    }
+}

LanMountainDesktop.Launcher/Infrastructure/ThemeService.cs

@@ -0,0 +1,68 @@
+using Avalonia;
+using Avalonia.Styling;
+using FluentAvalonia.Styling;
+
+namespace LanMountainDesktop.Launcher.Infrastructure;
+
+/// <summary>
+/// 主题服务，管理启动器的主题设置
+/// </summary>
+public static class ThemeService
+{
+    private static ThemeVariant _currentTheme = ThemeVariant.Light;
+    private static string _accentColor = "#0078D4";
+
+    /// <summary>
+    /// 获取当前主题
+    /// </summary>
+    public static ThemeVariant CurrentTheme => _currentTheme;
+
+    /// <summary>
+    /// 获取当前主题色
+    /// </summary>
+    public static string AccentColor => _accentColor;
+
+    /// <summary>
+    /// 应用主题设置
+    /// </summary>
+    public static void ApplyTheme(ThemeMode mode, string accentColor)
+    {
+        _currentTheme = mode switch
+        {
+            ThemeMode.Dark => ThemeVariant.Dark,
+            _ => ThemeVariant.Light
+        };
+        _accentColor = accentColor;
+
+        // 应用到当前应用程序
+        if (Application.Current is { } app)
+        {
+            app.RequestedThemeVariant = _currentTheme;
+        }
+    }
+
+    /// <summary>
+    /// 应用浅色主题
+    /// </summary>
+    public static void ApplyLightTheme(string accentColor)
+    {
+        ApplyTheme(ThemeMode.Light, accentColor);
+    }
+
+    /// <summary>
+    /// 应用深色主题
+    /// </summary>
+    public static void ApplyDarkTheme(string accentColor)
+    {
+        ApplyTheme(ThemeMode.Dark, accentColor);
+    }
+}
+
+/// <summary>
+/// 主题模式
+/// </summary>
+public enum ThemeMode
+{
+    Light,
+    Dark
+}