0.5.6

插件系统再进化

LanMountainDesktop/plugins/LoadedPlugin.cs

@@ -0,0 +1,88 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
+
+using LanMountainDesktop.PluginSdk;
+
+namespace LanMountainDesktop.Plugins;
+
+public sealed class LoadedPlugin : IDisposable, IAsyncDisposable
+{
+    private int _disposed;
+
+    internal LoadedPlugin(
+        PluginManifest manifest,
+        string sourcePath,
+        string assemblyPath,
+        Assembly assembly,
+        IPlugin plugin,
+        IPluginContext context,
+        IReadOnlyList<PluginSettingsPageRegistration> settingsPages,
+        IReadOnlyList<PluginDesktopComponentRegistration> desktopComponents,
+        PluginLoadContext loadContext)
+    {
+        Manifest = manifest;
+        SourcePath = sourcePath;
+        AssemblyPath = assemblyPath;
+        Assembly = assembly;
+        Plugin = plugin;
+        Context = context;
+        SettingsPages = settingsPages;
+        DesktopComponents = desktopComponents;
+        LoadContext = loadContext;
+    }
+
+    public PluginManifest Manifest { get; }
+
+    public string SourcePath { get; }
+
+    public string AssemblyPath { get; }
+
+    public Assembly Assembly { get; }
+
+    public IPlugin Plugin { get; }
+
+    public IPluginContext Context { get; }
+
+    public IReadOnlyList<PluginSettingsPageRegistration> SettingsPages { get; }
+
+    public IReadOnlyList<PluginDesktopComponentRegistration> DesktopComponents { get; }
+
+    public PluginLoadContext LoadContext { get; }
+
+    public void Dispose()
+    {
+        DisposeAsync().AsTask().GetAwaiter().GetResult();
+    }
+
+    public async ValueTask DisposeAsync()
+    {
+        if (Interlocked.Exchange(ref _disposed, 1) != 0)
+        {
+            return;
+        }
+
+        if (Plugin is IAsyncDisposable asyncDisposable)
+        {
+            await asyncDisposable.DisposeAsync();
+        }
+        else if (Plugin is IDisposable disposable)
+        {
+            disposable.Dispose();
+        }
+
+        if (Context is IAsyncDisposable asyncContext)
+        {
+            await asyncContext.DisposeAsync();
+        }
+        else if (Context is IDisposable disposableContext)
+        {
+            disposableContext.Dispose();
+        }
+
+        LoadContext.Unload();
+        GC.SuppressFinalize(this);
+    }
+}

LanMountainDesktop/plugins/MainWindow.PluginSettingsControls.cs

@@ -0,0 +1,14 @@
+using Avalonia.Controls;
+
+namespace LanMountainDesktop.Views;
+
+public partial class MainWindow
+{
+    internal TextBlock PluginSettingsPanelTitleTextBlock => PluginSettingsPanel.FindControl<TextBlock>("PluginSettingsPanelTitleTextBlock")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander PluginSystemSettingsExpander => PluginSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("PluginSystemSettingsExpander")!;
+    internal TextBlock PluginSystemDescriptionTextBlock => PluginSettingsPanel.FindControl<TextBlock>("PluginSystemDescriptionTextBlock")!;
+    internal TextBlock PluginSystemStatusTextBlock => PluginSettingsPanel.FindControl<TextBlock>("PluginSystemStatusTextBlock")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander InstalledPluginsSettingsExpander => PluginSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("InstalledPluginsSettingsExpander")!;
+    internal TextBlock PluginRestartHintTextBlock => PluginSettingsPanel.FindControl<TextBlock>("PluginRestartHintTextBlock")!;
+    internal TextBlock PluginCatalogEmptyTextBlock => PluginSettingsPanel.FindControl<TextBlock>("PluginCatalogEmptyTextBlock")!;
+}

LanMountainDesktop/plugins/MainWindow.PluginSettingsHost.cs

@@ -0,0 +1,217 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Media;
+using FluentAvalonia.UI.Controls;
+using FluentIcons.Avalonia.Fluent;
+using FluentIcons.Common;
+using LanMountainDesktop.Models;
+using LanMountainDesktop.Services;
+
+namespace LanMountainDesktop.Views;
+
+public partial class MainWindow
+{
+    private readonly Dictionary<string, Control> _pluginSettingsPageHosts = new(StringComparer.OrdinalIgnoreCase);
+
+    private void InitializePluginSettingsNavigation()
+    {
+        if (_pluginSettingsPageHosts.Count > 0 || SettingsNavView?.MenuItems is null)
+        {
+            return;
+        }
+
+        var runtime = (Application.Current as App)?.PluginRuntimeService;
+        var contributions = runtime?.SettingsPages
+            .OrderBy(contribution => contribution.Registration.SortOrder)
+            .ThenBy(contribution => contribution.Plugin.Manifest.Name, StringComparer.OrdinalIgnoreCase)
+            .ThenBy(contribution => contribution.Registration.Title, StringComparer.OrdinalIgnoreCase)
+            .ToArray();
+
+        if (contributions is not { Length: > 0 })
+        {
+            return;
+        }
+
+        var pageCountsByPluginId = contributions
+            .GroupBy(contribution => contribution.Plugin.Manifest.Id, StringComparer.OrdinalIgnoreCase)
+            .ToDictionary(group => group.Key, group => group.Count(), StringComparer.OrdinalIgnoreCase);
+
+        var insertIndex = SettingsNavView.MenuItems.IndexOf(SettingsNavPluginsItem) + 1;
+        foreach (var contribution in contributions)
+        {
+            var tag = BuildPluginSettingsTag(contribution);
+            var navigationTitle = BuildPluginSettingsNavigationTitle(contribution, pageCountsByPluginId);
+            var navItem = new NavigationViewItem
+            {
+                Content = navigationTitle,
+                Tag = tag,
+                IconSource = new FluentIcons.Avalonia.Fluent.SymbolIconSource
+                {
+                    Symbol = FluentIcons.Common.Symbol.PuzzlePiece,
+                    IconVariant = FluentIcons.Common.IconVariant.Regular
+                }
+            };
+
+            ToolTip.SetTip(navItem, $"{contribution.Plugin.Manifest.Name} - {contribution.Registration.Title}");
+
+            SettingsNavView.MenuItems.Insert(insertIndex++, navItem);
+
+            var pageHost = CreatePluginSettingsPageHost(contribution);
+            pageHost.IsVisible = false;
+            SettingsContentPagesHost.Children.Add(pageHost);
+            _pluginSettingsPageHosts[tag] = pageHost;
+        }
+    }
+
+    private static string BuildPluginSettingsTag(PluginSettingsPageContribution contribution)
+    {
+        return $"PluginPage:{contribution.Plugin.Manifest.Id}:{contribution.Registration.Id}";
+    }
+
+    private static string BuildPluginSettingsNavigationTitle(
+        PluginSettingsPageContribution contribution,
+        IReadOnlyDictionary<string, int> pageCountsByPluginId)
+    {
+        return pageCountsByPluginId.TryGetValue(contribution.Plugin.Manifest.Id, out var pageCount) && pageCount > 1
+            ? $"{contribution.Plugin.Manifest.Name} - {contribution.Registration.Title}"
+            : contribution.Plugin.Manifest.Name;
+    }
+
+    private Control CreatePluginSettingsPageHost(PluginSettingsPageContribution contribution)
+    {
+        Control content;
+        try
+        {
+            content = contribution.Registration.ContentFactory();
+        }
+        catch (Exception ex)
+        {
+            content = CreatePluginPageErrorContent(ex);
+        }
+
+        return new StackPanel
+        {
+            Spacing = 16,
+            Children =
+            {
+                new TextBlock
+                {
+                    Text = contribution.Registration.Title,
+                    FontSize = 24,
+                    FontWeight = FontWeight.SemiBold,
+                    Foreground = GetThemeBrush("AdaptiveTextPrimaryBrush")
+                },
+                new TextBlock
+                {
+                    Text = contribution.Plugin.Manifest.Name,
+                    Foreground = GetThemeBrush("AdaptiveTextSecondaryBrush")
+                },
+                content
+            }
+        };
+    }
+
+    private Control CreatePluginPageErrorContent(Exception exception)
+    {
+        return new Border
+        {
+            Background = new SolidColorBrush(Color.Parse("#332B0F16")),
+            BorderBrush = new SolidColorBrush(Color.Parse("#66F97316")),
+            BorderThickness = new Thickness(1),
+            CornerRadius = new CornerRadius(16),
+            Padding = new Thickness(16),
+            Child = new TextBlock
+            {
+                Text = exception.Message,
+                TextWrapping = TextWrapping.Wrap
+            }
+        };
+    }
+
+    private void UpdatePluginSettingsPageVisibility(string? selectedTag)
+    {
+        foreach (var pair in _pluginSettingsPageHosts)
+        {
+            pair.Value.IsVisible = string.Equals(pair.Key, selectedTag, StringComparison.OrdinalIgnoreCase);
+        }
+    }
+
+    internal void RefreshPluginSettingsNavigation()
+    {
+        if (SettingsNavView?.MenuItems is null)
+        {
+            return;
+        }
+
+        foreach (var pair in _pluginSettingsPageHosts.ToArray())
+        {
+            var navItem = SettingsNavView.MenuItems
+                .OfType<NavigationViewItem>()
+                .FirstOrDefault(item => string.Equals(item.Tag?.ToString(), pair.Key, StringComparison.OrdinalIgnoreCase));
+            if (navItem is not null)
+            {
+                SettingsNavView.MenuItems.Remove(navItem);
+            }
+
+            SettingsContentPagesHost.Children.Remove(pair.Value);
+        }
+
+        _pluginSettingsPageHosts.Clear();
+        InitializePluginSettingsNavigation();
+    }
+
+    private string? GetSelectedSettingsTabTag()
+    {
+        return (SettingsNavView?.SelectedItem as NavigationViewItem)?.Tag?.ToString();
+    }
+
+    private int ResolveSelectedSettingsTabIndex()
+    {
+        if (SettingsNavView?.SelectedItem is null || SettingsNavView.MenuItems is null)
+        {
+            return 0;
+        }
+
+        for (var i = 0; i < SettingsNavView.MenuItems.Count; i++)
+        {
+            if (ReferenceEquals(SettingsNavView.MenuItems[i], SettingsNavView.SelectedItem))
+            {
+                return i;
+            }
+        }
+
+        return 0;
+    }
+
+    private void RestoreSettingsTabSelection(AppSettingsSnapshot snapshot)
+    {
+        if (SettingsNavView?.MenuItems is null || SettingsNavView.MenuItems.Count == 0)
+        {
+            return;
+        }
+
+        if (!string.IsNullOrWhiteSpace(snapshot.SettingsTabTag))
+        {
+            var taggedItem = SettingsNavView.MenuItems
+                .OfType<NavigationViewItem>()
+                .FirstOrDefault(item => string.Equals(item.Tag?.ToString(), snapshot.SettingsTabTag, StringComparison.OrdinalIgnoreCase));
+            if (taggedItem is not null)
+            {
+                SettingsNavView.SelectedItem = taggedItem;
+                return;
+            }
+        }
+
+        var safeIndex = Math.Clamp(snapshot.SettingsTabIndex, 0, Math.Max(0, SettingsNavView.MenuItems.Count - 1));
+        if (SettingsNavView.MenuItems[safeIndex] is NavigationViewItem navItem)
+        {
+            SettingsNavView.SelectedItem = navItem;
+        }
+    }
+}
+
+
+

LanMountainDesktop/plugins/MainWindow.PluginSettingsLocalization.cs

@@ -0,0 +1,28 @@
+namespace LanMountainDesktop.Views;
+
+public partial class MainWindow
+{
+    private void ApplyPluginSettingsLocalization()
+    {
+        PluginSettingsPanelTitleTextBlock.Text = L("settings.plugins.title", "Plugins");
+        PluginSystemSettingsExpander.Header = L("settings.plugins.runtime_header", "Plugin Runtime");
+        PluginSystemSettingsExpander.Description = L(
+            "settings.plugins.runtime_desc",
+            "Review plugin runtime state and load results.");
+        PluginSystemDescriptionTextBlock.Text = L(
+            "settings.plugins.runtime_hint",
+            "This page shows discovery status, load results, and runtime diagnostics for installed plugins.");
+        PluginSystemStatusTextBlock.Text = L(
+            "settings.plugins.runtime_status",
+            "Plugin runtime status will appear here after plugin discovery completes.");
+        InstalledPluginsSettingsExpander.Header = L("settings.plugins.installed_header", "Installed Plugins");
+        InstalledPluginsSettingsExpander.Description = L(
+            "settings.plugins.installed_desc",
+            "Enable or disable plugins here. Detailed plugin settings appear as separate settings pages.");
+        PluginRestartHintTextBlock.Text = L(
+            "settings.plugins.restart_hint",
+            "Plugin enable state changes take effect after restarting the app.");
+        PluginCatalogEmptyTextBlock.Text = L("settings.plugins.empty", "No plugins found.");
+        PluginSettingsPanel.RefreshFromRuntime();
+    }
+}

LanMountainDesktop/plugins/PluginCatalogEntry.cs

@@ -0,0 +1,19 @@
+using LanMountainDesktop.PluginSdk;
+
+namespace LanMountainDesktop.Services;
+
+public enum PluginCatalogSourceKind
+{
+    Package = 0,
+    Manifest = 1
+}
+
+public sealed record PluginCatalogEntry(
+    PluginManifest Manifest,
+    string SourcePath,
+    bool IsPackage,
+    bool IsEnabled,
+    bool IsLoaded,
+    string? ErrorMessage,
+    int SettingsPageCount,
+    int WidgetCount);

LanMountainDesktop/plugins/PluginContributions.cs

@@ -0,0 +1,12 @@
+using LanMountainDesktop.Plugins;
+using LanMountainDesktop.PluginSdk;
+
+namespace LanMountainDesktop.Services;
+
+public sealed record PluginSettingsPageContribution(
+    LoadedPlugin Plugin,
+    PluginSettingsPageRegistration Registration);
+
+public sealed record PluginDesktopComponentContribution(
+    LoadedPlugin Plugin,
+    PluginDesktopComponentRegistration Registration);

LanMountainDesktop/plugins/PluginLoadContext.cs

@@ -0,0 +1,72 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.Loader;
+
+using LanMountainDesktop.PluginSdk;
+
+namespace LanMountainDesktop.Plugins;
+
+public sealed class PluginLoadContext : AssemblyLoadContext
+{
+    private readonly AssemblyDependencyResolver _resolver;
+    private readonly HashSet<string> _sharedAssemblyNames;
+
+    public PluginLoadContext(string mainAssemblyPath, IEnumerable<string>? sharedAssemblyNames = null)
+        : base($"{Path.GetFileNameWithoutExtension(mainAssemblyPath)}_{Guid.NewGuid():N}", isCollectible: true)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(mainAssemblyPath);
+
+        MainAssemblyPath = Path.GetFullPath(mainAssemblyPath);
+        _resolver = new AssemblyDependencyResolver(MainAssemblyPath);
+        _sharedAssemblyNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+        {
+            typeof(IPlugin).Assembly.GetName().Name!
+        };
+
+        if (sharedAssemblyNames is null)
+        {
+            return;
+        }
+
+        foreach (var assemblyName in sharedAssemblyNames)
+        {
+            if (!string.IsNullOrWhiteSpace(assemblyName))
+            {
+                _sharedAssemblyNames.Add(assemblyName.Trim());
+            }
+        }
+    }
+
+    public string MainAssemblyPath { get; }
+
+    protected override Assembly? Load(AssemblyName assemblyName)
+    {
+        var simpleName = assemblyName.Name;
+        if (string.IsNullOrWhiteSpace(simpleName))
+        {
+            return null;
+        }
+
+        if (_sharedAssemblyNames.Contains(simpleName))
+        {
+            return Default.Assemblies.FirstOrDefault(
+                    assembly => string.Equals(
+                        assembly.GetName().Name,
+                        simpleName,
+                        StringComparison.OrdinalIgnoreCase))
+                ?? null;
+        }
+
+        var assemblyPath = _resolver.ResolveAssemblyToPath(assemblyName);
+        return assemblyPath is null ? null : LoadFromAssemblyPath(assemblyPath);
+    }
+
+    protected override nint LoadUnmanagedDll(string unmanagedDllName)
+    {
+        var libraryPath = _resolver.ResolveUnmanagedDllToPath(unmanagedDllName);
+        return libraryPath is null ? nint.Zero : LoadUnmanagedDllFromPath(libraryPath);
+    }
+}

LanMountainDesktop/plugins/PluginLoadResult.cs

@@ -0,0 +1,24 @@
+using System;
+
+using LanMountainDesktop.PluginSdk;
+
+namespace LanMountainDesktop.Plugins;
+
+public sealed record PluginLoadResult(
+    string SourcePath,
+    PluginManifest? Manifest,
+    LoadedPlugin? LoadedPlugin,
+    Exception? Error)
+{
+    public bool IsSuccess => LoadedPlugin is not null && Error is null;
+
+    public static PluginLoadResult Success(string sourcePath, PluginManifest manifest, LoadedPlugin loadedPlugin)
+    {
+        return new PluginLoadResult(sourcePath, manifest, loadedPlugin, null);
+    }
+
+    public static PluginLoadResult Failure(string sourcePath, PluginManifest? manifest, Exception error)
+    {
+        return new PluginLoadResult(sourcePath, manifest, null, error);
+    }
+}

LanMountainDesktop/plugins/PluginLoader.cs

@@ -0,0 +1,932 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.IO;
+using System.IO.Compression;
+using System.Linq;
+using System.Reflection;
+using System.Security.Cryptography;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+using LanMountainDesktop.PluginSdk;
+
+namespace LanMountainDesktop.Plugins;
+
+public sealed class PluginLoader
+{
+    private readonly PluginLoaderOptions _options;
+
+    public PluginLoader(PluginLoaderOptions? options = null)
+    {
+        _options = options ?? new PluginLoaderOptions();
+    }
+
+    public IReadOnlyList<PluginLoadResult> LoadAll(
+        string pluginsRootDirectory,
+        IServiceProvider? services = null,
+        IReadOnlyDictionary<string, object?>? properties = null)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(pluginsRootDirectory);
+
+        if (!Directory.Exists(pluginsRootDirectory))
+        {
+            return Array.Empty<PluginLoadResult>();
+        }
+
+        var results = new List<PluginLoadResult>();
+        var candidates = DiscoverCandidates(pluginsRootDirectory, results);
+        var selectedPluginIds = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+        foreach (var candidate in candidates)
+        {
+            if (!selectedPluginIds.Add(candidate.Manifest.Id))
+            {
+                results.Add(PluginLoadResult.Failure(
+                    candidate.SourcePath,
+                    candidate.Manifest,
+                    new InvalidOperationException(
+                        $"Duplicate plugin id '{candidate.Manifest.Id}' was found. Source '{candidate.SourcePath}' was ignored because a higher-priority source was already selected.")));
+                continue;
+            }
+
+            results.Add(candidate.SourceKind switch
+            {
+                PluginSourceKind.Package => LoadFromPackage(
+                    candidate.SourcePath,
+                    pluginsRootDirectory,
+                    candidate.Manifest,
+                    services,
+                    properties),
+                _ => LoadFromManifest(
+                    candidate.SourcePath,
+                    candidate.Manifest,
+                    services,
+                    properties)
+            });
+        }
+
+        return results;
+    }
+
+    public PluginLoadResult LoadFromManifest(
+        string manifestPath,
+        IServiceProvider? services = null,
+        IReadOnlyDictionary<string, object?>? properties = null)
+    {
+        PluginManifest? manifest = null;
+
+        try
+        {
+            manifest = PluginManifest.Load(manifestPath);
+            return LoadFromManifest(manifestPath, manifest, services, properties);
+        }
+        catch (Exception ex)
+        {
+            return PluginLoadResult.Failure(Path.GetFullPath(manifestPath), manifest, ex);
+        }
+    }
+
+    public PluginLoadResult LoadFromPackage(
+        string packagePath,
+        string pluginsRootDirectory,
+        IServiceProvider? services = null,
+        IReadOnlyDictionary<string, object?>? properties = null)
+    {
+        PluginManifest? manifest = null;
+
+        try
+        {
+            manifest = ReadManifestFromPackage(packagePath);
+            return LoadFromPackage(packagePath, pluginsRootDirectory, manifest, services, properties);
+        }
+        catch (Exception ex)
+        {
+            return PluginLoadResult.Failure(Path.GetFullPath(packagePath), manifest, ex);
+        }
+    }
+
+    public PluginLoadResult LoadFromAssembly(
+        string assemblyPath,
+        PluginManifest manifest,
+        IServiceProvider? services = null,
+        IReadOnlyDictionary<string, object?>? properties = null)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(assemblyPath);
+        ArgumentNullException.ThrowIfNull(manifest);
+
+        var fullAssemblyPath = Path.GetFullPath(assemblyPath);
+        var pluginDirectory = Path.GetDirectoryName(fullAssemblyPath)
+            ?? throw new InvalidOperationException($"Failed to determine the plugin directory of '{fullAssemblyPath}'.");
+        var dataDirectory = Path.Combine(pluginDirectory, _options.DataDirectoryName);
+        return LoadCore(fullAssemblyPath, fullAssemblyPath, pluginDirectory, dataDirectory, manifest, services, properties);
+    }
+
+    private PluginLoadResult LoadCore(
+        string sourcePath,
+        string assemblyPath,
+        string pluginDirectory,
+        string dataDirectory,
+        PluginManifest manifest,
+        IServiceProvider? services,
+        IReadOnlyDictionary<string, object?>? properties)
+    {
+        PluginLoadContext? loadContext = null;
+        IPlugin? plugin = null;
+        PluginContext? context = null;
+
+        try
+        {
+            loadContext = new PluginLoadContext(assemblyPath, _options.SharedAssemblyNames);
+            var assembly = loadContext.LoadFromAssemblyPath(assemblyPath);
+            var pluginType = ResolvePluginType(assembly);
+            plugin = CreatePluginInstance(pluginType);
+            context = CreateContext(manifest, pluginDirectory, dataDirectory, services, properties);
+
+            plugin.Initialize(context);
+            var settingsPages = context.GetSettingsPagesSnapshot();
+            var desktopComponents = context.GetDesktopComponentsSnapshot();
+
+            var loadedPlugin = new LoadedPlugin(
+                manifest,
+                sourcePath,
+                assemblyPath,
+                assembly,
+                plugin,
+                context,
+                settingsPages,
+                desktopComponents,
+                loadContext);
+
+            return PluginLoadResult.Success(sourcePath, manifest, loadedPlugin);
+        }
+        catch (Exception ex)
+        {
+            DisposeInstance(plugin);
+            DisposeInstance(context);
+            loadContext?.Unload();
+            return PluginLoadResult.Failure(sourcePath, manifest, ex);
+        }
+    }
+
+    private PluginLoadResult LoadFromManifest(
+        string manifestPath,
+        PluginManifest manifest,
+        IServiceProvider? services,
+        IReadOnlyDictionary<string, object?>? properties)
+    {
+        try
+        {
+            var fullManifestPath = Path.GetFullPath(manifestPath);
+            var assemblyPath = manifest.ResolveEntranceAssemblyPath(fullManifestPath);
+            if (!File.Exists(assemblyPath))
+            {
+                throw new FileNotFoundException(
+                    $"Plugin '{manifest.Id}' entrance assembly '{assemblyPath}' was not found.",
+                    assemblyPath);
+            }
+
+            var pluginDirectory = Path.GetDirectoryName(assemblyPath)
+                ?? throw new InvalidOperationException($"Failed to determine the plugin directory of '{assemblyPath}'.");
+            var dataDirectory = Path.Combine(pluginDirectory, _options.DataDirectoryName);
+            return LoadCore(fullManifestPath, assemblyPath, pluginDirectory, dataDirectory, manifest, services, properties);
+        }
+        catch (Exception ex)
+        {
+            return PluginLoadResult.Failure(Path.GetFullPath(manifestPath), manifest, ex);
+        }
+    }
+
+    private PluginLoadResult LoadFromPackage(
+        string packagePath,
+        string pluginsRootDirectory,
+        PluginManifest manifest,
+        IServiceProvider? services,
+        IReadOnlyDictionary<string, object?>? properties)
+    {
+        try
+        {
+            var fullPackagePath = Path.GetFullPath(packagePath);
+            var extractionDirectory = ExtractPackage(fullPackagePath, pluginsRootDirectory);
+            var extractedManifestPath = Path.Combine(extractionDirectory, _options.ManifestFileName);
+
+            if (!File.Exists(extractedManifestPath))
+            {
+                throw new FileNotFoundException(
+                    $"Plugin package '{fullPackagePath}' does not contain '{_options.ManifestFileName}'.",
+                    extractedManifestPath);
+            }
+
+            var extractedManifest = PluginManifest.Load(extractedManifestPath);
+            if (!string.Equals(extractedManifest.Id, manifest.Id, StringComparison.OrdinalIgnoreCase))
+            {
+                throw new InvalidOperationException(
+                    $"Plugin package '{fullPackagePath}' manifest id changed after extraction. Expected '{manifest.Id}', actual '{extractedManifest.Id}'.");
+            }
+
+            var assemblyPath = extractedManifest.ResolveEntranceAssemblyPath(extractedManifestPath);
+            if (!File.Exists(assemblyPath))
+            {
+                throw new FileNotFoundException(
+                    $"Plugin '{extractedManifest.Id}' entrance assembly '{assemblyPath}' was not found after package extraction.",
+                    assemblyPath);
+            }
+
+            var dataDirectory = GetPackagedDataDirectory(pluginsRootDirectory, extractedManifest);
+            return LoadCore(fullPackagePath, assemblyPath, extractionDirectory, dataDirectory, extractedManifest, services, properties);
+        }
+        catch (Exception ex)
+        {
+            return PluginLoadResult.Failure(Path.GetFullPath(packagePath), manifest, ex);
+        }
+    }
+
+    private PluginContext CreateContext(
+        PluginManifest manifest,
+        string pluginDirectory,
+        string dataDirectory,
+        IServiceProvider? services,
+        IReadOnlyDictionary<string, object?>? properties)
+    {
+        Directory.CreateDirectory(dataDirectory);
+
+        return new PluginContext(
+            manifest,
+            pluginDirectory,
+            dataDirectory,
+            services ?? NullServiceProvider.Instance,
+            CreateReadOnlyProperties(properties));
+    }
+
+    private IReadOnlyList<PluginCandidate> DiscoverCandidates(
+        string pluginsRootDirectory,
+        List<PluginLoadResult> preparationFailures)
+    {
+        var candidates = new List<PluginCandidate>();
+
+        foreach (var packagePath in EnumerateCandidatePaths(
+                     pluginsRootDirectory,
+                     "*" + NormalizePackageExtension(_options.PackageFileExtension)))
+        {
+            try
+            {
+                var manifest = ReadManifestFromPackage(packagePath);
+                candidates.Add(new PluginCandidate(Path.GetFullPath(packagePath), manifest, PluginSourceKind.Package));
+            }
+            catch (Exception ex)
+            {
+                preparationFailures.Add(PluginLoadResult.Failure(Path.GetFullPath(packagePath), null, ex));
+            }
+        }
+
+        foreach (var manifestPath in EnumerateCandidatePaths(pluginsRootDirectory, _options.ManifestFileName))
+        {
+            try
+            {
+                var manifest = PluginManifest.Load(manifestPath);
+                candidates.Add(new PluginCandidate(Path.GetFullPath(manifestPath), manifest, PluginSourceKind.Manifest));
+            }
+            catch (Exception ex)
+            {
+                preparationFailures.Add(PluginLoadResult.Failure(Path.GetFullPath(manifestPath), null, ex));
+            }
+        }
+
+        return candidates
+            .OrderBy(candidate => candidate.SourceKind)
+            .ThenBy(candidate => candidate.SourcePath, StringComparer.OrdinalIgnoreCase)
+            .ToArray();
+    }
+
+    private IEnumerable<string> EnumerateCandidatePaths(string pluginsRootDirectory, string searchPattern)
+    {
+        var runtimeRootDirectory = EnsureTrailingSeparator(GetRuntimeRootDirectory(pluginsRootDirectory));
+
+        return Directory
+            .EnumerateFiles(pluginsRootDirectory, searchPattern, SearchOption.AllDirectories)
+            .Select(Path.GetFullPath)
+            .Where(path => !path.StartsWith(runtimeRootDirectory, StringComparison.OrdinalIgnoreCase))
+            .OrderBy(path => path, StringComparer.OrdinalIgnoreCase);
+    }
+
+    private PluginManifest ReadManifestFromPackage(string packagePath)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(packagePath);
+
+        var fullPackagePath = Path.GetFullPath(packagePath);
+        if (!File.Exists(fullPackagePath))
+        {
+            throw new FileNotFoundException($"Plugin package '{fullPackagePath}' was not found.", fullPackagePath);
+        }
+
+        using var archive = ZipFile.OpenRead(fullPackagePath);
+        var manifestEntries = archive.Entries
+            .Where(entry =>
+                !string.IsNullOrWhiteSpace(entry.Name) &&
+                string.Equals(entry.Name, _options.ManifestFileName, StringComparison.OrdinalIgnoreCase))
+            .ToArray();
+
+        if (manifestEntries.Length == 0)
+        {
+            throw new InvalidOperationException(
+                $"Plugin package '{fullPackagePath}' does not contain '{_options.ManifestFileName}'.");
+        }
+
+        if (manifestEntries.Length > 1)
+        {
+            throw new InvalidOperationException(
+                $"Plugin package '{fullPackagePath}' contains multiple '{_options.ManifestFileName}' files.");
+        }
+
+        using var stream = manifestEntries[0].Open();
+        return PluginManifest.Load(stream, $"{fullPackagePath}!/{manifestEntries[0].FullName}");
+    }
+
+    private string ExtractPackage(string packagePath, string pluginsRootDirectory)
+    {
+        var extractionDirectory = GetPackageExtractionDirectory(pluginsRootDirectory, packagePath);
+        RecreateDirectory(extractionDirectory);
+        ZipFile.ExtractToDirectory(packagePath, extractionDirectory, overwriteFiles: true);
+        return extractionDirectory;
+    }
+
+    private string GetPackageExtractionDirectory(string pluginsRootDirectory, string packagePath)
+    {
+        var packageName = SanitizeDirectoryName(Path.GetFileNameWithoutExtension(packagePath));
+        var packageHash = Convert.ToHexString(
+            SHA256.HashData(Encoding.UTF8.GetBytes(Path.GetFullPath(packagePath))))
+            .Substring(0, 12);
+
+        return Path.Combine(
+            GetRuntimeRootDirectory(pluginsRootDirectory),
+            _options.ExtractedPackagesDirectoryName,
+            $"{packageName}_{packageHash}");
+    }
+
+    private string GetPackagedDataDirectory(string pluginsRootDirectory, PluginManifest manifest)
+    {
+        return Path.Combine(
+            GetRuntimeRootDirectory(pluginsRootDirectory),
+            _options.PackagedDataDirectoryName,
+            SanitizeDirectoryName(manifest.Id));
+    }
+
+    private string GetRuntimeRootDirectory(string pluginsRootDirectory)
+    {
+        return Path.Combine(Path.GetFullPath(pluginsRootDirectory), _options.RuntimeDirectoryName);
+    }
+
+    private static void RecreateDirectory(string directoryPath)
+    {
+        if (Directory.Exists(directoryPath))
+        {
+            Directory.Delete(directoryPath, recursive: true);
+        }
+
+        Directory.CreateDirectory(directoryPath);
+    }
+
+    private static string NormalizePackageExtension(string extension)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(extension);
+        return extension.StartsWith(".", StringComparison.Ordinal) ? extension : "." + extension;
+    }
+
+    private static string EnsureTrailingSeparator(string path)
+    {
+        var fullPath = Path.GetFullPath(path);
+        return fullPath.EndsWith(Path.DirectorySeparatorChar.ToString(), StringComparison.Ordinal)
+            ? fullPath
+            : fullPath + Path.DirectorySeparatorChar;
+    }
+
+    private static string SanitizeDirectoryName(string value)
+    {
+        var invalidCharacters = Path.GetInvalidFileNameChars();
+        var builder = new StringBuilder(value.Length);
+
+        foreach (var ch in value)
+        {
+            builder.Append(invalidCharacters.Contains(ch) ? '_' : ch);
+        }
+
+        return string.IsNullOrWhiteSpace(builder.ToString()) ? "_plugin" : builder.ToString().Trim();
+    }
+
+    private static ReadOnlyDictionary<string, object?> CreateReadOnlyProperties(
+        IReadOnlyDictionary<string, object?>? properties)
+    {
+        if (properties is null || properties.Count == 0)
+        {
+            return new ReadOnlyDictionary<string, object?>(
+                new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase));
+        }
+
+        var map = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase);
+        foreach (var pair in properties)
+        {
+            map[pair.Key] = pair.Value;
+        }
+
+        return new ReadOnlyDictionary<string, object?>(map);
+    }
+
+    private static Type ResolvePluginType(Assembly assembly)
+    {
+        var candidateTypes = GetLoadableTypes(assembly)
+            .Where(type =>
+                typeof(IPlugin).IsAssignableFrom(type) &&
+                !type.IsAbstract &&
+                !type.IsInterface &&
+                !type.ContainsGenericParameters)
+            .ToArray();
+
+        if (candidateTypes.Length == 0)
+        {
+            throw new InvalidOperationException(
+                $"Assembly '{assembly.Location}' does not contain a concrete type implementing '{nameof(IPlugin)}'.");
+        }
+
+        var attributedTypes = candidateTypes
+            .Where(type => type.IsDefined(typeof(PluginEntranceAttribute), inherit: false))
+            .ToArray();
+
+        if (attributedTypes.Length == 1)
+        {
+            return attributedTypes[0];
+        }
+
+        if (attributedTypes.Length > 1)
+        {
+            throw new InvalidOperationException(
+                $"Assembly '{assembly.Location}' contains multiple plugin entrance types. Mark only one type with '{nameof(PluginEntranceAttribute)}'.");
+        }
+
+        if (candidateTypes.Length == 1)
+        {
+            return candidateTypes[0];
+        }
+
+        throw new InvalidOperationException(
+            $"Assembly '{assembly.Location}' contains multiple '{nameof(IPlugin)}' implementations. Mark the intended entrance type with '{nameof(PluginEntranceAttribute)}'.");
+    }
+
+    private static IPlugin CreatePluginInstance(Type pluginType)
+    {
+        if (pluginType.GetConstructor(Type.EmptyTypes) is null)
+        {
+            throw new InvalidOperationException(
+                $"Plugin type '{pluginType.FullName}' must expose a public parameterless constructor.");
+        }
+
+        if (Activator.CreateInstance(pluginType) is not IPlugin plugin)
+        {
+            throw new InvalidOperationException(
+                $"Failed to create plugin instance of type '{pluginType.FullName}'.");
+        }
+
+        return plugin;
+    }
+
+    private static void DisposeInstance(object? instance)
+    {
+        if (instance is null)
+        {
+            return;
+        }
+
+        try
+        {
+            if (instance is IAsyncDisposable asyncDisposable)
+            {
+                asyncDisposable.DisposeAsync().AsTask().GetAwaiter().GetResult();
+                return;
+            }
+
+            if (instance is IDisposable disposable)
+            {
+                disposable.Dispose();
+            }
+        }
+        catch (Exception disposeError)
+        {
+            System.Diagnostics.Debug.WriteLine(
+                $"[PluginLoader] Disposal of '{instance.GetType().FullName}' failed: {disposeError}");
+        }
+    }
+
+    private static Type[] GetLoadableTypes(Assembly assembly)
+    {
+        try
+        {
+            return assembly.GetTypes();
+        }
+        catch (ReflectionTypeLoadException ex)
+        {
+            var loaderMessages = ex.LoaderExceptions
+                .Where(exception => exception is not null)
+                .Select(exception => exception!.Message)
+                .ToArray();
+
+            var detail = loaderMessages.Length == 0
+                ? "No additional loader diagnostics were provided."
+                : string.Join(Environment.NewLine, loaderMessages);
+
+            throw new InvalidOperationException(
+                $"Failed to inspect plugin assembly '{assembly.Location}'.{Environment.NewLine}{detail}",
+                ex);
+        }
+    }
+
+    private sealed class PluginContext : IPluginContext, IDisposable, IAsyncDisposable
+    {
+        private readonly Dictionary<string, PluginSettingsPageRegistration> _settingsPages =
+            new(StringComparer.OrdinalIgnoreCase);
+        private readonly Dictionary<string, PluginDesktopComponentRegistration> _desktopComponents =
+            new(StringComparer.OrdinalIgnoreCase);
+        private readonly Dictionary<Type, object> _registeredServices = [];
+        private readonly List<object> _serviceRegistrationOrder = [];
+        private readonly object _serviceGate = new();
+        private readonly IServiceProvider _hostServices;
+        private int _disposed;
+
+        public PluginContext(
+            PluginManifest manifest,
+            string pluginDirectory,
+            string dataDirectory,
+            IServiceProvider services,
+            IReadOnlyDictionary<string, object?> properties)
+        {
+            Manifest = manifest;
+            PluginDirectory = pluginDirectory;
+            DataDirectory = dataDirectory;
+            _hostServices = services;
+            Services = new PluginCompositeServiceProvider(this);
+            Properties = properties;
+
+            RegisterBuiltInService<IPluginContext>(this);
+            RegisterBuiltInService<IPluginMessageBus>(new PluginMessageBus());
+        }
+
+        public PluginManifest Manifest { get; }
+
+        public string PluginDirectory { get; }
+
+        public string DataDirectory { get; }
+
+        public IServiceProvider Services { get; }
+
+        public IReadOnlyDictionary<string, object?> Properties { get; }
+
+        public T? GetService<T>()
+        {
+            return (T?)Services.GetService(typeof(T));
+        }
+
+        public bool TryGetProperty<T>(string key, out T? value)
+        {
+            ArgumentException.ThrowIfNullOrWhiteSpace(key);
+
+            if (Properties.TryGetValue(key, out var rawValue) && rawValue is T typedValue)
+            {
+                value = typedValue;
+                return true;
+            }
+
+            value = default;
+            return false;
+        }
+
+        public void RegisterService<TService>(TService service)
+            where TService : class
+        {
+            RegisterServiceCore(typeof(TService), service, allowOverride: false);
+        }
+
+        public void RegisterSettingsPage(PluginSettingsPageRegistration registration)
+        {
+            ArgumentNullException.ThrowIfNull(registration);
+            ThrowIfDisposed();
+
+            if (!_settingsPages.TryAdd(registration.Id, registration))
+            {
+                throw new InvalidOperationException(
+                    $"Plugin '{Manifest.Id}' already registered a settings page with id '{registration.Id}'.");
+            }
+        }
+
+        public void RegisterDesktopComponent(PluginDesktopComponentRegistration registration)
+        {
+            ArgumentNullException.ThrowIfNull(registration);
+            ThrowIfDisposed();
+
+            if (!_desktopComponents.TryAdd(registration.ComponentId, registration))
+            {
+                throw new InvalidOperationException(
+                    $"Plugin '{Manifest.Id}' already registered a desktop component with id '{registration.ComponentId}'.");
+            }
+        }
+
+        public IReadOnlyList<PluginSettingsPageRegistration> GetSettingsPagesSnapshot()
+        {
+            ThrowIfDisposed();
+            return _settingsPages.Values
+                .OrderBy(page => page.SortOrder)
+                .ThenBy(page => page.Title, StringComparer.OrdinalIgnoreCase)
+                .ToArray();
+        }
+
+        public IReadOnlyList<PluginDesktopComponentRegistration> GetDesktopComponentsSnapshot()
+        {
+            ThrowIfDisposed();
+            return _desktopComponents.Values
+                .OrderBy(component => component.Category, StringComparer.OrdinalIgnoreCase)
+                .ThenBy(component => component.DisplayName, StringComparer.OrdinalIgnoreCase)
+                .ToArray();
+        }
+
+        internal object? ResolveService(Type serviceType)
+        {
+            if (Volatile.Read(ref _disposed) != 0)
+            {
+                return null;
+            }
+
+            if (serviceType == typeof(IServiceProvider))
+            {
+                return Services;
+            }
+
+            lock (_serviceGate)
+            {
+                if (_registeredServices.TryGetValue(serviceType, out var service))
+                {
+                    return service;
+                }
+
+                foreach (var registeredService in _registeredServices.Values)
+                {
+                    if (serviceType.IsInstanceOfType(registeredService))
+                    {
+                        return registeredService;
+                    }
+                }
+            }
+
+            return _hostServices.GetService(serviceType);
+        }
+
+        private void RegisterBuiltInService<TService>(TService service)
+            where TService : class
+        {
+            RegisterServiceCore(typeof(TService), service, allowOverride: true);
+        }
+
+        public void Dispose()
+        {
+            DisposeAsync().AsTask().GetAwaiter().GetResult();
+        }
+
+        public async ValueTask DisposeAsync()
+        {
+            if (Interlocked.Exchange(ref _disposed, 1) != 0)
+            {
+                return;
+            }
+
+            object[] services;
+            lock (_serviceGate)
+            {
+                services = _serviceRegistrationOrder.ToArray();
+                _registeredServices.Clear();
+                _serviceRegistrationOrder.Clear();
+            }
+
+            _settingsPages.Clear();
+            _desktopComponents.Clear();
+
+            var disposedServices = new HashSet<object>(ReferenceEqualityComparer.Instance);
+            for (var i = services.Length - 1; i >= 0; i--)
+            {
+                var service = services[i];
+                if (ReferenceEquals(service, this) || !disposedServices.Add(service))
+                {
+                    continue;
+                }
+
+                if (service is IAsyncDisposable asyncDisposable)
+                {
+                    await asyncDisposable.DisposeAsync();
+                }
+                else if (service is IDisposable disposable)
+                {
+                    disposable.Dispose();
+                }
+            }
+        }
+
+        private void RegisterServiceCore(Type serviceType, object service, bool allowOverride)
+        {
+            ArgumentNullException.ThrowIfNull(serviceType);
+            ArgumentNullException.ThrowIfNull(service);
+            ThrowIfDisposed();
+
+            if (!serviceType.IsInstanceOfType(service))
+            {
+                throw new InvalidOperationException(
+                    $"Service instance '{service.GetType().FullName}' is not assignable to '{serviceType.FullName}'.");
+            }
+
+            lock (_serviceGate)
+            {
+                if (!allowOverride && _registeredServices.ContainsKey(serviceType))
+                {
+                    throw new InvalidOperationException(
+                        $"Plugin '{Manifest.Id}' already registered a service for '{serviceType.FullName}'.");
+                }
+
+                _registeredServices[serviceType] = service;
+                _serviceRegistrationOrder.Add(service);
+            }
+        }
+
+        private void ThrowIfDisposed()
+        {
+            if (Volatile.Read(ref _disposed) != 0)
+            {
+                throw new ObjectDisposedException(nameof(PluginContext));
+            }
+        }
+    }
+
+    private sealed class PluginCompositeServiceProvider : IServiceProvider
+    {
+        private readonly PluginContext _context;
+
+        public PluginCompositeServiceProvider(PluginContext context)
+        {
+            _context = context;
+        }
+
+        public object? GetService(Type serviceType)
+        {
+            ArgumentNullException.ThrowIfNull(serviceType);
+            return _context.ResolveService(serviceType);
+        }
+    }
+
+    private sealed class PluginMessageBus : IPluginMessageBus, IDisposable
+    {
+        private readonly Dictionary<Type, List<Subscription>> _subscriptions = [];
+        private readonly object _gate = new();
+        private int _disposed;
+
+        public IDisposable Subscribe<TMessage>(Action<TMessage> handler)
+        {
+            ArgumentNullException.ThrowIfNull(handler);
+            if (Volatile.Read(ref _disposed) != 0)
+            {
+                throw new ObjectDisposedException(nameof(PluginMessageBus));
+            }
+
+            var subscription = new Subscription(this, typeof(TMessage), message => handler((TMessage)message!));
+            lock (_gate)
+            {
+                if (!_subscriptions.TryGetValue(subscription.MessageType, out var handlers))
+                {
+                    handlers = [];
+                    _subscriptions[subscription.MessageType] = handlers;
+                }
+
+                handlers.Add(subscription);
+            }
+
+            return subscription;
+        }
+
+        public void Publish<TMessage>(TMessage message)
+        {
+            if (Volatile.Read(ref _disposed) != 0)
+            {
+                return;
+            }
+
+            Subscription[] handlers;
+            lock (_gate)
+            {
+                if (!_subscriptions.TryGetValue(typeof(TMessage), out var subscriptions) || subscriptions.Count == 0)
+                {
+                    return;
+                }
+
+                handlers = subscriptions.ToArray();
+            }
+
+            foreach (var handler in handlers)
+            {
+                try
+                {
+                    handler.Invoke(message);
+                }
+                catch (Exception ex)
+                {
+                    System.Diagnostics.Debug.WriteLine(
+                        $"[PluginMessageBus] Handler for '{typeof(TMessage).FullName}' failed: {ex}");
+                }
+            }
+        }
+
+        public void Dispose()
+        {
+            if (Interlocked.Exchange(ref _disposed, 1) != 0)
+            {
+                return;
+            }
+
+            lock (_gate)
+            {
+                _subscriptions.Clear();
+            }
+        }
+
+        private void Unsubscribe(Subscription subscription)
+        {
+            lock (_gate)
+            {
+                if (!_subscriptions.TryGetValue(subscription.MessageType, out var handlers))
+                {
+                    return;
+                }
+
+                handlers.Remove(subscription);
+                if (handlers.Count == 0)
+                {
+                    _subscriptions.Remove(subscription.MessageType);
+                }
+            }
+        }
+
+        private sealed class Subscription : IDisposable
+        {
+            private readonly PluginMessageBus _owner;
+            private int _disposed;
+
+            public Subscription(PluginMessageBus owner, Type messageType, Action<object?> handler)
+            {
+                _owner = owner;
+                MessageType = messageType;
+                Handler = handler;
+            }
+
+            public Type MessageType { get; }
+
+            public Action<object?> Handler { get; }
+
+            public void Invoke(object? message)
+            {
+                if (_disposed != 0)
+                {
+                    return;
+                }
+
+                Handler(message);
+            }
+
+            public void Dispose()
+            {
+                if (Interlocked.Exchange(ref _disposed, 1) != 0)
+                {
+                    return;
+                }
+
+                _owner.Unsubscribe(this);
+            }
+        }
+    }
+
+    private sealed class NullServiceProvider : IServiceProvider
+    {
+        public static NullServiceProvider Instance { get; } = new();
+
+        private NullServiceProvider()
+        {
+        }
+
+        public object? GetService(Type serviceType)
+        {
+            return null;
+        }
+    }
+
+    private enum PluginSourceKind
+    {
+        Package = 0,
+        Manifest = 1
+    }
+
+    private sealed record PluginCandidate(
+        string SourcePath,
+        PluginManifest Manifest,
+        PluginSourceKind SourceKind);
+}

LanMountainDesktop/plugins/PluginLoaderOptions.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+
+using LanMountainDesktop.PluginSdk;
+
+namespace LanMountainDesktop.Plugins;
+
+public sealed class PluginLoaderOptions
+{
+    public string ManifestFileName { get; init; } = PluginSdkInfo.ManifestFileName;
+
+    public string PackageFileExtension { get; init; } = PluginSdkInfo.PackageFileExtension;
+
+    public string DataDirectoryName { get; init; } = PluginSdkInfo.DataDirectoryName;
+
+    public string RuntimeDirectoryName { get; init; } = PluginSdkInfo.RuntimeDirectoryName;
+
+    public string ExtractedPackagesDirectoryName { get; init; } = PluginSdkInfo.ExtractedPackagesDirectoryName;
+
+    public string PackagedDataDirectoryName { get; init; } = PluginSdkInfo.PackagedDataDirectoryName;
+
+    public ISet<string> SharedAssemblyNames { get; } = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+    {
+        typeof(IPlugin).Assembly.GetName().Name!
+    };
+}

LanMountainDesktop/plugins/PluginRuntimeService.cs

@@ -0,0 +1,395 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.IO.Compression;
+using System.Linq;
+using System.Reflection;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Markup.Xaml;
+using LanMountainDesktop.Models;
+using LanMountainDesktop.Plugins;
+using LanMountainDesktop.PluginSdk;
+
+namespace LanMountainDesktop.Services;
+
+public sealed class PluginRuntimeService : IDisposable
+{
+    private readonly PluginLoader _loader;
+    private readonly AppSettingsService _appSettingsService = new();
+    private readonly List<LoadedPlugin> _loadedPlugins = [];
+    private readonly List<PluginLoadResult> _loadResults = [];
+    private readonly List<PluginCatalogEntry> _catalog = [];
+    private readonly List<PluginSettingsPageContribution> _settingsPages = [];
+    private readonly List<PluginDesktopComponentContribution> _desktopComponents = [];
+
+    public PluginRuntimeService()
+    {
+        PluginsDirectory = Path.Combine(AppContext.BaseDirectory, "Extensions", "Plugins");
+        _loader = new PluginLoader(CreateOptions());
+    }
+
+    public string PluginsDirectory { get; }
+
+    public IReadOnlyList<LoadedPlugin> LoadedPlugins => _loadedPlugins;
+
+    public IReadOnlyList<PluginLoadResult> LoadResults => _loadResults;
+
+    public IReadOnlyList<PluginCatalogEntry> Catalog => _catalog;
+
+    public IReadOnlyList<PluginSettingsPageContribution> SettingsPages => _settingsPages;
+
+    public IReadOnlyList<PluginDesktopComponentContribution> DesktopComponents => _desktopComponents;
+
+    public void LoadInstalledPlugins()
+    {
+        Directory.CreateDirectory(PluginsDirectory);
+        UnloadInstalledPlugins();
+
+        var disabledPluginIds = GetDisabledPluginIds();
+        var hostProperties = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase)
+        {
+            ["HostApplicationName"] = "LanMountainDesktop",
+            ["HostVersion"] = typeof(App).Assembly.GetName().Version?.ToString(),
+            ["PluginSdkApiVersion"] = PluginSdkInfo.ApiVersion
+        };
+
+        var discoveryFailures = new List<PluginLoadResult>();
+        var candidates = DiscoverCandidates(discoveryFailures);
+        _loadResults.AddRange(discoveryFailures);
+
+        var selectedPluginIds = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        foreach (var candidate in candidates)
+        {
+            if (!selectedPluginIds.Add(candidate.Manifest.Id))
+            {
+                var duplicateFailure = PluginLoadResult.Failure(
+                    candidate.SourcePath,
+                    candidate.Manifest,
+                    new InvalidOperationException(
+                        $"Duplicate plugin id '{candidate.Manifest.Id}' was found. Source '{candidate.SourcePath}' was ignored because a higher-priority source was already selected."));
+                _loadResults.Add(duplicateFailure);
+                continue;
+            }
+
+            var isEnabled = !disabledPluginIds.Contains(candidate.Manifest.Id);
+            if (!isEnabled)
+            {
+                _catalog.Add(new PluginCatalogEntry(
+                    candidate.Manifest,
+                    candidate.SourcePath,
+                    candidate.SourceKind == PluginCatalogSourceKind.Package,
+                    false,
+                    false,
+                    null,
+                    0,
+                    0));
+                continue;
+            }
+
+            var loadResult = candidate.SourceKind switch
+            {
+                PluginCatalogSourceKind.Package => _loader.LoadFromPackage(
+                    candidate.SourcePath,
+                    PluginsDirectory,
+                    services: null,
+                    hostProperties),
+                _ => _loader.LoadFromManifest(
+                    candidate.SourcePath,
+                    services: null,
+                    hostProperties)
+            };
+
+            _loadResults.Add(loadResult);
+
+            if (loadResult.IsSuccess && loadResult.LoadedPlugin is not null)
+            {
+                _loadedPlugins.Add(loadResult.LoadedPlugin);
+                CollectContributions(loadResult.LoadedPlugin);
+                _catalog.Add(new PluginCatalogEntry(
+                    loadResult.LoadedPlugin.Manifest,
+                    loadResult.SourcePath,
+                    candidate.SourceKind == PluginCatalogSourceKind.Package,
+                    true,
+                    true,
+                    null,
+                    loadResult.LoadedPlugin.SettingsPages.Count,
+                    loadResult.LoadedPlugin.DesktopComponents.Count));
+                Debug.WriteLine($"[PluginRuntime] Loaded '{loadResult.Manifest?.Id}' from '{loadResult.SourcePath}'.");
+                continue;
+            }
+
+            _catalog.Add(new PluginCatalogEntry(
+                candidate.Manifest,
+                candidate.SourcePath,
+                candidate.SourceKind == PluginCatalogSourceKind.Package,
+                true,
+                false,
+                loadResult.Error?.Message,
+                0,
+                0));
+            Debug.WriteLine($"[PluginRuntime] Failed to load plugin from '{loadResult.SourcePath}': {loadResult.Error}");
+        }
+
+        if (_catalog.Count == 0 && discoveryFailures.Count == 0)
+        {
+            Debug.WriteLine($"[PluginRuntime] No .laapp packages or loose plugin manifests found under '{PluginsDirectory}'.");
+        }
+    }
+
+    public bool SetPluginEnabled(string pluginId, bool isEnabled)
+    {
+        if (string.IsNullOrWhiteSpace(pluginId))
+        {
+            return false;
+        }
+
+        var snapshot = _appSettingsService.Load();
+        var disabledPluginIds = snapshot.DisabledPluginIds is { Count: > 0 }
+            ? new HashSet<string>(snapshot.DisabledPluginIds, StringComparer.OrdinalIgnoreCase)
+            : new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+        var changed = isEnabled
+            ? disabledPluginIds.Remove(pluginId)
+            : disabledPluginIds.Add(pluginId);
+
+        if (!changed)
+        {
+            return false;
+        }
+
+        snapshot.DisabledPluginIds = disabledPluginIds
+            .OrderBy(id => id, StringComparer.OrdinalIgnoreCase)
+            .ToList();
+        _appSettingsService.Save(snapshot);
+
+        for (var i = 0; i < _catalog.Count; i++)
+        {
+            if (string.Equals(_catalog[i].Manifest.Id, pluginId, StringComparison.OrdinalIgnoreCase))
+            {
+                _catalog[i] = _catalog[i] with { IsEnabled = isEnabled };
+            }
+        }
+
+        return true;
+    }
+
+    public PluginManifest InstallPluginPackage(string packagePath)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(packagePath);
+
+        var fullPackagePath = Path.GetFullPath(packagePath);
+        if (!File.Exists(fullPackagePath))
+        {
+            throw new FileNotFoundException($"Plugin package '{fullPackagePath}' was not found.", fullPackagePath);
+        }
+
+        if (!string.Equals(Path.GetExtension(fullPackagePath), PluginSdkInfo.PackageFileExtension, StringComparison.OrdinalIgnoreCase))
+        {
+            throw new InvalidOperationException(
+                $"Plugin package must use the '{PluginSdkInfo.PackageFileExtension}' extension.");
+        }
+
+        Directory.CreateDirectory(PluginsDirectory);
+
+        var manifest = ReadManifestFromPackage(fullPackagePath);
+        RemoveExistingPluginPackages(manifest.Id, fullPackagePath);
+
+        var destinationPath = Path.Combine(PluginsDirectory, BuildInstalledPackageFileName(manifest.Id));
+        if (!string.Equals(fullPackagePath, Path.GetFullPath(destinationPath), StringComparison.OrdinalIgnoreCase))
+        {
+            File.Copy(fullPackagePath, destinationPath, overwrite: true);
+        }
+
+        return manifest;
+    }
+
+    public void Dispose()
+    {
+        UnloadInstalledPlugins();
+    }
+
+    private void UnloadInstalledPlugins()
+    {
+        for (var i = _loadedPlugins.Count - 1; i >= 0; i--)
+        {
+            _loadedPlugins[i].Dispose();
+        }
+
+        _loadedPlugins.Clear();
+        _loadResults.Clear();
+        _catalog.Clear();
+        _settingsPages.Clear();
+        _desktopComponents.Clear();
+    }
+
+    private HashSet<string> GetDisabledPluginIds()
+    {
+        var snapshot = _appSettingsService.Load();
+        return snapshot.DisabledPluginIds is { Count: > 0 }
+            ? new HashSet<string>(snapshot.DisabledPluginIds, StringComparer.OrdinalIgnoreCase)
+            : new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+    }
+
+    private IReadOnlyList<PluginCandidate> DiscoverCandidates(List<PluginLoadResult> failures)
+    {
+        var candidates = new List<PluginCandidate>();
+
+        foreach (var packagePath in EnumerateCandidatePaths($"*{PluginSdkInfo.PackageFileExtension}"))
+        {
+            try
+            {
+                var manifest = ReadManifestFromPackage(packagePath);
+                candidates.Add(new PluginCandidate(packagePath, manifest, PluginCatalogSourceKind.Package));
+            }
+            catch (Exception ex)
+            {
+                failures.Add(PluginLoadResult.Failure(packagePath, null, ex));
+            }
+        }
+
+        foreach (var manifestPath in EnumerateCandidatePaths("plugin.json"))
+        {
+            try
+            {
+                var manifest = PluginManifest.Load(manifestPath);
+                candidates.Add(new PluginCandidate(manifestPath, manifest, PluginCatalogSourceKind.Manifest));
+            }
+            catch (Exception ex)
+            {
+                failures.Add(PluginLoadResult.Failure(manifestPath, null, ex));
+            }
+        }
+
+        return candidates
+            .OrderBy(candidate => candidate.SourceKind)
+            .ThenBy(candidate => candidate.SourcePath, StringComparer.OrdinalIgnoreCase)
+            .ToArray();
+    }
+
+    private IEnumerable<string> EnumerateCandidatePaths(string searchPattern)
+    {
+        var runtimeRootDirectory = EnsureTrailingSeparator(Path.Combine(Path.GetFullPath(PluginsDirectory), ".runtime"));
+
+        return Directory
+            .EnumerateFiles(PluginsDirectory, searchPattern, SearchOption.AllDirectories)
+            .Select(Path.GetFullPath)
+            .Where(path => !path.StartsWith(runtimeRootDirectory, StringComparison.OrdinalIgnoreCase))
+            .OrderBy(path => path, StringComparer.OrdinalIgnoreCase);
+    }
+
+    private static PluginManifest ReadManifestFromPackage(string packagePath)
+    {
+        using var archive = ZipFile.OpenRead(packagePath);
+        var entries = archive.Entries
+            .Where(entry => string.Equals(entry.Name, "plugin.json", StringComparison.OrdinalIgnoreCase))
+            .ToArray();
+
+        if (entries.Length == 0)
+        {
+            throw new InvalidOperationException($"Plugin package '{packagePath}' does not contain 'plugin.json'.");
+        }
+
+        if (entries.Length > 1)
+        {
+            throw new InvalidOperationException($"Plugin package '{packagePath}' contains multiple 'plugin.json' files.");
+        }
+
+        using var stream = entries[0].Open();
+        return PluginManifest.Load(stream, $"{packagePath}!/{entries[0].FullName}");
+    }
+
+    private void RemoveExistingPluginPackages(string pluginId, string packagePathToKeep)
+    {
+        foreach (var existingPackagePath in EnumerateCandidatePaths($"*{PluginSdkInfo.PackageFileExtension}"))
+        {
+            if (string.Equals(
+                    Path.GetFullPath(existingPackagePath),
+                    Path.GetFullPath(packagePathToKeep),
+                    StringComparison.OrdinalIgnoreCase))
+            {
+                continue;
+            }
+
+            try
+            {
+                var existingManifest = ReadManifestFromPackage(existingPackagePath);
+                if (!string.Equals(existingManifest.Id, pluginId, StringComparison.OrdinalIgnoreCase))
+                {
+                    continue;
+                }
+
+                File.Delete(existingPackagePath);
+            }
+            catch
+            {
+                // Ignore unrelated or invalid packages during replacement.
+            }
+        }
+    }
+
+    private static string BuildInstalledPackageFileName(string pluginId)
+    {
+        var invalidChars = Path.GetInvalidFileNameChars();
+        var fileName = new string(pluginId.Select(ch => invalidChars.Contains(ch) ? '_' : ch).ToArray());
+        return fileName + PluginSdkInfo.PackageFileExtension;
+    }
+
+    private static string EnsureTrailingSeparator(string path)
+    {
+        return path.EndsWith(Path.DirectorySeparatorChar.ToString(), StringComparison.Ordinal)
+            ? path
+            : path + Path.DirectorySeparatorChar;
+    }
+
+    private static PluginLoaderOptions CreateOptions()
+    {
+        var options = new PluginLoaderOptions();
+        AddSharedAssembly(options, typeof(App).Assembly);
+
+        foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
+        {
+            var assemblyName = assembly.GetName().Name;
+            if (string.IsNullOrWhiteSpace(assemblyName))
+            {
+                continue;
+            }
+
+            if (assemblyName.StartsWith("Avalonia", StringComparison.OrdinalIgnoreCase) ||
+                string.Equals(assemblyName, "MicroCom.Runtime", StringComparison.OrdinalIgnoreCase))
+            {
+                AddSharedAssembly(options, assembly);
+            }
+        }
+
+        return options;
+    }
+
+    private static void AddSharedAssembly(PluginLoaderOptions options, Assembly assembly)
+    {
+        var assemblyName = assembly.GetName().Name;
+        if (!string.IsNullOrWhiteSpace(assemblyName))
+        {
+            options.SharedAssemblyNames.Add(assemblyName);
+        }
+    }
+
+    private void CollectContributions(LoadedPlugin loadedPlugin)
+    {
+        foreach (var settingsPage in loadedPlugin.SettingsPages)
+        {
+            _settingsPages.Add(new PluginSettingsPageContribution(loadedPlugin, settingsPage));
+        }
+
+        foreach (var desktopComponent in loadedPlugin.DesktopComponents)
+        {
+            _desktopComponents.Add(new PluginDesktopComponentContribution(loadedPlugin, desktopComponent));
+        }
+    }
+
+    private sealed record PluginCandidate(
+        string SourcePath,
+        PluginManifest Manifest,
+        PluginCatalogSourceKind SourceKind);
+}

LanMountainDesktop/plugins/PluginSettingsPage.Host.cs

@@ -0,0 +1,387 @@
+using System;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Layout;
+using Avalonia.Media;
+using Avalonia.Platform.Storage;
+using FluentAvalonia.UI.Controls;
+using LanMountainDesktop.PluginSdk;
+using LanMountainDesktop.Services;
+
+namespace LanMountainDesktop.Views.SettingsPages;
+
+public partial class PluginSettingsPage : UserControl
+{
+    private static readonly IBrush SuccessBrush = new SolidColorBrush(Color.Parse("#FF0F766E"));
+    private static readonly IBrush ErrorBrush = new SolidColorBrush(Color.Parse("#FFC42B1C"));
+
+    private readonly AppSettingsService _appSettingsService = new();
+    private readonly LocalizationService _localizationService = new();
+    private string? _packageImportStatusMessage;
+    private bool _packageImportStatusIsError;
+
+    public PluginSettingsPage()
+    {
+        InitializeComponent();
+        AttachedToVisualTree += (_, _) => RefreshFromRuntime();
+    }
+
+    public void RefreshFromRuntime()
+    {
+        var runtime = (Application.Current as App)?.PluginRuntimeService;
+        UpdateInstallerUi(runtime);
+        if (runtime is null)
+        {
+            PluginSystemStatusTextBlock.Text = L("settings.plugins.runtime_unavailable", "Plugin runtime is not available.");
+            PluginRuntimeSummaryPanel.Children.Clear();
+            PluginCatalogItemsHost.Children.Clear();
+            PluginRestartHintTextBlock.IsVisible = false;
+            return;
+        }
+
+        BuildRuntimeSummary(runtime);
+        BuildPluginCatalog(runtime);
+    }
+
+    private void UpdateInstallerUi(PluginRuntimeService? runtime)
+    {
+        InstallPluginPackageButton.Content = L("settings.plugins.install_button", "Open .laapp package");
+        InstallPluginPackageButton.IsEnabled = runtime is not null;
+        PluginPackageImportHintTextBlock.Text = runtime is null
+            ? L(
+                "settings.plugins.install_unavailable",
+                "Plugin runtime is unavailable, so .laapp packages cannot be installed right now.")
+            : F(
+                "settings.plugins.install_hint_format",
+                "Open a .laapp package to install it into: {0}",
+                runtime.PluginsDirectory);
+
+        PluginPackageImportStatusTextBlock.IsVisible = !string.IsNullOrWhiteSpace(_packageImportStatusMessage);
+        PluginPackageImportStatusTextBlock.Text = _packageImportStatusMessage ?? string.Empty;
+        PluginPackageImportStatusTextBlock.Foreground = _packageImportStatusIsError ? ErrorBrush : SuccessBrush;
+    }
+
+    private void BuildRuntimeSummary(PluginRuntimeService runtime)
+    {
+        var failures = runtime.LoadResults.Where(result => !result.IsSuccess).ToArray();
+        var enabledCount = runtime.Catalog.Count(entry => entry.IsEnabled);
+        PluginSystemStatusTextBlock.Text = F(
+            "settings.plugins.summary_format",
+            "Detected {0} plugin(s); enabled {1}; loaded {2}; settings pages {3}; widgets {4}; failures {5}.",
+            runtime.Catalog.Count,
+            enabledCount,
+            runtime.LoadedPlugins.Count,
+            runtime.SettingsPages.Count,
+            runtime.DesktopComponents.Count,
+            failures.Length);
+
+        PluginRuntimeSummaryPanel.Children.Clear();
+        foreach (var plugin in runtime.Catalog.OrderBy(entry => entry.Manifest.Name, StringComparer.OrdinalIgnoreCase))
+        {
+            var status = plugin.IsEnabled
+                ? plugin.IsLoaded
+                    ? L("settings.plugins.state.enabled", "Enabled")
+                    : L("settings.plugins.state.enabled_failed", "Enabled / failed to load")
+                : L("settings.plugins.state.disabled", "Disabled");
+            PluginRuntimeSummaryPanel.Children.Add(CreateSummaryLine(
+                F(
+                    "settings.plugins.summary_item_format",
+                    "{0}  v{1}  |  {2}",
+                    plugin.Manifest.Name,
+                    plugin.Manifest.Version ?? "dev",
+                    status)));
+        }
+    }
+
+    private void BuildPluginCatalog(PluginRuntimeService runtime)
+    {
+        PluginCatalogItemsHost.Children.Clear();
+
+        var plugins = runtime.Catalog
+            .OrderBy(entry => entry.Manifest.Name, StringComparer.OrdinalIgnoreCase)
+            .ToList();
+
+        PluginCatalogEmptyTextBlock.IsVisible = plugins.Count == 0;
+        PluginRestartHintTextBlock.IsVisible = plugins.Count > 0;
+
+        foreach (var plugin in plugins)
+        {
+            PluginCatalogItemsHost.Children.Add(CreatePluginCatalogItem(runtime, plugin));
+        }
+    }
+
+    private Control CreatePluginCatalogItem(PluginRuntimeService runtime, PluginCatalogEntry entry)
+    {
+        var title = new TextBlock
+        {
+            Text = entry.Manifest.Name,
+            FontSize = 16,
+            FontWeight = FontWeight.SemiBold,
+            TextWrapping = TextWrapping.Wrap
+        };
+
+        var subtitle = new TextBlock
+        {
+            Text = BuildPluginSubtitle(entry),
+            Foreground = PluginSystemDescriptionTextBlock.Foreground,
+            TextWrapping = TextWrapping.Wrap
+        };
+
+        var enabledToggle = new ToggleSwitch
+        {
+            IsChecked = entry.IsEnabled,
+            OnContent = L("settings.plugins.toggle_on", "Enabled"),
+            OffContent = L("settings.plugins.toggle_off", "Disabled"),
+            HorizontalAlignment = HorizontalAlignment.Right,
+            VerticalAlignment = VerticalAlignment.Center
+        };
+
+        enabledToggle.Checked += (_, _) => OnPluginEnableChanged(runtime, entry, true);
+        enabledToggle.Unchecked += (_, _) => OnPluginEnableChanged(runtime, entry, false);
+
+        var header = new Grid
+        {
+            ColumnDefinitions = new ColumnDefinitions("*,Auto"),
+            ColumnSpacing = 12,
+            Children =
+            {
+                new StackPanel
+                {
+                    Spacing = 4,
+                    Children = { title, subtitle }
+                },
+                enabledToggle
+            }
+        };
+        Grid.SetColumn(enabledToggle, 1);
+
+        var details = new TextBlock
+        {
+            Text = BuildPluginDetails(entry),
+            Foreground = PluginSystemDescriptionTextBlock.Foreground,
+            TextWrapping = TextWrapping.Wrap
+        };
+
+        return new Border
+        {
+            Background = new SolidColorBrush(Color.Parse("#14000000")),
+            CornerRadius = new CornerRadius(16),
+            Padding = new Thickness(14),
+            Child = new StackPanel
+            {
+                Spacing = 10,
+                Children = { header, details }
+            }
+        };
+    }
+
+    private void OnPluginEnableChanged(PluginRuntimeService runtime, PluginCatalogEntry entry, bool isEnabled)
+    {
+        runtime.SetPluginEnabled(entry.Manifest.Id, isEnabled);
+        BuildRuntimeSummary(runtime);
+        BuildPluginCatalog(runtime);
+        PluginSystemStatusTextBlock.Text = F(
+            "settings.plugins.toggle_result_format",
+            "Plugin '{0}' was {1} for the next launch. Restart the app to apply page and widget changes.",
+            entry.Manifest.Name,
+            isEnabled
+                ? L("settings.plugins.toggle_state_enabled", "enabled")
+                : L("settings.plugins.toggle_state_disabled", "disabled"));
+    }
+
+    private async void OnInstallPluginPackageClick(object? sender, Avalonia.Interactivity.RoutedEventArgs e)
+    {
+        var runtime = (Application.Current as App)?.PluginRuntimeService;
+        if (runtime is null)
+        {
+            SetPackageImportStatus(
+                L(
+                    "settings.plugins.install_unavailable",
+                    "Plugin runtime is unavailable, so .laapp packages cannot be installed right now."),
+                isError: true);
+            return;
+        }
+
+        var topLevel = TopLevel.GetTopLevel(this);
+        var storageProvider = topLevel?.StorageProvider;
+        if (storageProvider is null)
+        {
+            SetPackageImportStatus(
+                L("settings.plugins.install_picker_unavailable", "Storage provider is unavailable."),
+                isError: true);
+            return;
+        }
+
+        var files = await storageProvider.OpenFilePickerAsync(new FilePickerOpenOptions
+        {
+            Title = L("settings.plugins.install_picker_title", "Select plugin package"),
+            AllowMultiple = false,
+            FileTypeFilter =
+            [
+                new FilePickerFileType(L("settings.plugins.install_file_type", ".laapp plugin package"))
+                {
+                    Patterns = [$"*{PluginSdkInfo.PackageFileExtension}"]
+                }
+            ]
+        });
+
+        if (files.Count == 0)
+        {
+            return;
+        }
+
+        string? temporaryPackagePath = null;
+        try
+        {
+            temporaryPackagePath = await CopyPackageToTemporaryFileAsync(files[0]);
+            if (string.IsNullOrWhiteSpace(temporaryPackagePath))
+            {
+                SetPackageImportStatus(
+                    L("settings.plugins.install_copy_failed", "Failed to copy the selected .laapp package."),
+                    isError: true);
+                return;
+            }
+
+            var manifest = runtime.InstallPluginPackage(temporaryPackagePath);
+            runtime.LoadInstalledPlugins();
+            RefreshPluginNavigation(topLevel);
+            PendingRestartStateService.SetPending(PendingRestartStateService.PluginCatalogReason, true);
+            RefreshFromRuntime();
+            SetPackageImportStatus(
+                F(
+                    "settings.plugins.install_success_format",
+                    "Installed plugin '{0}'. Restart the app to apply newly added settings pages and widgets.",
+                    manifest.Name),
+                isError: false);
+        }
+        catch (Exception ex)
+        {
+            SetPackageImportStatus(
+                F(
+                    "settings.plugins.install_failed_format",
+                    "Failed to install plugin package: {0}",
+                    ex.Message),
+                isError: true);
+        }
+        finally
+        {
+            if (!string.IsNullOrWhiteSpace(temporaryPackagePath))
+            {
+                try
+                {
+                    File.Delete(temporaryPackagePath);
+                }
+                catch
+                {
+                    // Ignore temporary file cleanup errors.
+                }
+            }
+        }
+    }
+
+    private void RefreshPluginNavigation(TopLevel? topLevel)
+    {
+        switch (topLevel)
+        {
+            case MainWindow mainWindow:
+                mainWindow.RefreshPluginSettingsNavigation();
+                break;
+            case SettingsWindow settingsWindow:
+                settingsWindow.RefreshPluginSettingsNavigation();
+                break;
+        }
+    }
+
+    private void SetPackageImportStatus(string message, bool isError)
+    {
+        _packageImportStatusMessage = string.IsNullOrWhiteSpace(message) ? null : message;
+        _packageImportStatusIsError = isError;
+        UpdateInstallerUi((Application.Current as App)?.PluginRuntimeService);
+    }
+
+    private string BuildPluginSubtitle(PluginCatalogEntry entry)
+    {
+        var source = entry.IsPackage
+            ? L("settings.plugins.source_package", ".laapp package")
+            : L("settings.plugins.source_manifest", "Loose manifest");
+        var state = entry.IsEnabled
+            ? entry.IsLoaded
+                ? L("settings.plugins.state.loaded", "Loaded")
+                : L("settings.plugins.state.load_failed", "Load failed")
+            : L("settings.plugins.state.disabled", "Disabled");
+        return F(
+            "settings.plugins.subtitle_format",
+            "{0} | {1} | {2}",
+            state,
+            source,
+            entry.Manifest.Id);
+    }
+
+    private string BuildPluginDetails(PluginCatalogEntry entry)
+    {
+        var detail = F(
+            "settings.plugins.detail_format",
+            "Settings pages: {0} | Widgets: {1}",
+            entry.SettingsPageCount,
+            entry.WidgetCount);
+        return string.IsNullOrWhiteSpace(entry.ErrorMessage)
+            ? detail
+            : detail + Environment.NewLine + entry.ErrorMessage;
+    }
+
+    private TextBlock CreateSummaryLine(string text)
+    {
+        return new TextBlock
+        {
+            Text = text,
+            TextWrapping = TextWrapping.Wrap,
+            Foreground = PluginSystemDescriptionTextBlock.Foreground
+        };
+    }
+
+    private string L(string key, string fallback)
+    {
+        var snapshot = _appSettingsService.Load();
+        return _localizationService.GetString(snapshot.LanguageCode, key, fallback);
+    }
+
+    private string F(string key, string fallback, params object[] args)
+    {
+        return string.Format(CultureInfo.CurrentCulture, L(key, fallback), args);
+    }
+
+    private static async Task<string?> CopyPackageToTemporaryFileAsync(IStorageFile file)
+    {
+        try
+        {
+            var extension = Path.GetExtension(file.Name);
+            if (string.IsNullOrWhiteSpace(extension))
+            {
+                extension = PluginSdkInfo.PackageFileExtension;
+            }
+
+            var temporaryDirectory = Path.Combine(
+                Path.GetTempPath(),
+                "LanMountainDesktop",
+                "PluginImports");
+            Directory.CreateDirectory(temporaryDirectory);
+
+            var temporaryPackagePath = Path.Combine(
+                temporaryDirectory,
+                $"{DateTime.Now:yyyyMMdd_HHmmss}_{Guid.NewGuid():N}{extension}");
+
+            await using var sourceStream = await file.OpenReadAsync();
+            await using var destinationStream = File.Create(temporaryPackagePath);
+            await sourceStream.CopyToAsync(destinationStream);
+            return temporaryPackagePath;
+        }
+        catch
+        {
+            return null;
+        }
+    }
+}

LanMountainDesktop/plugins/PluginSettingsPage.axaml

@@ -0,0 +1,86 @@
+<UserControl xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             xmlns:ui="using:FluentAvalonia.UI.Controls"
+             xmlns:fi="using:FluentIcons.Avalonia.Fluent"
+             mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="1000"
+             x:Class="LanMountainDesktop.Views.SettingsPages.PluginSettingsPage">
+
+    <StackPanel x:Name="PluginSettingsPanel" Spacing="16">
+        <TextBlock x:Name="PluginSettingsPanelTitleTextBlock"
+                   FontSize="24"
+                   FontWeight="SemiBold"
+                   Foreground="{DynamicResource AdaptiveTextPrimaryBrush}"
+                   Text="Plugins" />
+
+        <Border Classes="settings-expander-shell">
+            <ui:SettingsExpander x:Name="PluginSystemSettingsExpander"
+                                 Header="Plugin Runtime"
+                                 Description="Manage plugin loading and backend isolation."
+                                 IsExpanded="True">
+                <ui:SettingsExpander.IconSource>
+                    <ui:FontIconSource Glyph="&#xe734;" FontFamily="{StaticResource SymbolThemeFontFamily}" />
+                </ui:SettingsExpander.IconSource>
+                <ui:SettingsExpander.Footer>
+                    <StackPanel Spacing="10">
+                        <TextBlock x:Name="PluginSystemDescriptionTextBlock"
+                                   Foreground="{DynamicResource AdaptiveTextSecondaryBrush}"
+                                   Text="This page will host installed plugin management, permission review, and sandboxed backend runtime controls." />
+                        <Border Background="{DynamicResource AdaptiveSurfaceRaisedBrush}"
+                                CornerRadius="{DynamicResource DesignCornerRadiusSm}"
+                                Padding="14">
+                            <TextBlock x:Name="PluginSystemStatusTextBlock"
+                                       Foreground="{DynamicResource AdaptiveTextSecondaryBrush}"
+                                       TextWrapping="Wrap"
+                                       Text="Plugin management UI is not connected yet. Next step is wiring the loader, permissions, and worker isolation state into this panel." />
+                        </Border>
+                        <StackPanel x:Name="PluginRuntimeSummaryPanel" Spacing="6" />
+                    </StackPanel>
+                </ui:SettingsExpander.Footer>
+            </ui:SettingsExpander>
+        </Border>
+
+        <Border Classes="settings-expander-shell">
+            <ui:SettingsExpander x:Name="InstalledPluginsSettingsExpander"
+                                 Header="Installed Plugins"
+                                 Description="Enable plugins here. Detailed settings appear as separate settings pages."
+                                 IsExpanded="True">
+                <ui:SettingsExpander.IconSource>
+                    <ui:FontIconSource Glyph="&#xe8fd;" FontFamily="{StaticResource SymbolThemeFontFamily}" />
+                </ui:SettingsExpander.IconSource>
+                <ui:SettingsExpander.Footer>
+                    <StackPanel Spacing="10">
+                        <Border Background="{DynamicResource AdaptiveSurfaceRaisedBrush}"
+                                CornerRadius="{DynamicResource DesignCornerRadiusSm}"
+                                Padding="14">
+                            <StackPanel Spacing="10">
+                                <Button x:Name="InstallPluginPackageButton"
+                                        HorizontalAlignment="Left"
+                                        Click="OnInstallPluginPackageClick"
+                                        Content="Open .laapp package" />
+                                <TextBlock x:Name="PluginPackageImportHintTextBlock"
+                                           Foreground="{DynamicResource AdaptiveTextSecondaryBrush}"
+                                           TextWrapping="Wrap"
+                                           Text="Open a .laapp package to install it into the local plugin directory." />
+                                <TextBlock x:Name="PluginPackageImportStatusTextBlock"
+                                           Foreground="{DynamicResource AdaptiveTextSecondaryBrush}"
+                                           TextWrapping="Wrap"
+                                           IsVisible="False" />
+                            </StackPanel>
+                        </Border>
+                        <TextBlock x:Name="PluginRestartHintTextBlock"
+                                   Foreground="{DynamicResource AdaptiveTextSecondaryBrush}"
+                                   TextWrapping="Wrap"
+                                   Text="Plugin enable state changes take effect after restarting the app." />
+                        <TextBlock x:Name="PluginCatalogEmptyTextBlock"
+                                   Foreground="{DynamicResource AdaptiveTextSecondaryBrush}"
+                                   Text="No plugins found."
+                                   IsVisible="False" />
+                        <StackPanel x:Name="PluginCatalogItemsHost" Spacing="12" />
+                    </StackPanel>
+                </ui:SettingsExpander.Footer>
+            </ui:SettingsExpander>
+        </Border>
+    </StackPanel>
+</UserControl>

LanMountainDesktop/plugins/README.md

@@ -0,0 +1,33 @@
+# 宿主侧插件运行时
+
+这个目录用于归档阑山桌面宿主侧的插件相关实现。
+
+职责范围：
+- 已安装插件的发现
+- `.laapp` 安装包安装与替换
+- 插件运行时加载
+- 插件贡献的设置页与桌面组件接入
+- 宿主侧插件设置页的安装、显示与刷新
+
+当前宿主侧核心文件：
+- `PluginLoader.cs`
+- `PluginLoadContext.cs`
+- `PluginLoaderOptions.cs`
+- `PluginLoadResult.cs`
+- `LoadedPlugin.cs`
+- `PluginRuntimeService.cs`
+- `PluginContributions.cs`
+- `PluginCatalogEntry.cs`
+- `PluginSettingsPage.axaml`
+- `PluginSettingsPage.Host.cs`
+- `MainWindow.PluginSettingsHost.cs`
+- `SettingsWindow.PluginSettingsHost.cs`
+- `MainWindow.PluginSettingsLocalization.cs`
+- `SettingsWindow.PluginSettingsLocalization.cs`
+- `MainWindow.PluginSettingsControls.cs`
+- `SettingsWindow.PluginSettingsControls.cs`
+
+说明：
+- 插件开发标准、插件打包工具、示例插件与开发文档统一放在仓库根目录下的 `LanAirApp/`
+- 宿主本体的插件加载、解析、安装与插件设置页接入逻辑统一放在 `LanMountainDesktop/plugins/`
+- `LanMountainDesktop.PluginSdk` 只保留插件作者需要引用的契约、清单模型和扩展注册接口

LanMountainDesktop/plugins/SettingsWindow.PluginSettingsControls.cs

@@ -0,0 +1,14 @@
+using Avalonia.Controls;
+
+namespace LanMountainDesktop.Views;
+
+public partial class SettingsWindow
+{
+    internal TextBlock PluginSettingsPanelTitleTextBlock => PluginSettingsPanel.FindControl<TextBlock>("PluginSettingsPanelTitleTextBlock")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander PluginSystemSettingsExpander => PluginSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("PluginSystemSettingsExpander")!;
+    internal TextBlock PluginSystemDescriptionTextBlock => PluginSettingsPanel.FindControl<TextBlock>("PluginSystemDescriptionTextBlock")!;
+    internal TextBlock PluginSystemStatusTextBlock => PluginSettingsPanel.FindControl<TextBlock>("PluginSystemStatusTextBlock")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander InstalledPluginsSettingsExpander => PluginSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("InstalledPluginsSettingsExpander")!;
+    internal TextBlock PluginRestartHintTextBlock => PluginSettingsPanel.FindControl<TextBlock>("PluginRestartHintTextBlock")!;
+    internal TextBlock PluginCatalogEmptyTextBlock => PluginSettingsPanel.FindControl<TextBlock>("PluginCatalogEmptyTextBlock")!;
+}

LanMountainDesktop/plugins/SettingsWindow.PluginSettingsHost.cs

@@ -0,0 +1,217 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Media;
+using FluentAvalonia.UI.Controls;
+using FluentIcons.Avalonia.Fluent;
+using FluentIcons.Common;
+using LanMountainDesktop.Models;
+using LanMountainDesktop.Services;
+
+namespace LanMountainDesktop.Views;
+
+public partial class SettingsWindow
+{
+    private readonly Dictionary<string, Control> _pluginSettingsPageHosts = new(StringComparer.OrdinalIgnoreCase);
+
+    private void InitializePluginSettingsNavigation()
+    {
+        if (_pluginSettingsPageHosts.Count > 0 || SettingsNavView?.MenuItems is null)
+        {
+            return;
+        }
+
+        var runtime = (Application.Current as App)?.PluginRuntimeService;
+        var contributions = runtime?.SettingsPages
+            .OrderBy(contribution => contribution.Registration.SortOrder)
+            .ThenBy(contribution => contribution.Plugin.Manifest.Name, StringComparer.OrdinalIgnoreCase)
+            .ThenBy(contribution => contribution.Registration.Title, StringComparer.OrdinalIgnoreCase)
+            .ToArray();
+
+        if (contributions is not { Length: > 0 })
+        {
+            return;
+        }
+
+        var pageCountsByPluginId = contributions
+            .GroupBy(contribution => contribution.Plugin.Manifest.Id, StringComparer.OrdinalIgnoreCase)
+            .ToDictionary(group => group.Key, group => group.Count(), StringComparer.OrdinalIgnoreCase);
+
+        var insertIndex = SettingsNavView.MenuItems.IndexOf(SettingsNavPluginsItem) + 1;
+        foreach (var contribution in contributions)
+        {
+            var tag = BuildPluginSettingsTag(contribution);
+            var navigationTitle = BuildPluginSettingsNavigationTitle(contribution, pageCountsByPluginId);
+            var navItem = new NavigationViewItem
+            {
+                Content = navigationTitle,
+                Tag = tag,
+                IconSource = new FluentIcons.Avalonia.Fluent.SymbolIconSource
+                {
+                    Symbol = FluentIcons.Common.Symbol.PuzzlePiece,
+                    IconVariant = FluentIcons.Common.IconVariant.Regular
+                }
+            };
+
+            ToolTip.SetTip(navItem, $"{contribution.Plugin.Manifest.Name} - {contribution.Registration.Title}");
+
+            SettingsNavView.MenuItems.Insert(insertIndex++, navItem);
+
+            var pageHost = CreatePluginSettingsPageHost(contribution);
+            pageHost.IsVisible = false;
+            SettingsContentPagesHost.Children.Add(pageHost);
+            _pluginSettingsPageHosts[tag] = pageHost;
+        }
+    }
+
+    private static string BuildPluginSettingsTag(PluginSettingsPageContribution contribution)
+    {
+        return $"PluginPage:{contribution.Plugin.Manifest.Id}:{contribution.Registration.Id}";
+    }
+
+    private static string BuildPluginSettingsNavigationTitle(
+        PluginSettingsPageContribution contribution,
+        IReadOnlyDictionary<string, int> pageCountsByPluginId)
+    {
+        return pageCountsByPluginId.TryGetValue(contribution.Plugin.Manifest.Id, out var pageCount) && pageCount > 1
+            ? $"{contribution.Plugin.Manifest.Name} - {contribution.Registration.Title}"
+            : contribution.Plugin.Manifest.Name;
+    }
+
+    private Control CreatePluginSettingsPageHost(PluginSettingsPageContribution contribution)
+    {
+        Control content;
+        try
+        {
+            content = contribution.Registration.ContentFactory();
+        }
+        catch (Exception ex)
+        {
+            content = CreatePluginPageErrorContent(ex);
+        }
+
+        return new StackPanel
+        {
+            Spacing = 16,
+            Children =
+            {
+                new TextBlock
+                {
+                    Text = contribution.Registration.Title,
+                    FontSize = 24,
+                    FontWeight = FontWeight.SemiBold,
+                    Foreground = GetThemeBrush("AdaptiveTextPrimaryBrush")
+                },
+                new TextBlock
+                {
+                    Text = contribution.Plugin.Manifest.Name,
+                    Foreground = GetThemeBrush("AdaptiveTextSecondaryBrush")
+                },
+                content
+            }
+        };
+    }
+
+    private static Control CreatePluginPageErrorContent(Exception exception)
+    {
+        return new Border
+        {
+            Background = new SolidColorBrush(Color.Parse("#332B0F16")),
+            BorderBrush = new SolidColorBrush(Color.Parse("#66F97316")),
+            BorderThickness = new Thickness(1),
+            CornerRadius = new CornerRadius(16),
+            Padding = new Thickness(16),
+            Child = new TextBlock
+            {
+                Text = exception.Message,
+                TextWrapping = TextWrapping.Wrap
+            }
+        };
+    }
+
+    private void UpdatePluginSettingsPageVisibility(string? selectedTag)
+    {
+        foreach (var pair in _pluginSettingsPageHosts)
+        {
+            pair.Value.IsVisible = string.Equals(pair.Key, selectedTag, StringComparison.OrdinalIgnoreCase);
+        }
+    }
+
+    internal void RefreshPluginSettingsNavigation()
+    {
+        if (SettingsNavView?.MenuItems is null)
+        {
+            return;
+        }
+
+        foreach (var pair in _pluginSettingsPageHosts.ToArray())
+        {
+            var navItem = SettingsNavView.MenuItems
+                .OfType<NavigationViewItem>()
+                .FirstOrDefault(item => string.Equals(item.Tag?.ToString(), pair.Key, StringComparison.OrdinalIgnoreCase));
+            if (navItem is not null)
+            {
+                SettingsNavView.MenuItems.Remove(navItem);
+            }
+
+            SettingsContentPagesHost.Children.Remove(pair.Value);
+        }
+
+        _pluginSettingsPageHosts.Clear();
+        InitializePluginSettingsNavigation();
+    }
+
+    private string? GetSelectedSettingsTabTag()
+    {
+        return (SettingsNavView?.SelectedItem as NavigationViewItem)?.Tag?.ToString();
+    }
+
+    private int ResolveSelectedSettingsTabIndex()
+    {
+        if (SettingsNavView?.SelectedItem is null || SettingsNavView.MenuItems is null)
+        {
+            return 0;
+        }
+
+        for (var i = 0; i < SettingsNavView.MenuItems.Count; i++)
+        {
+            if (ReferenceEquals(SettingsNavView.MenuItems[i], SettingsNavView.SelectedItem))
+            {
+                return i;
+            }
+        }
+
+        return 0;
+    }
+
+    private void RestoreSettingsTabSelection(AppSettingsSnapshot snapshot)
+    {
+        if (SettingsNavView?.MenuItems is null || SettingsNavView.MenuItems.Count == 0)
+        {
+            return;
+        }
+
+        if (!string.IsNullOrWhiteSpace(snapshot.SettingsTabTag))
+        {
+            var taggedItem = SettingsNavView.MenuItems
+                .OfType<NavigationViewItem>()
+                .FirstOrDefault(item => string.Equals(item.Tag?.ToString(), snapshot.SettingsTabTag, StringComparison.OrdinalIgnoreCase));
+            if (taggedItem is not null)
+            {
+                SettingsNavView.SelectedItem = taggedItem;
+                return;
+            }
+        }
+
+        var safeIndex = Math.Clamp(snapshot.SettingsTabIndex, 0, Math.Max(0, SettingsNavView.MenuItems.Count - 1));
+        if (SettingsNavView.MenuItems[safeIndex] is NavigationViewItem navItem)
+        {
+            SettingsNavView.SelectedItem = navItem;
+        }
+    }
+}
+
+
+

LanMountainDesktop/plugins/SettingsWindow.PluginSettingsLocalization.cs

@@ -0,0 +1,18 @@
+namespace LanMountainDesktop.Views;
+
+public partial class SettingsWindow
+{
+    private void ApplyPluginSettingsLocalization()
+    {
+        PluginSettingsPanelTitleTextBlock.Text = L("settings.plugins.title", "Plugins");
+        PluginSystemSettingsExpander.Header = L("settings.plugins.runtime_header", "Plugin Runtime");
+        PluginSystemSettingsExpander.Description = L("settings.plugins.runtime_desc", "Review plugin runtime state and load results.");
+        PluginSystemDescriptionTextBlock.Text = L("settings.plugins.runtime_hint", "This page shows discovery status, load results, and runtime diagnostics for installed plugins.");
+        PluginSystemStatusTextBlock.Text = L("settings.plugins.runtime_status", "Plugin runtime status will appear here after plugin discovery completes.");
+        InstalledPluginsSettingsExpander.Header = L("settings.plugins.installed_header", "Installed Plugins");
+        InstalledPluginsSettingsExpander.Description = L("settings.plugins.installed_desc", "Enable or disable plugins here. Detailed plugin settings appear as separate settings pages.");
+        PluginRestartHintTextBlock.Text = L("settings.plugins.restart_hint", "Plugin enable state changes take effect after restarting the app.");
+        PluginCatalogEmptyTextBlock.Text = L("settings.plugins.empty", "No plugins found.");
+        PluginSettingsPanel.RefreshFromRuntime();
+    }
+}