From 6716e726fd1f717ad2d66c8bfe70189cf4cff708 Mon Sep 17 00:00:00 2001
From: CryoTechnic <cryogen65@gmail.com>
Date: Wed, 15 Jul 2026 19:49:57 -0400
Subject: [PATCH 1/6] Update i18n for drag-n-drop plugin window

---
 Hi3Helper.Core/Lang/en_US.json | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Hi3Helper.Core/Lang/en_US.json b/Hi3Helper.Core/Lang/en_US.json
index 271407c0d..80ec78411 100644
--- a/Hi3Helper.Core/Lang/en_US.json
+++ b/Hi3Helper.Core/Lang/en_US.json
@@ -837,10 +837,10 @@
     "ListViewFooterWarning1": "You need to restart your launcher in order to apply the changes!",
     "ListViewFooterRestartButton": "Restart the Launcher",
 
-    "RightPanelImportTitle1": "Click to add the",
-    "RightPanelImportTitle2": "or",
-    "RightPanelImportTitle3": "here",
-    "RightPanelImportTitle4": "Anywhere in the box is fine!"
+    "RightPanelImportTitle1": "Browse or drop a",
+    "RightPanelImportTitle2": "or",
+    "RightPanelImportTitle3": "",
+    "RightPanelImportTitle4": "Drop plugin files anywhere in this panel"
   },
 
   "_Misc": {

From 7e9859158bf3787fc110355bb87a7d8bc6d6fde3 Mon Sep 17 00:00:00 2001
From: CryoTechnic <cryogen65@gmail.com>
Date: Wed, 15 Jul 2026 19:50:34 -0400
Subject: [PATCH 2/6] Add new drop indicator overlay in plugin window

---
 .../MainApp/Pages/PluginManagerPage.xaml      | 27 +++++++++++++++++--
 1 file changed, 25 insertions(+), 2 deletions(-)

diff --git a/CollapseLauncher/XAMLs/MainApp/Pages/PluginManagerPage.xaml b/CollapseLauncher/XAMLs/MainApp/Pages/PluginManagerPage.xaml
index 249ce132e..d3e2c4773 100644
--- a/CollapseLauncher/XAMLs/MainApp/Pages/PluginManagerPage.xaml
+++ b/CollapseLauncher/XAMLs/MainApp/Pages/PluginManagerPage.xaml
@@ -823,12 +823,17 @@
                 </ResourceDictionary>
             </Grid.Resources>
             <Button x:Name="ImportBoxButton"
+                    AllowDrop="True"
                     HorizontalAlignment="Stretch"
                     VerticalAlignment="Stretch"
                     extension:UIElementExtensions.CursorType="Hand"
                     Background="{StaticResource ImportBoxButtonBackground}"
                     Click="OnClickImportButton"
-                    CornerRadius="20">
+                    CornerRadius="20"
+                    DragEnter="OnDragEnterImportBox"
+                    DragLeave="OnDragLeaveImportBox"
+                    DragOver="OnDragOverImportBox"
+                    Drop="OnDropImportBox">
                 <interactivity:Interaction.Behaviors>
                     <interactivity:EventTriggerBehavior EventName="PointerEntered">
                         <behaviors:StartAnimationAction Animation="{x:Bind ImportBoxPlusGridEnterAnimation}" />
@@ -906,7 +911,7 @@
                             </animations:AnimationSet>
                         </animations:Explicit.Animations>
 
-                        <FontIcon FontSize="48z"
+                        <FontIcon FontSize="48"
                                   Glyph="&#xE710;" />
                     </Button>
                     <StackPanel Grid.Row="1"
@@ -938,6 +943,24 @@
                     </StackPanel>
                 </Grid>
             </Button>
+            <Grid x:Name="ImportDropIndicator"
+                  IsHitTestVisible="False"
+                  Opacity="0">
+                <Grid.OpacityTransition>
+                    <ScalarTransition Duration="0:0:.18" />
+                </Grid.OpacityTransition>
+                <Border Margin="3"
+                        Background="{ThemeResource AccentFillColorDefaultBrush}"
+                        CornerRadius="17"
+                        Opacity=".08" />
+                <Rectangle Margin="2"
+                           RadiusX="18"
+                           RadiusY="18"
+                           Stroke="{ThemeResource AccentColor}"
+                           StrokeDashArray="1,2"
+                           StrokeDashCap="Round"
+                           StrokeThickness="3" />
+            </Grid>
         </Grid>
         <Button x:Name="OpenPluginCatalogBottomLeftButton"
                 Grid.Column="0"

From 7f35ae46d1faab7508c6db08f3458fd06acd49d1 Mon Sep 17 00:00:00 2001
From: CryoTechnic <cryogen65@gmail.com>
Date: Wed, 15 Jul 2026 19:52:07 -0400
Subject: [PATCH 3/6] Add file drag-and-drop support to WindowUtility

Convert `WindowUtility` to partial and add file drag-and-drop handling.

- Added `internal FileDropEvent` and `SetFileDropEnabled` to toggle `DROPFILES`/`COPYDATA`/`COPYGLOBALDATA` filters and call `DragAcceptFiles`.
- Implemented `TryGetExternalDragPosition` to read external drag cursor position.
- `WndProc` now handles `WM_DROPFILES` and forwards to `HandleFileDrop`.
- HandleFileDrop enumerates dropped files (`DragQueryFile`/`DragQueryPoint`) and invokes `FileDropEvent`, then cleans up with `DragFinish`.
- Added `NativeFileDrop` partial class with `P/Invoke` bindings and a `NativePoint` struct.
---
 .../Classes/Helper/WindowUtility.cs           | 127 +++++++++++++++++-
 1 file changed, 126 insertions(+), 1 deletion(-)

diff --git a/CollapseLauncher/Classes/Helper/WindowUtility.cs b/CollapseLauncher/Classes/Helper/WindowUtility.cs
index 9e98f6314..37257c3bf 100644
--- a/CollapseLauncher/Classes/Helper/WindowUtility.cs
+++ b/CollapseLauncher/Classes/Helper/WindowUtility.cs
@@ -53,9 +53,10 @@ internal enum WindowBackdropKind
     }
 
     internal delegate nint WndProcDelegate(nint hwnd, uint msg, nuint wParam, nint lParam);
-    internal static class WindowUtility
+    internal static partial class WindowUtility
     {
         private static event EventHandler<RectInt32[]>? DragAreaChangeEvent;
+        internal static event Action<string[], PointInt32>? FileDropEvent;
 
         private static nint _oldMainWndProcPtr;
         private static nint _oldDesktopSiteBridgeWndProcPtr;
@@ -417,6 +418,52 @@ internal static void RegisterWindow(this Window window)
             FileDialogNative.InitHandlerPointer(CurrentWindowPtr);
         }
 
+        internal static void SetFileDropEnabled(bool isEnabled)
+        {
+            const uint WM_COPYDATA       = 0x004A;
+            const uint WM_COPYGLOBALDATA = 0x0049;
+            const uint WM_DROPFILES      = 0x0233;
+            const uint MSGFLT_RESET      = 0;
+            const uint MSGFLT_ALLOW      = 1;
+
+            nint windowHandle = CurrentWindowPtr;
+            if (windowHandle == nint.Zero)
+            {
+                return;
+            }
+
+            uint messageFilterAction = isEnabled ? MSGFLT_ALLOW : MSGFLT_RESET;
+            NativeFileDrop.ChangeWindowMessageFilterEx(windowHandle, WM_DROPFILES, messageFilterAction, nint.Zero);
+            NativeFileDrop.ChangeWindowMessageFilterEx(windowHandle, WM_COPYDATA, messageFilterAction, nint.Zero);
+            NativeFileDrop.ChangeWindowMessageFilterEx(windowHandle, WM_COPYGLOBALDATA, messageFilterAction, nint.Zero);
+            NativeFileDrop.DragAcceptFiles(windowHandle, isEnabled);
+        }
+
+        internal static bool TryGetExternalDragPosition(out PointInt32 dragPosition)
+        {
+            const int VK_LBUTTON = 0x01;
+            const int VK_RBUTTON = 0x02;
+            const int KeyPressed = 0x8000;
+
+            dragPosition = default;
+            nint windowHandle = CurrentWindowPtr;
+            if (windowHandle == nint.Zero || windowHandle == PInvoke.GetForegroundWindow())
+            {
+                return false;
+            }
+
+            bool isMouseButtonPressed = (NativeFileDrop.GetAsyncKeyState(VK_LBUTTON) & KeyPressed) != 0 ||
+                                        (NativeFileDrop.GetAsyncKeyState(VK_RBUTTON) & KeyPressed) != 0;
+            if (!isMouseButtonPressed || !NativeFileDrop.GetCursorPos(out NativePoint cursorPosition))
+            {
+                return false;
+            }
+
+            NativeFileDrop.ScreenToClient(windowHandle, ref cursorPosition);
+            dragPosition = new PointInt32(cursorPosition.X, cursorPosition.Y);
+            return true;
+        }
+
         #region Drag Area Handler
 
         private static void InstallDragAreaChangeMonitor()
@@ -496,6 +543,7 @@ private static nint MainWndProc(nint hwnd, uint msg, nuint wParam, nint lParam)
             const uint WM_ACTIVATE        = 0x0006;
             const uint WM_QUERYENDSESSION = 0x0011;
             const uint WM_ENDSESSION      = 0x0016;
+            const uint WM_DROPFILES       = 0x0233;
 
             switch (msg)
             {
@@ -643,11 +691,88 @@ private static nint MainWndProc(nint hwnd, uint msg, nuint wParam, nint lParam)
                         (CurrentWindow as MainWindow)?.CloseApp();
                     }
                     break;
+                case WM_DROPFILES:
+                    HandleFileDrop((nint)wParam);
+                    return 0;
             }
 
             return PInvoke.CallWindowProc(_oldMainWndProcPtr, hwnd, msg, wParam, lParam);
         }
 
+        private static unsafe void HandleFileDrop(nint dropHandle)
+        {
+            const uint GetFileCount = uint.MaxValue;
+
+            try
+            {
+                int fileCount = (int)NativeFileDrop.DragQueryFile(dropHandle, GetFileCount, null, 0);
+                string[] files = new string[fileCount];
+                for (int i = 0; i < fileCount; i++)
+                {
+                    uint filePathLength = NativeFileDrop.DragQueryFile(dropHandle, (uint)i, null, 0);
+                    char[] filePathBuffer = new char[filePathLength + 1];
+                    fixed (char* filePathBufferPtr = filePathBuffer)
+                    {
+                        NativeFileDrop.DragQueryFile(dropHandle, (uint)i, filePathBufferPtr, (uint)filePathBuffer.Length);
+                        files[i] = new string(filePathBufferPtr, 0, (int)filePathLength);
+                    }
+                }
+
+                NativeFileDrop.DragQueryPoint(dropHandle, out NativePoint dropPoint);
+                FileDropEvent?.Invoke(files, new PointInt32(dropPoint.X, dropPoint.Y));
+            }
+            finally
+            {
+                NativeFileDrop.DragFinish(dropHandle);
+            }
+        }
+
+        private static unsafe partial class NativeFileDrop
+        {
+            [LibraryImport("shell32.dll")]
+            [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
+            internal static partial void DragAcceptFiles(nint windowHandle, [MarshalAs(UnmanagedType.Bool)] bool acceptFiles);
+
+            [LibraryImport("shell32.dll", EntryPoint = "DragQueryFileW")]
+            [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
+            internal static partial uint DragQueryFile(nint dropHandle, uint fileIndex, char* filePath, uint filePathLength);
+
+            [LibraryImport("shell32.dll")]
+            [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
+            [return: MarshalAs(UnmanagedType.Bool)]
+            internal static partial bool DragQueryPoint(nint dropHandle, out NativePoint dropPoint);
+
+            [LibraryImport("shell32.dll")]
+            [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
+            internal static partial void DragFinish(nint dropHandle);
+
+            [LibraryImport("user32.dll")]
+            [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
+            [return: MarshalAs(UnmanagedType.Bool)]
+            internal static partial bool ChangeWindowMessageFilterEx(nint windowHandle, uint message, uint action, nint changeFilterStruct);
+
+            [LibraryImport("user32.dll")]
+            [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
+            internal static partial short GetAsyncKeyState(int virtualKey);
+
+            [LibraryImport("user32.dll")]
+            [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
+            [return: MarshalAs(UnmanagedType.Bool)]
+            internal static partial bool GetCursorPos(out NativePoint cursorPosition);
+
+            [LibraryImport("user32.dll")]
+            [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
+            [return: MarshalAs(UnmanagedType.Bool)]
+            internal static partial bool ScreenToClient(nint windowHandle, ref NativePoint cursorPosition);
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct NativePoint
+        {
+            internal int X;
+            internal int Y;
+        }
+
         #endregion
 
         #region Titlebar Methods

From 9301d8f8a0d84dc89e5a29e0b20559827d5ac2d8 Mon Sep 17 00:00:00 2001
From: CryoTechnic <cryogen65@gmail.com>
Date: Wed, 15 Jul 2026 19:53:07 -0400
Subject: [PATCH 4/6] Add drag-and-drop import & refactor import logic

- Enable WinUI and native file drag-and-drop support for the Plugin Manager
- Add drag enter/over/leave/drop handlers
- Add a `DispatcherTimer` to track external drag position, and a visual drop indicator.
- Wire `WindowUtility.FileDropEvent` on page load/unload and gate drops to the import area.
- Extract import flow into an async `ImportPlugins` method and improve error handling around imports.
---
 .../MainApp/Pages/PluginManagerPage.xaml.cs   | 143 +++++++++++++++++-
 1 file changed, 141 insertions(+), 2 deletions(-)

diff --git a/CollapseLauncher/XAMLs/MainApp/Pages/PluginManagerPage.xaml.cs b/CollapseLauncher/XAMLs/MainApp/Pages/PluginManagerPage.xaml.cs
index 6313bfe88..5cb985a54 100644
--- a/CollapseLauncher/XAMLs/MainApp/Pages/PluginManagerPage.xaml.cs
+++ b/CollapseLauncher/XAMLs/MainApp/Pages/PluginManagerPage.xaml.cs
@@ -13,6 +13,10 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Windows.ApplicationModel.DataTransfer;
+using Windows.Foundation;
+using Windows.Graphics;
+using Windows.Storage;
 // ReSharper disable CheckNamespace
 
 #nullable enable
@@ -23,10 +27,36 @@ public sealed partial class PluginManagerPage
         public static PluginManagerPageContext Context { get; }              = new();
         public static PluginManagerPage        This    { get; private set; } = null!;
 
+        private readonly DispatcherTimer _fileDragIndicatorTimer = new()
+        {
+            Interval = TimeSpan.FromMilliseconds(50)
+        };
+        private bool _isWinUiFileDragActive;
+        private bool _isDropIndicatorVisible;
+
         public PluginManagerPage()
         {
             This = this;
             InitializeComponent();
+            _fileDragIndicatorTimer.Tick += OnFileDragIndicatorTimerTick;
+            Loaded += OnPluginManagerPageLoaded;
+            Unloaded += OnPluginManagerPageUnloaded;
+        }
+
+        private void OnPluginManagerPageLoaded(object sender, RoutedEventArgs e)
+        {
+            WindowUtility.FileDropEvent += OnNativeFileDrop;
+            WindowUtility.SetFileDropEnabled(true);
+            _fileDragIndicatorTimer.Start();
+        }
+
+        private void OnPluginManagerPageUnloaded(object sender, RoutedEventArgs e)
+        {
+            _fileDragIndicatorTimer.Stop();
+            _isWinUiFileDragActive = false;
+            SetImportDropIndicator(false);
+            WindowUtility.SetFileDropEnabled(false);
+            WindowUtility.FileDropEvent -= OnNativeFileDrop;
         }
 
         private void OnListViewRightClickUpdate(object sender, RightTappedRoutedEventArgs e)
@@ -63,10 +93,8 @@ private void OnRestoreUninstalledPlugin(object sender, RoutedEventArgs e)
 
         private async void OnClickImportButton(object sender, RoutedEventArgs e)
         {
-            int imported = 0;
             try
             {
-                ImportBoxButton.IsEnabled = false;
                 Dictionary<string, string> supportedFiles = new()
                 {
                     { Locale.Current.Lang?._PluginManagerPage?.FileDialogFileFilter1 ?? "", "*.zip;manifest.json" }
@@ -79,6 +107,117 @@ private async void OnClickImportButton(object sender, RoutedEventArgs e)
                     return;
                 }
 
+                await ImportPlugins(selectedFiles);
+            }
+            catch (Exception ex)
+            {
+                ErrorSender.SendException(ex.WrapPluginException("No plugin has been imported due to following error:"));
+            }
+        }
+
+        private void OnDragEnterImportBox(object sender, DragEventArgs e)
+        {
+            if (ImportBoxButton.IsEnabled && e.DataView.Contains(StandardDataFormats.StorageItems))
+            {
+                _isWinUiFileDragActive = true;
+                SetImportDropIndicator(true);
+                e.AcceptedOperation = DataPackageOperation.Copy;
+            }
+        }
+
+        private void OnDragLeaveImportBox(object sender, DragEventArgs e)
+        {
+            Point position = e.GetPosition(ImportBoxButton);
+            if (position.X >= 0 && position.X <= ImportBoxButton.ActualWidth &&
+                position.Y >= 0 && position.Y <= ImportBoxButton.ActualHeight)
+            {
+                return;
+            }
+
+            _isWinUiFileDragActive = false;
+            SetImportDropIndicator(false);
+        }
+
+        private void OnDragOverImportBox(object sender, DragEventArgs e)
+        {
+            if (ImportBoxButton.IsEnabled && e.DataView.Contains(StandardDataFormats.StorageItems))
+            {
+                _isWinUiFileDragActive = true;
+                SetImportDropIndicator(true);
+                e.AcceptedOperation = DataPackageOperation.Copy;
+            }
+        }
+
+        private async void OnDropImportBox(object sender, DragEventArgs e)
+        {
+            _isWinUiFileDragActive = false;
+            SetImportDropIndicator(false);
+            try
+            {
+                IReadOnlyList<IStorageItem> storageItems = await e.DataView.GetStorageItemsAsync();
+                string[] selectedFiles = storageItems.OfType<StorageFile>().Select(file => file.Path).ToArray();
+                await ImportPlugins(selectedFiles);
+            }
+            catch (Exception ex)
+            {
+                ErrorSender.SendException(ex.WrapPluginException("No plugin has been imported due to following error:"));
+            }
+        }
+
+        private async void OnNativeFileDrop(string[] selectedFiles, PointInt32 dropPoint)
+        {
+            if (!IsPointInDropArea(dropPoint))
+            {
+                return;
+            }
+
+            await ImportPlugins(selectedFiles);
+        }
+
+        private void OnFileDragIndicatorTimerTick(object? sender, object e)
+        {
+            bool isExternalDragOverDropArea =
+                WindowUtility.TryGetExternalDragPosition(out PointInt32 dragPosition) &&
+                IsPointInDropArea(dragPosition);
+            SetImportDropIndicator(_isWinUiFileDragActive || isExternalDragOverDropArea);
+        }
+
+        private bool IsPointInDropArea(PointInt32 point)
+        {
+            Rect dropAreaBounds = ImportBoxButton.TransformToVisual(null)
+                                                     .TransformBounds(new Rect(0,
+                                                                               0,
+                                                                               ImportBoxButton.ActualWidth,
+                                                                               ImportBoxButton.ActualHeight));
+            double scaleFactor = WindowUtility.CurrentWindowMonitorScaleFactor;
+            return point.X >= dropAreaBounds.Left * scaleFactor &&
+                   point.X <= dropAreaBounds.Right * scaleFactor &&
+                   point.Y >= dropAreaBounds.Top * scaleFactor &&
+                   point.Y <= dropAreaBounds.Bottom * scaleFactor;
+        }
+
+        private void SetImportDropIndicator(bool isVisible)
+        {
+            if (_isDropIndicatorVisible == isVisible)
+            {
+                return;
+            }
+
+            _isDropIndicatorVisible = isVisible;
+            ImportDropIndicator.Opacity = isVisible ? 1 : 0;
+        }
+
+        private async Task ImportPlugins(string[] selectedFiles)
+        {
+            if (selectedFiles.Length == 0)
+            {
+                return;
+            }
+
+            int imported = 0;
+            try
+            {
+                ImportBoxButton.IsEnabled = false;
                 List<Exception> exceptions = [];
 
                 foreach (string filePath in selectedFiles)

From 2aa513bf422f84ecd3de52b5b258975af1a79f9d Mon Sep 17 00:00:00 2001
From: CryoTechnic <cryogen65@gmail.com>
Date: Wed, 15 Jul 2026 23:08:33 -0400
Subject: [PATCH 5/6] Improve error handling for plugin imports

- PluginImporter: support importing `.zip` packages or `manifest.json`, validate filenames, copy assets to a staging directory and atomically move into place, protect against directory-traversal by resolving contained paths (`GetContainedPath`), and ensure cleanup on failure. Uses stream-based copy for assets.
- PluginManagerPage: fixes drag indicator state, collects per-file failures instead of throwing `AggregateException`, logs errors, and shows a friendly dialog mapping common exceptions to readable messages.
---
 .../Classes/Plugins/PluginImporter.cs         | 73 ++++++++++++++++---
 .../MainApp/Pages/PluginManagerPage.xaml.cs   | 61 ++++++++++++----
 2 files changed, 107 insertions(+), 27 deletions(-)

diff --git a/CollapseLauncher/Classes/Plugins/PluginImporter.cs b/CollapseLauncher/Classes/Plugins/PluginImporter.cs
index b8f3b496b..50b908ca8 100644
--- a/CollapseLauncher/Classes/Plugins/PluginImporter.cs
+++ b/CollapseLauncher/Classes/Plugins/PluginImporter.cs
@@ -1,5 +1,6 @@
 using Hi3Helper.Plugin.Core.Update;
 using Hi3Helper.Shared.Region;
+using CollapseLauncher.Helper.StreamUtility;
 using System;
 using System.Data;
 using System.IO;
@@ -15,6 +16,14 @@ internal static partial class PluginImporter
     public static async Task<PluginInfo> AutoGetImportFromPath(string filePath, CancellationToken token)
     {
         bool isFromPackage = filePath.EndsWith(".zip", StringComparison.OrdinalIgnoreCase);
+        bool isFromManifest = string.Equals(Path.GetFileName(filePath),
+                                            PluginManager.ManifestPrefix,
+                                            StringComparison.OrdinalIgnoreCase);
+
+        if (!isFromPackage && !isFromManifest)
+        {
+            throw new NotSupportedException($"{Path.GetFileName(filePath)} is not supported. Import a .zip package or a file named manifest.json.");
+        }
 
         using IPluginSource pluginSource = isFromPackage ?
             await ZipPluginSource.GetSourceFrom(filePath, token) :
@@ -24,6 +33,7 @@ await ZipPluginSource.GetSourceFrom(filePath, token) :
         string pluginDirName       = $"Hi3Helper.Plugin.{pluginExecNameNoExt}";
         string pluginBaseDir       = Path.Combine(LauncherConfig.AppPluginFolder, pluginDirName);
         string pluginRelName       = Path.Combine(pluginDirName, pluginSource.Manifest.MainLibraryName);
+        string pluginEntryPath     = GetContainedPath(pluginBaseDir, pluginSource.Manifest.MainLibraryName);
 
         if (PluginManager.PluginInstances.ContainsKey(pluginBaseDir) ||
             PluginManager.PluginInstances.Values
@@ -44,25 +54,64 @@ await ZipPluginSource.GetSourceFrom(filePath, token) :
             });
         }
 
-        string pluginEntryPath = Path.Combine(pluginBaseDir, pluginSource.Manifest.MainLibraryName);
-        foreach (PluginManifestAssetInfo asset in pluginSource.Manifest.Assets)
+        Directory.CreateDirectory(LauncherConfig.AppPluginFolder);
+        string stagingDir = Path.Combine(LauncherConfig.AppPluginFolder, $".import-{Guid.NewGuid():N}");
+        string cleanupDir = stagingDir;
+
+        try
         {
-            string  assetFullPath = Path.Combine(pluginBaseDir, asset.FilePath);
-            string? assetFullDir  = Path.GetDirectoryName(assetFullPath);
+            foreach (PluginManifestAssetInfo asset in pluginSource.Manifest.Assets)
+            {
+                string  assetFullPath = GetContainedPath(stagingDir, asset.FilePath);
+                string? assetFullDir  = Path.GetDirectoryName(assetFullPath);
+
+                if (!string.IsNullOrEmpty(assetFullDir))
+                {
+                    Directory.CreateDirectory(assetFullDir);
+                }
+
+                await using FileStream assetStream             = File.Create(assetFullPath);
+                await using Stream     assetPluginSourceStream = await pluginSource.GetAssetStream(asset, token);
+
+                await assetPluginSourceStream.CopyToAsync(assetStream, token);
+            }
+
+            Directory.Move(stagingDir, pluginBaseDir);
+            cleanupDir = pluginBaseDir;
 
-            if (!string.IsNullOrEmpty(assetFullDir))
+            PluginInfo pluginInfo = new(pluginEntryPath,
+                                         pluginRelName,
+                                         pluginSource.Manifest);
+            cleanupDir = string.Empty;
+            return pluginInfo;
+        }
+        catch
+        {
+            if (!string.IsNullOrEmpty(cleanupDir))
             {
-                Directory.CreateDirectory(assetFullDir);
+                new DirectoryInfo(cleanupDir).TryDeleteDirectory(true);
             }
 
-            await using FileStream assetStream             = File.Create(assetFullPath);
-            await using Stream     assetPluginSourceStream = await pluginSource.GetAssetStream(asset, token);
+            throw;
+        }
+    }
+
+    private static string GetContainedPath(string baseDirectory, string relativePath)
+    {
+        if (string.IsNullOrWhiteSpace(relativePath))
+        {
+            throw new InvalidDataException("The plugin manifest contains an empty file path.");
+        }
 
-            await assetPluginSourceStream.CopyToAsync(assetStream, token);
+        string baseFullPath = Path.TrimEndingDirectorySeparator(Path.GetFullPath(baseDirectory));
+        string fileFullPath = Path.GetFullPath(relativePath, baseFullPath);
+        string basePrefix   = baseFullPath + Path.DirectorySeparatorChar;
+
+        if (!fileFullPath.StartsWith(basePrefix, StringComparison.OrdinalIgnoreCase))
+        {
+            throw new InvalidDataException($"The plugin manifest path '{relativePath}' points outside the plugin directory.");
         }
 
-        return new PluginInfo(pluginEntryPath,
-                              pluginRelName,
-                              pluginSource.Manifest);
+        return fileFullPath;
     }
 }
diff --git a/CollapseLauncher/XAMLs/MainApp/Pages/PluginManagerPage.xaml.cs b/CollapseLauncher/XAMLs/MainApp/Pages/PluginManagerPage.xaml.cs
index 5cb985a54..9063ef3c7 100644
--- a/CollapseLauncher/XAMLs/MainApp/Pages/PluginManagerPage.xaml.cs
+++ b/CollapseLauncher/XAMLs/MainApp/Pages/PluginManagerPage.xaml.cs
@@ -1,5 +1,6 @@
 using CollapseLauncher.Dialogs;
 using CollapseLauncher.Helper;
+using CollapseLauncher.XAMLs.Theme.ContentDialog;
 using CollapseLauncher.Plugins;
 using Hi3Helper;
 using Hi3Helper.SentryHelper;
@@ -9,7 +10,9 @@
 using Microsoft.UI.Xaml.Input;
 using System;
 using System.Collections.Generic;
+using System.Data;
 using System.Diagnostics;
+using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -166,6 +169,9 @@ private async void OnDropImportBox(object sender, DragEventArgs e)
 
         private async void OnNativeFileDrop(string[] selectedFiles, PointInt32 dropPoint)
         {
+            _isWinUiFileDragActive = false;
+            SetImportDropIndicator(false);
+
             if (!IsPointInDropArea(dropPoint))
             {
                 return;
@@ -215,10 +221,10 @@ private async Task ImportPlugins(string[] selectedFiles)
             }
 
             int imported = 0;
+            List<(string FilePath, Exception Exception)> failures = [];
             try
             {
                 ImportBoxButton.IsEnabled = false;
-                List<Exception> exceptions = [];
 
                 foreach (string filePath in selectedFiles)
                 {
@@ -230,27 +236,52 @@ private async Task ImportPlugins(string[] selectedFiles)
                     }
                     catch (Exception exception)
                     {
-                        exceptions.Add(exception);
+                        failures.Add((filePath, exception));
+                        Logger.LogWriteLine($"[PluginManagerPage::ImportPlugins] Failed to import: {filePath}\r\n{exception}",
+                                            LogType.Error,
+                                            true);
                     }
                 }
-
-                if (exceptions.Count > 0)
-                {
-                    throw new AggregateException(exceptions);
-                }
-            }
-            catch (Exception ex)
-            {
-                string messageHead = imported > 0 ?
-                    $"{imported} plugin(s) have been imported! But some error has occurred while importing other plugins:" :
-                    "No plugin has been imported due to following error:";
-
-                ErrorSender.SendException(ex.WrapPluginException(messageHead));
             }
             finally
             {
                 ImportBoxButton.IsEnabled = true;
             }
+
+            if (failures.Count == 0)
+            {
+                return;
+            }
+
+            string messageHead = imported > 0 ?
+                $"{imported} plugin(s) were imported, but {failures.Count} file(s) could not be imported:" :
+                "No plugins were imported:";
+            string failureMessages = string.Join(Environment.NewLine,
+                                                 failures.Select(failure =>
+                                                     $"- {Path.GetFileName(failure.FilePath)}: {GetFriendlyImportError(failure.FilePath, failure.Exception)}"));
+
+            string warningMessage = $"{messageHead}{Environment.NewLine}{Environment.NewLine}{failureMessages}";
+            await SimpleDialogs.SpawnDialog(Locale.Current.Lang?._UnhandledExceptionPage?.UnhandledTitle4 ?? "Warning",
+                                            warningMessage,
+                                            ImportBoxButton,
+                                            Locale.Current.Lang?._Misc?.Close,
+                                            dialogTheme: ContentDialogTheme.Warning);
+        }
+
+        private static string GetFriendlyImportError(string filePath, Exception exception)
+        {
+            return exception switch
+            {
+                NotSupportedException        => exception.Message,
+                DuplicateNameException      => exception.Message,
+                UnauthorizedAccessException => "Permission was denied while reading or installing the plugin.",
+                FileNotFoundException       => "The package is missing its manifest or another required file.",
+                InvalidDataException        => "The archive or manifest is invalid.",
+                IOException when filePath.EndsWith(".zip", StringComparison.OrdinalIgnoreCase) =>
+                    "The archive could not be read or installed.",
+                IOException => "The manifest or one of its referenced files could not be read.",
+                _ => "The file is not a valid or supported plugin."
+            };
         }
 
         internal static async void AskLauncherRestart(object? sender, RoutedEventArgs? e)

From 883fdc92476b01bc1f18a20fc62b653a0ba49dbd Mon Sep 17 00:00:00 2001
From: CryoTechnic <cryogen65@gmail.com>
Date: Wed, 15 Jul 2026 23:09:03 -0400
Subject: [PATCH 6/6] Remove foreground window check in drag logic

---
 CollapseLauncher/Classes/Helper/WindowUtility.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CollapseLauncher/Classes/Helper/WindowUtility.cs b/CollapseLauncher/Classes/Helper/WindowUtility.cs
index 37257c3bf..0b9e24a36 100644
--- a/CollapseLauncher/Classes/Helper/WindowUtility.cs
+++ b/CollapseLauncher/Classes/Helper/WindowUtility.cs
@@ -447,7 +447,7 @@ internal static bool TryGetExternalDragPosition(out PointInt32 dragPosition)
 
             dragPosition = default;
             nint windowHandle = CurrentWindowPtr;
-            if (windowHandle == nint.Zero || windowHandle == PInvoke.GetForegroundWindow())
+            if (windowHandle == nint.Zero)
             {
                 return false;
             }