Add progress bar detection to dialog system

Extend dialog detection to also detect Unity progress bars and the
startup splash window. Progress bars (EditorUtility.DisplayProgressBar,
DisplayCancelableProgressBar) and the UnitySplashWindow are now treated
as dialogs with optional progress/description fields.

On Windows, detects msctls_progress32 child controls (reading position
via PBM_GETPOS/PBM_GETRANGE) and Static text labels for descriptions.
Also matches UnitySplashWindow class in addition to #32770 dialogs.

DialogInfo DTO gains nullable description and progress fields, omitted
from JSON when not present for backwards compatibility.

Author: Niaobu

UnityCtl.Cli/DialogCommands.cs

@@ -28,7 +28,9 @@ public static Command CreateCommand()
                 var infos = dialogs.Select(d => new DialogInfo
                 {
                     Title = d.Title,
-                    Buttons = d.Buttons.Select(b => b.Text).ToArray()
+                    Buttons = d.Buttons.Select(b => b.Text).ToArray(),
+                    Description = d.Description,
+                    Progress = d.Progress
                 }).ToArray();
 
                 Console.WriteLine(JsonHelper.Serialize(infos));
@@ -51,6 +53,13 @@ public static Command CreateCommand()
                             var buttonLabels = dialog.Buttons.Select(b => $"[{b.Text}]");
                             Console.Write($" {string.Join(" ", buttonLabels)}");
                         }
+                        if (dialog.Progress.HasValue)
+                        {
+                            var pct = (int)(dialog.Progress.Value * 100);
+                            Console.Write($" ({pct}%)");
+                        }
+                        if (dialog.Description != null)
+                            Console.Write($" - {dialog.Description}");
                         Console.WriteLine();
                     }
                 }

UnityCtl.Cli/DialogDetector.cs

@@ -21,6 +21,12 @@ internal class DetectedDialog
 
     /// <summary>Platform-specific context needed for clicking buttons (e.g., macOS process name).</summary>
     public string? ProcessContext { get; init; }
+
+    /// <summary>Description text from static labels (e.g., progress bar description).</summary>
+    public string? Description { get; init; }
+
+    /// <summary>Progress value 0.0-1.0 if this dialog contains a progress bar, null otherwise.</summary>
+    public float? Progress { get; init; }
 }
 
 internal static class DialogDetector
@@ -81,24 +87,33 @@ private static List<DetectedDialog> DetectDialogsWindows(int processId)
             if (!Win32.IsWindowVisible(hWnd))
                 return true;
 
-            // Check for dialog class (#32770)
             var classNameBuf = new StringBuilder(256);
             Win32.GetClassName(hWnd, classNameBuf, classNameBuf.Capacity);
-            if (classNameBuf.ToString() != "#32770")
+            var className = classNameBuf.ToString();
+
+            // Match dialog windows (#32770) and Unity splash/loading windows
+            var isDialog = className == "#32770";
+            var isSplash = className == "UnitySplashWindow";
+            if (!isDialog && !isSplash)
                 return true;
 
             // Get title
             var titleBuf = new StringBuilder(256);
             Win32.GetWindowText(hWnd, titleBuf, titleBuf.Capacity);
             var title = titleBuf.ToString();
 
-            // Enumerate child buttons
+            // Enumerate child controls — buttons, progress bars, static text
             var buttons = new List<DetectedButton>();
+            float? progress = null;
+            string? description = null;
+
             Win32.EnumChildWindows(hWnd, (childHwnd, __) =>
             {
                 var childClassBuf = new StringBuilder(256);
                 Win32.GetClassName(childHwnd, childClassBuf, childClassBuf.Capacity);
-                if (childClassBuf.ToString() == "Button")
+                var childClass = childClassBuf.ToString();
+
+                if (childClass == "Button")
                 {
                     var btnTextBuf = new StringBuilder(256);
                     Win32.GetWindowText(childHwnd, btnTextBuf, btnTextBuf.Capacity);
@@ -114,14 +129,38 @@ private static List<DetectedDialog> DetectDialogsWindows(int processId)
                         });
                     }
                 }
+                else if (childClass == "msctls_progress32")
+                {
+                    // Read progress position and range
+                    var pos = (int)Win32.SendMessage(childHwnd, Win32.PBM_GETPOS, IntPtr.Zero, IntPtr.Zero);
+                    var rangeHigh = (int)Win32.SendMessage(childHwnd, Win32.PBM_GETRANGE, IntPtr.Zero, IntPtr.Zero);
+                    if (rangeHigh <= 0)
+                        rangeHigh = 100; // default range
+                    progress = Math.Clamp((float)pos / rangeHigh, 0f, 1f);
+                }
+                else if (childClass == "Static")
+                {
+                    var textBuf = new StringBuilder(512);
+                    Win32.GetWindowText(childHwnd, textBuf, textBuf.Capacity);
+                    var text = textBuf.ToString();
+                    if (!string.IsNullOrWhiteSpace(text))
+                    {
+                        // Keep the longest static text as the description
+                        if (description == null || text.Length > description.Length)
+                            description = text;
+                    }
+                }
+
                 return true;
             }, IntPtr.Zero);
 
             dialogs.Add(new DetectedDialog
             {
                 Title = title,
                 Buttons = buttons,
-                NativeHandle = hWnd
+                NativeHandle = hWnd,
+                Description = description,
+                Progress = progress
             });
 
             return true; // continue looking for more dialogs
@@ -548,6 +587,8 @@ private static class Win32
     {
         public const uint BM_CLICK = 0x00F5;
         public const uint WM_COMMAND = 0x0111;
+        public const uint PBM_GETPOS = 0x0408;
+        public const uint PBM_GETRANGE = 0x0407;
 
         public delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam);
 

UnityCtl.Cli/StatusCommand.cs

@@ -94,7 +94,7 @@ public static Command CreateCommand()
                 UnityConnectedToBridge = unityConnected
             };
 
-            // Detect popup dialogs if Unity is running
+            // Detect popup dialogs (including progress bars) if Unity is running
             DialogInfo[]? detectedDialogs = null;
             if (result.UnityEditorRunning)
             {
@@ -108,7 +108,9 @@ public static Command CreateCommand()
                         detectedDialogs = dialogs.Select(d => new DialogInfo
                         {
                             Title = d.Title,
-                            Buttons = d.Buttons.Select(b => b.Text).ToArray()
+                            Buttons = d.Buttons.Select(b => b.Text).ToArray(),
+                            Description = d.Description,
+                            Progress = d.Progress
                         }).ToArray();
                     }
                 }
@@ -214,7 +216,7 @@ private static void PrintHumanReadableStatus(ProjectStatusResult status, string?
             }
         }
 
-        // Popup dialogs
+        // Popup dialogs (including progress bars)
         if (dialogs != null && dialogs.Length > 0)
         {
             Console.WriteLine();
@@ -230,9 +232,17 @@ private static void PrintHumanReadableStatus(ProjectStatusResult status, string?
                     var buttonLabels = dialog.Buttons.Select(b => $"[{b}]");
                     Console.Write($" {string.Join(" ", buttonLabels)}");
                 }
+                if (dialog.Progress.HasValue)
+                {
+                    var pct = (int)(dialog.Progress.Value * 100);
+                    Console.Write($" ({pct}%)");
+                }
+                if (dialog.Description != null)
+                    Console.Write($" - {dialog.Description}");
                 Console.WriteLine();
             }
-            Console.WriteLine("  Use 'unityctl dialog dismiss' to dismiss");
+            if (dialogs.Any(d => d.Buttons.Length > 0))
+                Console.WriteLine("  Use 'unityctl dialog dismiss' to dismiss");
         }
 
         // Version information

UnityCtl.Protocol/DTOs.cs

@@ -322,6 +322,12 @@ public class DialogInfo
 
     [JsonProperty("buttons")]
     public required string[] Buttons { get; init; }
+
+    [JsonProperty("description")]
+    public string? Description { get; init; }
+
+    [JsonProperty("progress")]
+    public float? Progress { get; init; }
 }
 
 /// <summary>

UnityCtl.UnityPackage/Plugins/UnityCtl.Protocol.dll

@@ -1,12 +1,12 @@
 # Dialog Detection
 
-Unity Editor shows modal dialog popups in various situations — compilation errors triggering Safe Mode, license issues, import failures, etc. These dialogs block Unity's main thread, which means:
+Unity Editor shows modal dialog popups and progress bars in various situations — compilation errors triggering Safe Mode, license issues, import failures, asset imports, builds, editor startup, etc. These block Unity's main thread, which means:
 
 - The UnityCtl plugin cannot process any RPC commands
 - `unityctl wait` hangs indefinitely
 - The bridge reports Unity as connected, but all commands time out (504)
 
-The `dialog` command detects these popups from the CLI side (no bridge or plugin needed) and can dismiss them programmatically.
+The `dialog` command detects these popups from the CLI side (no bridge or plugin needed) and can dismiss them programmatically. Progress bars (e.g., asset imports, builds, editor startup) are treated as dialogs — they may have no buttons but include progress percentage and description text.
 
 ## Commands
 
@@ -26,6 +26,29 @@ $ unityctl dialog list --json
 [{"title":"Enter Safe Mode?","buttons":["Enter Safe Mode","Ignore","Quit"]}]
 ```
 
+Progress bars show additional fields:
+
+```
+$ unityctl dialog list
+Detected 1 dialog(s):
+
+  "Building Player (busy for 35s)..." [Cancel] [Skip Transcoding] (100%) - Write asset files
+```
+
+```
+$ unityctl dialog list --json
+[{"title":"Building Player (busy for 35s)...","buttons":["Cancel","Skip Transcoding"],"description":"Write asset files","progress":1.0}]
+```
+
+During editor startup, the loading splash is detected as a button-less dialog with progress:
+
+```
+$ unityctl dialog list
+Detected 1 dialog(s):
+
+  "Opening project..." (46%)
+```
+
 ### `unityctl dialog dismiss`
 
 Dismisses the first detected dialog by clicking a button.
@@ -47,14 +70,22 @@ Popups: [!] 1 dialog detected
   Use 'unityctl dialog dismiss' to dismiss
 ```
 
+Progress bars also appear in status output:
+
+```
+Popups: [!] 1 dialog detected
+  "Compiling Scripts (busy for 23s)..." [Cancel] [Skip Transcoding] (10%) - Compiling C# (UnityEngine.UI)
+  Use 'unityctl dialog dismiss' to dismiss
+```
+
 ## Architecture
 
 Dialog detection is purely client-side — it runs in the CLI process using OS-level window APIs. This is necessary because dialogs block Unity's main thread, so the plugin can't respond to bridge commands.
 
 The flow is:
 1. Find the Unity process for the project (`FindUnityProcessForProject`)
-2. Use platform-specific APIs to enumerate that process's dialog windows
-3. Extract window titles and button labels
+2. Use platform-specific APIs to enumerate that process's dialog and splash windows
+3. Extract window titles, button labels, progress bar values, and description text
 4. Optionally click a button to dismiss
 
 ## Platform Support
@@ -63,11 +94,22 @@ The flow is:
 
 Uses Win32 P/Invoke APIs to detect and interact with dialogs:
 
-- **Detection**: `EnumWindows` to find visible windows belonging to the Unity PID, filtering for the `#32770` dialog window class
+- **Detection**: `EnumWindows` to find visible windows belonging to the Unity PID, filtering for the `#32770` dialog window class and `UnitySplashWindow` (Unity's startup/loading window)
 - **Button enumeration**: `EnumChildWindows` to find child controls with the `Button` class, reading text via `GetWindowText`
 - **Button text cleanup**: Win32 button text includes `&` accelerator prefixes (e.g., `&OK`, `&Cancel`) — these are stripped automatically
+- **Progress bars**: Detects `msctls_progress32` child controls, reads position via `SendMessage(PBM_GETPOS)` and range via `SendMessage(PBM_GETRANGE)`, normalizes to 0.0-1.0
+- **Description text**: Reads `Static` child controls for description labels (e.g., "Compiling C# (UnityEngine.UI)")
 - **Clicking**: `SendMessage(WM_COMMAND)` to the parent dialog with the button's control ID (via `GetDlgCtrlID`). `SetForegroundWindow` is called first to ensure the dialog processes messages
 
+**Window classes detected:**
+
+| Class | What | Examples |
+|-------|------|----------|
+| `#32770` | Standard Win32 dialog | Safe Mode prompt, `EditorUtility.DisplayDialog`, `DisplayProgressBar`, `DisplayCancelableProgressBar` |
+| `UnitySplashWindow` | Unity startup/loading splash | "Opening project..." with progress bar during editor launch |
+
+Both classes can contain `msctls_progress32` progress bar controls and `Static` text labels. The `UnitySplashWindow` typically has no buttons (or an empty-text button), while `#32770` dialogs from `DisplayCancelableProgressBar` include Cancel and Skip Transcoding buttons.
+
 **Why `SendMessage(WM_COMMAND)` instead of `PostMessage(BM_CLICK)`**: During testing, `PostMessage(BM_CLICK)` proved unreliable across processes — the dismiss would report success but the dialog wouldn't actually close. `SendMessage(WM_COMMAND)` mimics exactly what the dialog's own message loop does when a button is clicked, making it reliable cross-process. Falls back to `SendMessage(BM_CLICK)` if control ID lookup fails.
 
 **No special permissions required.** Works from any terminal, SSH session, or CI environment.
@@ -184,17 +226,30 @@ Key details:
 
 ### `DialogDetector.cs`
 
-Single static class with platform dispatch (`DetectDialogs`, `ClickButton`). Best-effort on all platforms — if detection fails (missing tools, no permissions), returns empty list silently. Never fails the parent command.
+Single static class with platform dispatch (`DetectDialogs`, `ClickButton`). Best-effort on all platforms — if detection fails (missing tools, no permissions), returns empty list silently. Never fails the parent command. Returns `DetectedDialog` objects with optional `Description` (from static text labels) and `Progress` (0.0-1.0 from progress bar controls).
 
 ### `DialogCommands.cs`
 
 Two subcommands under `unityctl dialog`:
-- `list` — enumerates dialogs, outputs human-readable or JSON
+- `list` — enumerates dialogs, outputs human-readable or JSON. Shows progress percentage and description when present.
 - `dismiss --button <text>` — clicks the named button (case-insensitive), defaults to first button
 
 ### `StatusCommand.cs`
 
-If Unity is running, calls `DialogDetector.DetectDialogs` and includes any detected dialogs in both human-readable and JSON output.
+If Unity is running, calls `DialogDetector.DetectDialogs` and includes any detected dialogs (including progress bars) in both human-readable and JSON output. The "Use 'unityctl dialog dismiss' to dismiss" hint is only shown when at least one dialog has buttons.
+
+### `DialogInfo` (Protocol DTO)
+
+```json
+{
+  "title": "Building Player (busy for 35s)...",
+  "buttons": ["Cancel", "Skip Transcoding"],
+  "description": "Write asset files",
+  "progress": 1.0
+}
+```
+
+The `description` and `progress` fields are nullable — omitted from JSON when not present (e.g., for plain button dialogs like Safe Mode prompts).
 
 ### Subprocess timeout