fix: add minimum size clamps and restore validation for window sizing (#2392)

- Add MIN_MAIN_WIDTH/HEIGHT and MIN_ONBOARDING_WIDTH/HEIGHT constants
- Update window_size_with_ratio to enforce minimum sizes
- Add explicit min_inner_size to window builders
- Validate restored window size after restore_state to prevent tiny windows

This fixes issues where windows could become unusably small in screen
mirroring scenarios or when bad sizes were persisted across DPI changes.

Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Co-authored-by: yujonglee <[email protected]>

Author: devin-ai-integration[bot]

plugins/windows/src/ext.rs

@@ -91,8 +91,26 @@ impl AppWindow {
         let window = self.build_window(app)?;
 
         if matches!(self, Self::Main) {
+            use tauri::LogicalSize;
             use tauri_plugin_window_state::{StateFlags, WindowExt};
+
             let _ = window.restore_state(StateFlags::SIZE);
+
+            if let Ok(size) = window.inner_size() {
+                let scale = window.scale_factor().unwrap_or(1.0);
+                let logical_width = size.width as f64 / scale;
+                let logical_height = size.height as f64 / scale;
+
+                const MIN_WIDTH: f64 = 620.0;
+                const MIN_HEIGHT: f64 = 500.0;
+
+                if logical_width < MIN_WIDTH || logical_height < MIN_HEIGHT {
+                    let _ = window.set_size(LogicalSize::new(
+                        logical_width.max(MIN_WIDTH),
+                        logical_height.max(MIN_HEIGHT),
+                    ));
+                }
+            }
         }
 
         window.show()?;

plugins/windows/src/window/v1.rs

@@ -91,14 +91,21 @@ impl AppWindow {
 
 const MAX_MAIN_WIDTH: f64 = 1600.0;
 const MAX_MAIN_HEIGHT: f64 = 1000.0;
+const MIN_MAIN_WIDTH: f64 = 620.0;
+const MIN_MAIN_HEIGHT: f64 = 500.0;
+
 const MAX_ONBOARDING_WIDTH: f64 = 900.0;
 const MAX_ONBOARDING_HEIGHT: f64 = 700.0;
+const MIN_ONBOARDING_WIDTH: f64 = 400.0;
+const MIN_ONBOARDING_HEIGHT: f64 = 600.0;
 
 fn window_size_with_ratio(
     monitor_width: f64,
     monitor_height: f64,
     aspect_ratio: f64,
     scale: f64,
+    min_width: f64,
+    min_height: f64,
     max_width: f64,
     max_height: f64,
 ) -> (f64, f64) {
@@ -112,14 +119,16 @@ fn window_size_with_ratio(
         (height * aspect_ratio, height)
     };
 
-    if width > max_width || height > max_height {
+    let (width, height) = if width > max_width || height > max_height {
         let scale_w = max_width / width;
         let scale_h = max_height / height;
         let scale = scale_w.min(scale_h);
         (width * scale, height * scale)
     } else {
         (width, height)
-    }
+    };
+
+    (width.max(min_width), height.max(min_height))
 }
 
 impl WindowImpl for AppWindow {
@@ -157,13 +166,16 @@ impl WindowImpl for AppWindow {
                     monitor_height,
                     2.0 / 3.0,
                     0.7,
+                    MIN_ONBOARDING_WIDTH,
+                    MIN_ONBOARDING_HEIGHT,
                     MAX_ONBOARDING_WIDTH,
                     MAX_ONBOARDING_HEIGHT,
                 );
 
                 self.window_builder(app, "/app/onboarding")
                     .resizable(false)
                     .inner_size(width, height)
+                    .min_inner_size(MIN_ONBOARDING_WIDTH, MIN_ONBOARDING_HEIGHT)
                     .prevent_overflow_with_margin(margin)
                     .center()
                     .build()?
@@ -174,23 +186,17 @@ impl WindowImpl for AppWindow {
                     monitor_height,
                     4.0 / 3.0,
                     0.8,
+                    MIN_MAIN_WIDTH,
+                    MIN_MAIN_HEIGHT,
                     MAX_MAIN_WIDTH,
                     MAX_MAIN_HEIGHT,
                 );
-                let (min_w, min_h) = window_size_with_ratio(
-                    monitor_width,
-                    monitor_height,
-                    4.0 / 3.0,
-                    0.4,
-                    MAX_MAIN_WIDTH * 0.5,
-                    MAX_MAIN_HEIGHT * 0.5,
-                );
 
                 self.window_builder(app, "/app/main")
                     .maximizable(true)
                     .minimizable(true)
                     .inner_size(width, height)
-                    .min_inner_size(min_w, min_h)
+                    .min_inner_size(MIN_MAIN_WIDTH, MIN_MAIN_HEIGHT)
                     .prevent_overflow_with_margin(margin)
                     .center()
                     .build()?