ResoDrive 0.3.1

Author: alphasixtyfive

CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.3.1] - 2026-08-28
+
+- Prevent a crash when restoring a maximized window after background startup.
+- Contain notification-area callback failures so a single UI action cannot
+  terminate the application.
+- Log fatal early-startup failures with an error ID and show a useful error
+  message instead of exiting silently.
+
 ## [0.3.0] - 2026-08-28
 
 First public preview of the cleaned ResoDrive codebase.
@@ -14,4 +22,5 @@ First public preview of the cleaned ResoDrive codebase.
 - Install through a small setup bundle that downloads the .NET Desktop Runtime
   only when it is missing.
 
+[0.3.1]: https://github.com/alphasixtyfive/resodrive/releases/tag/v0.3.1
 [0.3.0]: https://github.com/alphasixtyfive/resodrive/releases/tag/v0.3.0

Directory.Build.props

@@ -9,7 +9,7 @@
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     <Deterministic>true</Deterministic>
     <RestorePackagesWithLockFile>true</RestorePackagesWithLockFile>
-    <VersionPrefix>0.3.0</VersionPrefix>
+    <VersionPrefix>0.3.1</VersionPrefix>
     <ProductDisplayName>ResoDrive</ProductDisplayName>
     <ExecutableBaseName>resodrive</ExecutableBaseName>
     <ProductDescription>Mount Nextcloud, other WebDAV storage, and SFTP servers as drives in Windows</ProductDescription>

RELEASE_NOTES.md

@@ -1,14 +1,10 @@
-ResoDrive 0.3 is a focused public preview.
+ResoDrive 0.3.1 fixes a crash that could occur when reopening a maximized window
+after ResoDrive started in the background.
 
-It mounts Nextcloud, WebDAV, and SFTP storage as Windows drives, runs copy and
-mirror jobs, and keeps active work running when the management window is closed.
-Optional sign-in startup now uses Windows Task Scheduler without an artificial
-delay.
+Notification-area actions are now isolated so an unexpected failure in one UI
+callback cannot terminate the application. Fatal failures during very early
+startup are also written to the diagnostic log and displayed with an error ID
+instead of looking like a silent exit.
 
-Mount recovery uses bounded retry intervals for slow or intermittent links.
-Application and rclone downloads can continue after a dropped connection and are
-verified before use.
-
-The normal download is `ResoDrive-Setup.exe`. It keeps updates small by using the
-shared .NET 10 Desktop Runtime and downloads that prerequisite only when required.
-WinFsp remains necessary only for drive mounting.
+The normal download is `ResoDrive-Setup.exe`. Existing settings, credentials,
+mounts, and sync jobs are preserved during the upgrade.

src/ResoDrive.App/Infrastructure/TrayController.cs

@@ -116,7 +116,18 @@ private void Dispatch(Action action)
         if (_disposed || _dispatcher.HasShutdownStarted) return;
         try
         {
-            _dispatcher.BeginInvoke(() => { if (!_disposed) action(); });
+            _dispatcher.BeginInvoke(() =>
+            {
+                if (_disposed) return;
+                try
+                {
+                    action();
+                }
+                catch (Exception exception)
+                {
+                    ReportError(exception);
+                }
+            });
         }
         catch (InvalidOperationException)
         {
@@ -174,12 +185,25 @@ private async Task RunActionAsync(Func<Task<TrayActionResult>> action, Action<Tr
         catch (OperationCanceledException) { }
         catch (Exception exception)
         {
-            _reportError?.Invoke(exception);
+            ReportError(exception);
             if (!_disposed)
                 ShowResult(TrayActionResult.Failure("Action failed", $"The operation could not be completed. Open {ProductInfo.Name} to see details."));
         }
     }
 
+    private void ReportError(Exception exception)
+    {
+        try
+        {
+            _reportError?.Invoke(exception);
+        }
+        catch (Exception reportingException)
+        {
+            UiDiagnosticLog.Current.Exception("tray.error_reporting_failed", reportingException);
+        }
+        UiDiagnosticLog.Current.Exception("tray.action_failed", exception);
+    }
+
     private static string Truncate(string value, int maximumLength) => value.Length <= maximumLength
         ? value : string.Concat(value.AsSpan(0, maximumLength - 1), "…");
 }

src/ResoDrive.App/Infrastructure/WindowRestoration.cs

@@ -0,0 +1,21 @@
+using System.Windows;
+
+namespace ResoDrive.App;
+
+internal static class WindowRestoration
+{
+    internal static void PrepareForShow(Window window)
+    {
+        ArgumentNullException.ThrowIfNull(window);
+
+        // WPF rejects showing a maximized window when ShowActivated is false. A
+        // background launch deliberately sets that flag to false, so reset it
+        // before making the window visible again. Normalize a hidden maximized
+        // window as an additional guard; the caller reapplies the saved state
+        // after Show has created/restored the native window.
+        window.ShowActivated = true;
+        window.ShowInTaskbar = true;
+        if (!window.IsVisible && window.WindowState == WindowState.Maximized)
+            window.WindowState = WindowState.Normal;
+    }
+}

src/ResoDrive.App/MainWindow.xaml.cs

@@ -2385,13 +2385,14 @@ private void HideToTray()
 
     private void RestoreWindow()
     {
-        ShowInTaskbar = true;
+        var restoredState = _windowStateBeforeMinimize == WindowState.Maximized
+            ? WindowState.Maximized
+            : WindowState.Normal;
+        WindowRestoration.PrepareForShow(this);
         Show();
         var handle = new System.Windows.Interop.WindowInteropHelper(this).Handle;
         WindowAppearance.Restore(handle);
-        WindowState = _windowStateBeforeMinimize == WindowState.Maximized
-            ? WindowState.Maximized
-            : WindowState.Normal;
+        WindowState = restoredState;
         Activate();
         WindowAppearance.BringToForeground(handle);
         Focus();

src/ResoDrive.App/Program.cs

@@ -73,9 +73,29 @@ public static int Main(string[] args)
             return 0;
         }
 
-        var application = new App();
-        application.InitializeComponent();
-        return application.Run();
+        try
+        {
+            var application = new App();
+            application.InitializeComponent();
+            return application.Run();
+        }
+        catch (Exception exception)
+        {
+            var errorId = UiDiagnosticLog.Current.Exception("startup.fatal", exception);
+            try
+            {
+                System.Windows.MessageBox.Show(
+                    $"{ProductInfo.Name} could not start.\n\n{exception.Message}\n\nError ID: {errorId}",
+                    $"{ProductInfo.Name} startup error",
+                    System.Windows.MessageBoxButton.OK,
+                    System.Windows.MessageBoxImage.Error);
+            }
+            catch (Exception dialogException)
+            {
+                UiDiagnosticLog.Current.Exception("startup.error_dialog_failed", dialogException);
+            }
+            return 1;
+        }
     }
 
     internal static void TryStartHostEarly()

tests/ResoDrive.App.Tests/WindowRestorationTests.cs

@@ -0,0 +1,73 @@
+using System.Windows;
+
+namespace ResoDrive.App.Tests;
+
+public sealed class WindowRestorationTests
+{
+    [Fact]
+    public void PrepareForShow_MakesHiddenMaximizedBackgroundWindowSafeToShow()
+    {
+        RunInSta(() =>
+        {
+            var window = new Window
+            {
+                ShowActivated = false,
+                ShowInTaskbar = false,
+                WindowState = WindowState.Maximized,
+            };
+
+            WindowRestoration.PrepareForShow(window);
+
+            Assert.True(window.ShowActivated);
+            Assert.True(window.ShowInTaskbar);
+            Assert.Equal(WindowState.Normal, window.WindowState);
+            var exception = Record.Exception(window.Show);
+            Assert.Null(exception);
+            window.Close();
+        });
+    }
+
+    [Theory]
+    [InlineData(WindowState.Normal)]
+    [InlineData(WindowState.Minimized)]
+    public void PrepareForShow_PreservesNonMaximizedState(WindowState state)
+    {
+        RunInSta(() =>
+        {
+            var window = new Window
+            {
+                ShowActivated = false,
+                ShowInTaskbar = false,
+                WindowState = state,
+            };
+
+            WindowRestoration.PrepareForShow(window);
+
+            Assert.True(window.ShowActivated);
+            Assert.True(window.ShowInTaskbar);
+            Assert.Equal(state, window.WindowState);
+            window.Close();
+        });
+    }
+
+    private static void RunInSta(Action action)
+    {
+        Exception? failure = null;
+        var thread = new Thread(() =>
+        {
+            try
+            {
+                action();
+            }
+            catch (Exception exception)
+            {
+                failure = exception;
+            }
+        });
+        thread.SetApartmentState(ApartmentState.STA);
+        thread.Start();
+        Assert.True(thread.Join(TimeSpan.FromSeconds(10)));
+        if (failure is not null)
+            throw failure;
+    }
+}