gui_harness 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: afff804578f10a3d1b8771275024455eae4c201963d7cf0d928872b489aad081
+  data.tar.gz: 5221573ce1abf1b9d35d712b1724d1e0ee625e0fe79e596121143d642c195f10
+SHA512:
+  metadata.gz: 1d397f9c0a20952b91c94ab1af33c09680f5ea8409d23efbe9af4f498e8f128d41763480666e09f8698cd77b6bd7a62f21c38adf7f0c869a419a58f6e8e90e97
+  data.tar.gz: f1d39f58e2647347f3375100f5589ab54d2f7d6b9851a679c0b859b626399c48c950a04c099bae155b1841a2218cfb6a82aef60e1fef40949976d7df1d7e8eaf

data/.rubocop.yml

@@ -0,0 +1,60 @@
+plugins:
+  - rubocop-md
+  - rubocop-performance
+  - rubocop-rake
+  - rubocop-rspec
+
+AllCops:
+  Exclude:
+    - binstub/**
+    - exe/**
+    - vendor/**
+    - Gemfile*
+    - TODO.md
+  NewCops: enable
+  TargetRubyVersion: 3.4
+
+Gemspec/RequireMFA:
+  Enabled: false
+
+Layout/HashAlignment:
+  EnforcedColonStyle: table
+  EnforcedHashRocketStyle: table
+
+Layout/LineLength:
+  Max: 150
+
+Metrics/AbcSize:
+  Max: 35
+
+Metrics/BlockLength:
+  Max: 30
+
+Metrics/CyclomaticComplexity:
+  Max: 15
+
+Metrics/MethodLength:
+  Max: 40
+
+Metrics/ModuleLength:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Max: 15
+
+# The harness examples assert the whole result of a launch: the exit code, the dialog, its
+# classification, and the outcome. Splitting them would assert less of the contract.
+RSpec/ExampleLength:
+  Enabled: false
+
+RSpec/MultipleExpectations:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: comma

data/README.md

@@ -0,0 +1,155 @@
+# gui_harness [![Gem Version](https://badge.fury.io/rb/gui_harness.svg)](https://badge.fury.io/rb/gui_harness)
+
+A Ruby harness for real GUI automation and end-to-end compatibility testing.
+
+## Purpose
+
+`gui_harness` is a small library for driving real desktop applications the way a user does: launch the actual process, inspect the windows it owns, read the visible dialog text, classify the modal state, dismiss the blocking prompt, and return a structured result for tests.
+
+This project is intentionally not a log-only parser. The process-owned window probe is the source of truth. The harness treats the UI as the contract.
+
+The harness is designed for the real WSL-to-Windows workflow: Ruby runs in WSL, then the target GUI is launched by PowerShell on Windows. The launcher script is treated as a deployed runtime asset, not as Ruby source code.
+
+## Project layout
+
+- `lib/` contains the Ruby API and domain logic
+- `assets/` contains runtime assets that are deployed with the gem, including the Windows PowerShell launcher
+- `spec/` contains end-to-end, real-GUI regression tests
+- `.vscode/launch.json` contains editor launch entries for the real harness flow
+
+## Core behavior
+
+The harness is designed to do the following:
+
+- launch a GUI executable
+- retain the process identity
+- enumerate the top-level windows owned by that process
+- walk the accessibility tree for a visible modal
+- read text exposed by the dialog
+- map the text to a known class of dialog
+- trigger the correct dismissal action
+- return a machine-readable outcome for the test harness
+
+## Design principles
+
+- no stubs, mocks, or simulations
+- prefer actual GUI state over synthetic parser assumptions
+- retain a simple result model for tests
+- classify dialogs by visible text and expected user action
+- keep the implementation reusable across desktop apps
+
+## API
+
+The main entry point is `GuiHarness::LiveLauncher`.
+
+```ruby
+require 'gui_harness'
+
+result = GuiHarness::LiveLauncher.launch(
+  'C:/Program Files/Ableton/Live 12 Suite/Program/Ableton Live 12 Suite.exe',
+  'C:/path/to/test.als',
+  timeout: 120
+)
+
+puts result.exit_code
+puts result.dialog
+puts result.dialog_type
+puts result.dismiss_action
+puts result.outcome
+```
+
+### `classify_dialog`
+
+The library can also classify a dialog text string directly:
+
+```ruby
+GuiHarness::LiveLauncher.classify_dialog('A serious program error has occurred.')
+# => { type: :fatal, action: { type: "button", value: "OK" } }
+
+GuiHarness::LiveLauncher.classify_dialog('Save changes?')
+# => { type: :save_changes, action: { type: "button", value: "No" } }
+
+GuiHarness::LiveLauncher.classify_dialog("Cannot find the file 'missing.als'. Make sure the path and file name are correct.")
+# => { type: :error, action: { type: "button", value: "OK" } }
+```
+
+## Result model
+
+The launch result is a Ruby `Struct` with the following fields:
+
+- `exit_code`
+- `output`
+- `dialog`
+- `dialog_type`
+- `dismiss_action`
+- `log`
+- `loaded`
+- `crashed`
+
+It also exposes a derived `outcome` method:
+
+- `:loaded`
+- `:crashed`
+- `:blocked`
+- `:unknown`
+
+This keeps a real GUI run easy to assert in Ruby specs without exposing raw UIAutomation internals.
+
+## Real-world usage
+
+The harness is intended for round-trip and compatibility testing against real apps. A typical scenario is to launch a real desktop app with a real `.als` file, let it show a modal, classify the dialog, dismiss it, and then assert on the final state.
+
+The project includes two live Notepad regression paths:
+
+- error path: launch Notepad with a missing file and assert that the real `Cannot find the file ...` dialog is detected and dismissed
+- success path: launch Notepad with a valid file and assert that there is no dialog, the run reports success, and the app exits cleanly without leaving a process behind
+
+This is exactly the kind of real-world modal handling the harness is meant to observe and report.
+
+## PowerShell/Windows integration
+
+The Ruby class delegates actual window inspection to a PowerShell script in `assets/`. The script enumerates the real Windows UI, walks the automation tree, reads dialog text, and returns the observed information in a format that Ruby can parse.
+
+This separation keeps Ruby as the test-facing layer while leaving the actual OS-specific automation in the deployment asset that ships with the gem.
+
+## VS Code workflow
+
+This project includes a small VS Code launch setup for running the real-GUI specs directly from the editor.
+
+### Launch configurations
+
+From the Run and Debug panel, use one of these entries:
+
+- `RSpec: all specs` — runs the whole suite
+- `RSpec: current file` — runs the active spec file
+- `Ruby: quick Notepad probe` — runs the direct WSL-to-Windows dialog probe used during harness debugging
+
+The harness is meant to run from WSL while the app itself is launched on Windows via PowerShell. That is the supported environment for the real GUI tests.
+
+## Development
+
+The project is meant to be developed and debugged from WSL, while the GUI itself is launched on Windows. This is intentional and is part of the contract: the harness is a real native-GUI automation layer, not a mocked or local-only emulator.
+
+Install dependencies:
+
+```bash
+bundle install
+```
+
+Run the test suite:
+
+```bash
+bundle exec rspec
+```
+
+Run the focused GUI harness spec:
+
+```bash
+bundle exec rspec spec/live_launcher_spec.rb --format documentation
+```
+
+## Testing philosophy
+
+This library is not a mock-based parser. It is built to validate real desktop behavior, real dialogs, and real app states. When the harness says a dialog is fatal, recovery, save-related, or an ordinary file error, it is because the real Windows UI exposed that text and the harness classified it as such.
+
+That is what makes it useful for debugging actual compatibility paths and crash-recovery flows.

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+desc 'Run the test suite'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task default: :test

data/assets/gui_harness_live_launcher.ps1

@@ -0,0 +1,464 @@
+<#
+  GUI process probe for real-app compatibility testing.
+
+  This script is the Windows-side implementation of the harness contract:
+  - launch a GUI executable from WSL via PowerShell
+  - retain ownership of the process and its windows
+  - inspect the visible UIAutomation tree for real modal dialogs
+  - classify the dialog from its user-visible text
+  - dismiss the blocking control when possible
+  - terminate the process tree cleanly before returning
+#>
+param(
+  [Parameter(Mandatory=$true)][string]$Exe,
+  [Parameter(Mandatory=$true)][string]$Set,
+  [string]$Log = '',
+  [int]$TimeoutSeconds = 5,
+  [ValidateSet('normal','minimized','hidden')][string]$Visibility = 'normal'
+)
+
+$ErrorActionPreference = 'Stop'
+Add-Type -AssemblyName UIAutomationClient
+Add-Type -AssemblyName UIAutomationTypes
+
+Add-Type @'
+using System;
+using System.Text;
+using System.Runtime.InteropServices;
+public class Live {
+  [DllImport("user32.dll")] public static extern bool EnumWindows(EnumWindowsProc cb, IntPtr l);
+  public delegate bool EnumWindowsProc(IntPtr h, IntPtr l);
+  [DllImport("user32.dll", CharSet=CharSet.Unicode)] public static extern int GetWindowText(IntPtr h, StringBuilder s, int n);
+  [DllImport("user32.dll")] public static extern int GetWindowTextLength(IntPtr h);
+  [DllImport("user32.dll", CharSet=CharSet.Unicode)] public static extern int GetClassName(IntPtr h, StringBuilder s, int n);
+  [DllImport("user32.dll")] public static extern bool IsWindowVisible(IntPtr h);
+  [DllImport("user32.dll")] public static extern uint GetWindowThreadProcessId(IntPtr h, out uint pid);
+  [DllImport("user32.dll")] public static extern bool PostMessage(IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam);
+  [DllImport("user32.dll")] public static extern bool DestroyWindow(IntPtr hWnd);
+  [DllImport("user32.dll")] public static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
+}
+'@
+
+function Stop-ProcessTree([int[]]$ProcessIds) {
+  $seen = New-Object 'System.Collections.Generic.HashSet[int]'
+  $stack = New-Object 'System.Collections.Generic.Stack[int]'
+  foreach ($processId in $ProcessIds) { if ($processId -gt 0) { $stack.Push($processId) } }
+
+  while ($stack.Count -gt 0) {
+    $currentPid = $stack.Pop()
+    if (-not $seen.Add($currentPid)) { continue }
+    foreach ($child in Get-CimInstance Win32_Process -Filter "ParentProcessId = $currentPid" -ErrorAction SilentlyContinue) {
+      $stack.Push([int]$child.ProcessId)
+    }
+  }
+
+  foreach ($processId in $seen) {
+    try { Stop-Process -Id $processId -Force -ErrorAction SilentlyContinue } catch {}
+  }
+}
+
+function Get-ProcessTreeIds([int[]]$ProcessIds) {
+  $seen = New-Object 'System.Collections.Generic.HashSet[int]'
+  $stack = New-Object 'System.Collections.Generic.Stack[int]'
+  foreach ($processId in $ProcessIds) { if ($processId -gt 0) { $stack.Push($processId) } }
+
+  while ($stack.Count -gt 0) {
+    $currentPid = $stack.Pop()
+    if (-not $seen.Add($currentPid)) { continue }
+    foreach ($child in Get-CimInstance Win32_Process -Filter "ParentProcessId = $currentPid" -ErrorAction SilentlyContinue) {
+      $stack.Push([int]$child.ProcessId)
+    }
+  }
+
+  return @($seen)
+}
+
+function Close-VisibleWindowsForPids([int[]]$ProcessIds) {
+  $owners = New-Object 'System.Collections.Generic.HashSet[int]'
+  foreach ($processId in $ProcessIds) { if ($processId -gt 0) { [void]$owners.Add([int]$processId) } }
+
+  [Live]::EnumWindows({
+    param($handle, $lparam)
+    $owner = 0
+    [void][Live]::GetWindowThreadProcessId($handle, [ref]$owner)
+    if ($owners.Contains([int]$owner) -and [Live]::IsWindowVisible($handle)) {
+      [void][Live]::PostMessage($handle, 0x0010, [IntPtr]::Zero, [IntPtr]::Zero)
+    }
+    return $true
+  }, [IntPtr]::Zero) | Out-Null
+}
+
+function Cleanup-Notepad() {
+  $notepads = @(Get-Process -Name 'notepad' -ErrorAction SilentlyContinue)
+  foreach ($notepad in $notepads) {
+    try { Stop-Process -Id $notepad.Id -Force -ErrorAction SilentlyContinue } catch {}
+  }
+}
+
+function Set-ProcessWindowVisibility([int]$ProcessId, [string]$Visibility) {
+  $mode = switch ($Visibility) {
+    'hidden' { 0 }
+    'minimized' { 2 }
+    default { 1 }
+  }
+
+  [Live]::EnumWindows({
+    param($handle, $lparam)
+    $owner = 0
+    [void][Live]::GetWindowThreadProcessId($handle, [ref]$owner)
+    if ($owner -eq $ProcessId) {
+      [void][Live]::ShowWindow($handle, $mode)
+    }
+    return $true
+  }, [IntPtr]::Zero) | Out-Null
+}
+
+function Debug-Log([string]$Message) {
+  if ($env:GUI_HARNESS_DEBUG -eq '1' -or $env:DEBUG -eq '1') {
+    [Console]::Error.WriteLine("[gui_harness] $Message")
+  }
+}
+
+# The virtual key code of a key the harness sends.
+#
+# @param Key the name of the key, e.g. 'n' or 'esc'
+# @return [int] the virtual key code, or 0 when the key is not one of them
+function Get-KeyCode([string]$Key) {
+  switch ($Key.ToUpper()) {
+    'N' { return 0x4E }
+    'Y' { return 0x59 }
+    'ESC' { return 0x1B }
+    '{ESC}' { return 0x1B }
+    'ENTER' { return 0x0D }
+    default { return 0 }
+  }
+}
+
+# Sends a key to the windows of an application.
+#
+# The dialogs of Live are Qt windows, and UI Automation sees nothing in them, so a dialog of Live
+# is read from its log and dismissed with the keyboard. The key is posted to the windows of the
+# application, and not to the foreground window: a modal dialog of Live is a window of Live, but
+# the window that has the focus is not necessarily the dialog.
+#
+# @param ProcessIds the processes the key goes to
+# @param Key the name of the key
+# @return [int] the number of windows the key was sent to
+function Send-KeyToWindows([int[]]$ProcessIds, [string]$Key) {
+  $code = Get-KeyCode $Key
+  if ($code -eq 0) { return 0 }
+
+  $script:sent = 0
+  [Live]::EnumWindows({
+    param($handle, $lparam)
+    $owner = 0
+    [void][Live]::GetWindowThreadProcessId($handle, [ref]$owner)
+    if ($ProcessIds -contains [int]$owner) {
+      [void][Live]::PostMessage($handle, 0x0100, [IntPtr]$code, [IntPtr]::Zero)
+      [void][Live]::PostMessage($handle, 0x0101, [IntPtr]$code, [IntPtr]::Zero)
+      $script:sent++
+    }
+    return $true
+  }, [IntPtr]::Zero) | Out-Null
+
+  Debug-Log "sent $Key to $script:sent windows"
+  return $script:sent
+}
+
+# Brings the app to the foreground and sends it a key.
+#
+# @param ProcessId the process the key goes to
+# @param Key the key, in the notation of WScript.Shell.SendKeys
+# @return $true if the app was brought to the foreground
+function Send-DismissKey([int]$ProcessId, [string]$Key) {
+  $shell = New-Object -ComObject WScript.Shell
+  $activated = $shell.AppActivate($ProcessId)
+  Debug-Log "AppActivate($ProcessId) returned $activated, sending $Key"
+  if (-not $activated) { return $false }
+  Start-Sleep -Milliseconds 200
+  $shell.SendKeys($Key)
+  return $true
+}
+
+function Read-Log([long]$Start) {
+  if (-not $Log -or -not (Test-Path $Log)) { return '' }
+  $stream = [System.IO.File]::Open($Log, 'Open', 'Read', 'ReadWrite')
+  $stream.Seek($Start, 'Begin') | Out-Null
+  $reader = New-Object System.IO.StreamReader($stream)
+  $text = $reader.ReadToEnd()
+  $reader.Close()
+  return $text
+}
+
+function Get-Windows([int]$ProcessId) {
+  $found = New-Object System.Collections.ArrayList
+  [Live]::EnumWindows({
+    param($handle, $lparam)
+    $owner = 0
+    [void][Live]::GetWindowThreadProcessId($handle, [ref]$owner)
+    if ($owner -eq $ProcessId -and [Live]::IsWindowVisible($handle)) {
+      $class = New-Object System.Text.StringBuilder 256
+      [void][Live]::GetClassName($handle, $class, 256)
+      $title = New-Object System.Text.StringBuilder 1024
+      [void][Live]::GetWindowText($handle, $title, 1024)
+      [void]$found.Add([pscustomobject]@{
+        Handle = $handle
+        Class = $class.ToString()
+        Title = $title.ToString()
+      })
+    }
+    return $true
+  }, [IntPtr]::Zero) | Out-Null
+  return $found
+}
+
+function Test-IsModal($Element) {
+  if ($null -eq $Element) { return $false }
+  try {
+    $pattern = $Element.GetCurrentPattern([System.Windows.Automation.WindowPattern]::Pattern)
+    return $pattern.Current.IsModal
+  } catch { return $false }
+}
+
+# Finds the modal dialog of a window.
+#
+# An application is not a dialog. The windows of an application hold the whole of its
+# interface, so the text of a window says nothing about whether the application is blocked.
+# A dialog is a window inside it that is modal, and its own text is the text of the dialog.
+#
+# The dialogs of Live are Qt windows, and UI Automation sees nothing in them, so a dialog of
+# Live is read from its log instead.
+#
+# @param Handle the handle of a window of the application
+# @return the modal dialog, or $null when there is none
+function Get-DialogElement([IntPtr]$Handle) {
+  $root = [System.Windows.Automation.AutomationElement]::FromHandle($Handle)
+  if ($null -eq $root) { return $null }
+  if (Test-IsModal $root) { return $root }
+
+  $condition = New-Object System.Windows.Automation.PropertyCondition(
+    [System.Windows.Automation.AutomationElement]::ControlTypeProperty,
+    [System.Windows.Automation.ControlType]::Window)
+  $windows = $root.FindAll([System.Windows.Automation.TreeScope]::Descendants, $condition)
+  foreach ($element in $windows) {
+    if (Test-IsModal $element) { return $element }
+  }
+  return $null
+}
+
+function Get-DialogText($Element) {
+  if ($null -eq $Element) { return $null }
+
+  $names = [System.Collections.Generic.List[string]]::new()
+  $rootName = $Element.Current.Name
+  if ($rootName -and $rootName.Trim().Length -gt 0) { [void]$names.Add($rootName.Trim()) }
+
+  $all = $Element.FindAll([System.Windows.Automation.TreeScope]::Descendants,
+                           [System.Windows.Automation.Condition]::TrueCondition)
+  foreach ($element in $all) {
+    $name = $element.Current.Name
+    Debug-Log "  element type=$($element.Current.ControlType.ProgrammaticName) class=$($element.Current.ClassName) name='$name'"
+    if ($name -and $name.Trim().Length -gt 0) {
+      $trimmed = $name.Trim()
+      if (-not $names.Contains($trimmed)) { [void]$names.Add($trimmed) }
+    }
+  }
+
+  $text = $names | Where-Object { $_ -and $_.Trim().Length -gt 2 } | Select-Object -Unique
+  if (-not $text) { return $null }
+  return ($text -join ' | ')
+}
+
+function Click-Button($Element, [string]$Label) {
+  if ($null -eq $Element) { return $false }
+  $condition = New-Object System.Windows.Automation.AndCondition(
+    (New-Object System.Windows.Automation.PropertyCondition(
+      [System.Windows.Automation.AutomationElement]::ControlTypeProperty,
+      [System.Windows.Automation.ControlType]::Button)),
+    (New-Object System.Windows.Automation.PropertyCondition(
+      [System.Windows.Automation.AutomationElement]::NameProperty, $Label)))
+  $button = $Element.FindFirst([System.Windows.Automation.TreeScope]::Descendants, $condition)
+  if ($null -eq $button) { return $false }
+  try {
+    $button.GetCurrentPattern([System.Windows.Automation.InvokePattern]::Pattern).Invoke()
+    return $true
+  } catch { return $false }
+}
+
+function Get-DialogInfo([string]$Text) {
+  if (-not $Text) { return [pscustomobject]@{ Type = 'none'; Action = $null; ActionType = $null; ActionValue = $null } }
+
+  $normalized = $Text.Trim()
+  if ($normalized -match 'A serious program error has occurred\.|fatal error|Live will shut down after this message box is closed\.|program error') {
+    return [pscustomobject]@{ Type = 'fatal'; Action = 'OK'; ActionType = 'button'; ActionValue = 'OK' }
+  }
+  if ($normalized -match 'Would you like to recover your work\?|recover your work|Live unexpectedly quit while you were working on the Live Set') {
+    return [pscustomobject]@{ Type = 'recovery'; Action = 'No'; ActionType = 'button'; ActionValue = 'No' }
+  }
+  if ($normalized -match 'Save changes\?|Do you want to save the changes\?') {
+    return [pscustomobject]@{ Type = 'save_changes'; Action = 'No'; ActionType = 'button'; ActionValue = 'No' }
+  }
+  if ($normalized -match 'cannot find the path specified|cannot find the file|make sure the path and file name are correct|the file does not exist') {
+    return [pscustomobject]@{ Type = 'error'; Action = 'OK'; ActionType = 'button'; ActionValue = 'OK' }
+  }
+
+  return [pscustomobject]@{ Type = 'unknown'; Action = $null; ActionType = $null; ActionValue = $null }
+}
+
+Get-Process -Name 'Ableton Live*' -ErrorAction SilentlyContinue | Stop-Process -Force
+Cleanup-Notepad
+Start-Sleep -Milliseconds 250
+
+$logStart = 0
+if ($Log -and (Test-Path $Log)) { $logStart = (Get-Item $Log).Length }
+
+$argumentList = @()
+if ($Set) { $argumentList = @($Set) }
+$windowStyle = switch ($Visibility) {
+  'hidden' { 'Normal' }
+  'minimized' { 'Normal' }
+  default { 'Normal' }
+}
+$process = Start-Process -FilePath $Exe -ArgumentList $argumentList -PassThru -WindowStyle $windowStyle
+if ($Visibility -ne 'normal') { Set-ProcessWindowVisibility $process.Id $Visibility }
+
+$dialog = $null
+$recovered = $false
+$crashed = $false
+$deadline = (Get-Date).AddSeconds($TimeoutSeconds)
+$cleanupPids = @($process.Id)
+
+# The keys that dismiss the recovery prompt of Live, in the order they are tried.
+$recoveryKeys = @('n', 'esc')
+$recoveryAttempt = 0
+$recoveryKeySentAt = $null
+
+try {
+  while ((Get-Date) -lt $deadline) {
+    Start-Sleep -Milliseconds 200
+    $cleanupPids = @(Get-ProcessTreeIds @($process.Id))
+    Debug-Log "process tree: $($cleanupPids -join ',')"
+    $running = @($cleanupPids | ForEach-Object { Get-Process -Id $_ -ErrorAction SilentlyContinue })
+    if ($running.Count -eq 0) { break }
+
+    $text = Read-Log $logStart
+
+    # Live writes the text of its message boxes to its log, and its dialogs are Qt windows that
+    # UI Automation sees nothing in, so the log is where a dialog of Live is read from.
+    $messages = [regex]::Matches($text, 'Message Box: (.*)')
+    if ($messages.Count -gt 0) {
+      $message = $messages[$messages.Count - 1].Groups[1].Value.Trim()
+      if ($message -match 'recover your work') {
+        # The recovery prompt holds the set back: the document is not loaded until it is gone.
+        # The key goes to the windows of Live as soon as the prompt is seen, and again with the
+        # next key when the prompt is still there.
+        if ($recoveryAttempt -lt $recoveryKeys.Count) {
+          $key = $recoveryKeys[$recoveryAttempt]
+          $recoveryAttempt++
+          $recoveryKeySentAt = Get-Date
+          Debug-Log "dismissing the recovery prompt with $key"
+          [void](Send-KeyToWindows $cleanupPids $key)
+        } elseif ($null -ne $recoveryKeySentAt -and
+                  ((Get-Date) - $recoveryKeySentAt).TotalSeconds -ge 1) {
+          # The prompt did not go away. It is the window that has the focus that is dismissed,
+          # so the app is brought to the foreground and the key is sent to it.
+          $recoveryKeySentAt = Get-Date
+          Debug-Log "dismissing the recovery prompt with the foreground"
+          [void](Send-DismissKey $process.Id 'n')
+        }
+      } elseif (-not $dialog) {
+        $dialog = $message
+      }
+    }
+    if ($text -match 'Begin ExchangeDocument') { $recovered = $true }
+    if ($text -match 'Exception: Fatal Error') { $crashed = $true }
+    if ($text -match 'End ExchangeDocument') { break }
+
+    foreach ($processId in $cleanupPids) {
+      $windows = @(Get-Windows $processId)
+      Debug-Log "visible windows for PID ${processId}: $($windows.Count)"
+      foreach ($window in $windows) {
+        $dialogElement = Get-DialogElement $window.Handle
+        $shown = Get-DialogText $dialogElement
+        Debug-Log "window PID=$processId class=$($window.Class) title=$($window.Title) text=$shown"
+        if (-not $shown) { continue }
+
+        $dialogInfo = Get-DialogInfo $shown
+        $dialog = $shown
+
+        if ($dialogInfo.Type -eq 'fatal') {
+          $crashed = $true
+          if (Click-Button $dialogElement $dialogInfo.Action) { }
+          break
+        }
+
+        if ($dialogInfo.Type -eq 'recovery') {
+          if (Click-Button $dialogElement $dialogInfo.Action) {
+            $recovered = $true
+            $dialog = $null
+            break
+          }
+        }
+
+        if ($dialogInfo.Type -eq 'save_changes') {
+          if (Click-Button $dialogElement $dialogInfo.Action) { }
+        }
+
+        if ($dialogInfo.Type -and $dialogInfo.Type -ne 'unknown') { break }
+      }
+      if ($dialog) { break }
+    }
+
+    if ($dialog) { break }
+    if ($recovered) { continue }
+  }
+
+  $cleanupPids = @(Get-ProcessTreeIds @($process.Id))
+  foreach ($processId in $cleanupPids) {
+    foreach ($window in Get-Windows $processId) {
+      $dialogElement = Get-DialogElement $window.Handle
+      $shown = Get-DialogText $dialogElement
+      if ($shown -and $shown -notmatch 'serious program error|fatal error') {
+        if (Click-Button $dialogElement 'OK') { }
+        elseif (Click-Button $dialogElement 'No') { }
+        elseif (Click-Button $dialogElement 'Yes') { }
+      }
+    }
+  }
+}
+finally {
+  $cleanupPids = @(Get-ProcessTreeIds @($process.Id))
+  Close-VisibleWindowsForPids $cleanupPids
+
+  # Live asks whether to save the set when it is closed. The set is a test, so the answer is no.
+  # Live that is closed this way leaves no crash recovery state behind, and the next run starts
+  # without a recovery prompt.
+  $closeDeadline = (Get-Date).AddSeconds(5)
+  while ((Get-Date) -lt $closeDeadline) {
+    $messages = [regex]::Matches((Read-Log $logStart), 'Message Box: (.*)')
+    if ($messages.Count -gt 0 -and $messages[$messages.Count - 1].Groups[1].Value -match 'Save changes') {
+      [void](Send-KeyToWindows @(Get-ProcessTreeIds @($process.Id)) 'n')
+    }
+    $running = @(Get-ProcessTreeIds @($process.Id) | ForEach-Object { Get-Process -Id $_ -ErrorAction SilentlyContinue })
+    if ($running.Count -eq 0) { break }
+    Start-Sleep -Milliseconds 200
+  }
+
+  Stop-ProcessTree @($process.Id)
+  Cleanup-Notepad
+}
+
+if ($dialog) { Write-Output ('DIALOG: ' + $dialog) } else { Write-Output 'DIALOG: none' }
+if ($dialog) {
+  $dialogInfo = Get-DialogInfo $dialog
+  if ($dialogInfo.Type) { Write-Output ('DIALOG_TYPE: ' + $dialogInfo.Type) }
+  if ($dialogInfo.Action) { Write-Output ('DISMISS_ACTION: ' + $dialogInfo.ActionType + '=' + $dialogInfo.ActionValue) }
+} else {
+  Write-Output 'DIALOG_TYPE: none'
+  Write-Output 'DISMISS_ACTION: none'
+}
+if ($crashed) { Write-Output 'CRASHED: yes' } else { Write-Output 'CRASHED: no' }
+if ($recovered) { Write-Output 'RECOVERED: yes' } else { Write-Output 'RECOVERED: no' }
+
+Write-Output '--- LOG ---'
+Write-Output (Read-Log $logStart)

data/gui_harness.gemspec

@@ -0,0 +1,36 @@
+require_relative 'lib/gui_harness/version'
+
+Gem::Specification.new do |spec|
+  host = 'https://github.com/mslinn/gui_harness'
+
+  spec.authors               = ['Mike Slinn']
+  spec.bindir                = 'exe'
+  spec.executables           = []
+  spec.description           = <<~END_DESC
+    GUI automation harness for round-trip testing of real GUI applications.
+  END_DESC
+  spec.email                 = ['mslinn@mslinn.com']
+  spec.files                 = Dir['.rubocop.yml', 'LICENSE.*', 'Rakefile', '{assets,lib,spec}/**/*', '*.gemspec', '*.md']
+  spec.homepage              = 'https://mslinn.com'
+  spec.license               = 'MIT'
+  spec.metadata = {
+    'allowed_push_host' => 'https://rubygems.org',
+    'bug_tracker_uri'   => "#{host}/issues",
+    'changelog_uri'     => "#{host}/CHANGELOG.md",
+    'homepage_uri'      => spec.homepage,
+    'source_code_uri'   => host,
+  }
+  spec.name                 = 'gui_harness'
+  spec.platform             = Gem::Platform::RUBY
+  spec.post_install_message = <<~END_MESSAGE
+
+    Thanks for installing #{spec.name}!
+
+  END_MESSAGE
+  spec.require_paths         = ['lib']
+  spec.required_ruby_version = '>= 3.4'
+  spec.summary               = 'GUI harness for running and observing GUI apps in controlled tests'
+  spec.version               = GuiHarness::VERSION
+
+  spec.add_dependency 'colorator'
+end

data/lib/gui_harness/live_launcher.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'tmpdir'
+require_relative 'log'
+
+# Real-GUI compatibility harness.
+#
+# The Ruby layer is intentionally thin: it launches a native Windows GUI process,
+# passes the target file to it, and then interprets whatever visible modal window
+# the app exposes. The actual window enumeration and UIAutomation inspection live
+# in the PowerShell sidecar so the Ruby API can remain focused on test output and
+# structured results.
+module GuiHarness
+  module LiveLauncher
+    VISIBILITY_LEVELS = %i[normal minimized hidden].freeze
+    INVISIBLE_VISIBILITY_LEVELS = %i[minimized hidden].freeze
+
+    DIALOG_RULES = [
+      {
+        action:  { type: 'button', value: 'OK' },
+        id:      'fatal',
+        pattern: /A serious program error has occurred\.|fatal error/i,
+        type:    :fatal,
+      },
+      {
+        action:  { type: 'button', value: 'No' },
+        id:      'recover',
+        pattern: /Would you like to recover your work\?/i,
+        type:    :recovery,
+      },
+      {
+        action:  { type: 'button', value: 'No' },
+        id:      'save',
+        pattern: /Save changes\?/i,
+        type:    :save_changes,
+      },
+      {
+        action:  { type: 'button', value: 'OK' },
+        id:      'error',
+        pattern: /Cannot find the file|Make sure the path and file name are correct|The file is in use|
+                  The file does not exist|cannot find the path specified/ix,
+        type:    :error,
+      },
+      {
+        action:  { type: 'button', value: 'OK' },
+        id:      'shutdown',
+        pattern: /Live will shut down after this message box is closed\./i,
+        type:    :fatal,
+      }
+    ].freeze
+
+    SCRIPT = File.read(File.expand_path('../../assets/gui_harness_live_launcher.ps1', __dir__))
+
+    DISMISS_ACTIONS = {
+      'button=OK' => { type: 'button', value: 'OK' },
+      'button=No' => { type: 'button', value: 'No' },
+      'key=n'     => { type: 'key', value: 'n' },
+    }.freeze
+
+    Result = Struct.new(:exit_code, :output, :dialog, :dialog_type, :dismiss_action, :log, :loaded, :crashed, keyword_init: true) do
+      def success?
+        exit_code.to_i.zero? && dialog.nil? && !crashed
+      end
+
+      def outcome
+        return :loaded if exit_code.to_i.zero? && !crashed && dialog.nil?
+        return :crashed if crashed || dialog_type == :fatal
+        return :unknown if dialog_type == :unknown
+        return :blocked if dialog_type && dialog_type != :fatal
+
+        :unknown
+      end
+    end
+
+    class << self
+      def classify_dialog(text)
+        return nil if text.nil? || text.strip.empty?
+
+        rule = DIALOG_RULES.find { |candidate| text.match?(candidate[:pattern]) }
+        return { type: :unknown, action: nil } if rule.nil?
+
+        { type: rule[:type], action: rule[:action].dup }
+      end
+
+      def normalize_visibility(visibility)
+        candidate = visibility.to_s.strip.downcase.to_sym
+        return candidate if VISIBILITY_LEVELS.include?(candidate)
+
+        raise ArgumentError, "visibility must be one of: #{VISIBILITY_LEVELS.join(', ')}"
+      end
+
+      def visibility_style(visibility)
+        case normalize_visibility(visibility)
+        when :hidden then 'Hidden'
+        when :minimized then 'Minimized'
+        else 'Normal'
+        end
+      end
+
+      def debug_visibility_message(visibility, executable)
+        level = normalize_visibility(visibility)
+        "Launching GUI app with visibility=#{level} executable=#{executable}"
+      end
+
+      def launch(executable, set, log: nil, timeout: 3, visibility: :normal)
+        level = normalize_visibility(visibility)
+        Log.debug(debug_visibility_message(level, executable)) if INVISIBLE_VISIBILITY_LEVELS.include?(level)
+
+        script = write_powershell_live_launcher_script
+        args = ['powershell.exe', '-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', windows_path(script),
+                '-Exe', windows_path(executable), '-Set', windows_path(set),
+                '-TimeoutSeconds', timeout.to_s, '-Visibility', level.to_s]
+        args += ['-Log', windows_path(log)] unless log.nil?
+
+        output, status = Open3.capture2e(*args)
+        parse output, status
+      end
+
+      def available?(executable)
+        return false if executable.nil?
+        return false unless File.exist?(executable)
+
+        _, status = Open3.capture2e 'powershell.exe', '-NoProfile', '-Command', 'exit 0'
+        status.success?
+      rescue Errno::ENOENT
+        false
+      end
+
+      def windows_path(path)
+        return path unless path.start_with?('/')
+
+        out, status = Open3.capture2e 'wslpath', '-w', path
+        status.success? ? out.strip : path
+      end
+
+      private
+
+      def write_powershell_live_launcher_script
+        path = File.join windows_directory, 'gui_harness_live_launcher.ps1'
+        File.write path, SCRIPT
+        path
+      end
+
+      def windows_directory
+        @windows_directory ||= begin
+          dir = ENV['TEMP'] || ENV['TMP'] || 'C:\Windows\Temp'
+          wsl = windows_path dir
+          wsl.start_with?('/mnt/') ? wsl : '/mnt/c/Windows/Temp'
+        end
+      end
+
+      def parse(output, status)
+        clean_output = output.gsub("\r\n", "\n")
+        dialog = clean_output[/^DIALOG: (.*)$/, 1]
+        dialog = nil if dialog.nil? || dialog.strip == 'none'
+
+        dialog_type = clean_output[/^DIALOG_TYPE: (.*)$/, 1]&.strip
+        dialog_type = nil if dialog_type.to_s.casecmp('none').zero?
+        dialog_type = dialog_type&.to_sym
+        dismiss_action = clean_output[/^DISMISS_ACTION: (.*)$/, 1]
+        dismiss_action = DISMISS_ACTIONS[dismiss_action] if dismiss_action
+
+        dialog_info = classify_dialog(dialog)
+        dialog_type ||= dialog_info && dialog_info[:type]
+        dismiss_action ||= dialog_info && dialog_info[:action]
+
+        crashed = clean_output[/^CRASHED: (.*)$/, 1].to_s.strip == 'yes'
+        log = clean_output[/--- LOG ---\s*(.*)\z/m, 1].to_s
+        loaded = log.include?('End ExchangeDocument')
+
+        Result.new(crashed:        crashed,
+                   dialog:         dialog,
+                   dialog_type:    dialog_type,
+                   dismiss_action: dismiss_action,
+                   exit_code:      status.exitstatus,
+                   loaded:         loaded,
+                   log:            log,
+                   output:         clean_output)
+      end
+    end
+  end
+end
+
+LiveLauncher = GuiHarness::LiveLauncher

data/lib/gui_harness/log.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module GuiHarness
+  # The harness's logger.
+  #
+  # The logger is a constant of GuiHarness, and not a top-level one, because a program that uses
+  # the harness has a logger of its own, and the harness does not take it over.
+  #
+  # The debug output of a launch is a stream of window and process states, and it is of no use to
+  # anyone who is not reading it, so it is written only when the harness is being debugged.
+  module Log
+    class << self
+      # Writes a debug message.
+      #
+      # @param message [String] the message
+      # @return [void]
+      def debug(message)
+        logger.debug message
+      end
+
+      # The logger the harness writes to.
+      #
+      # @return [Logger] the logger
+      def logger
+        @logger ||= Logger.new($stderr).tap do |logger|
+          logger.level = debug? ? Logger::DEBUG : Logger::FATAL
+          logger.formatter = proc do |severity, _time, _progname, message|
+            "[gui_harness] #{severity}: #{message}\n"
+          end
+        end
+      end
+
+      private
+
+      # @return [Boolean] true if the harness is being debugged
+      def debug?
+        ENV['GUI_HARNESS_DEBUG'] == '1' || ENV['DEBUG'] == '1'
+      end
+    end
+  end
+end

data/lib/gui_harness/version.rb

@@ -0,0 +1,3 @@
+module GuiHarness
+  VERSION = '0.1.0'.freeze unless defined? VERSION
+end

data/lib/gui_harness.rb

@@ -0,0 +1,2 @@
+require_relative 'gui_harness/version'
+require_relative 'gui_harness/live_launcher'

data/spec/gui_harness/live_launcher_spec.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: false
+
+require 'spec_helper'
+require 'stringio'
+require 'tempfile'
+
+RSpec.describe GuiHarness::LiveLauncher do
+  # The number of Notepad processes Windows is running.
+  #
+  # @return [Integer] the number of them
+  def notepad_process_count
+    command = 'powershell.exe -NoProfile -Command "Get-Process -Name notepad ' \
+              '-ErrorAction SilentlyContinue | Measure-Object | ' \
+              'Select-Object -ExpandProperty Count"'
+    `#{command}`.strip.to_i
+  end
+
+  describe '.classify_dialog' do
+    it 'recognizes each supported dialog family and the required dismissal action' do
+      expect(described_class.classify_dialog('A serious program error has occurred.')).to eq(
+        { type: :fatal, action: { type: 'button', value: 'OK' } }
+      )
+
+      msg = "Live unexpectedly quit while you were working on the Live Set 'Untitled'. Would you like to recover your work?"
+      expect(described_class.classify_dialog(msg)).to eq(
+        { type: :recovery, action: { type: 'button', value: 'No' } }
+      )
+
+      expect(described_class.classify_dialog('Save changes?')).to eq(
+        { type: :save_changes, action: { type: 'button', value: 'No' } }
+      )
+
+      notepad_error = "Cannot find the file 'C:/missing.txt'. Make sure the path and file name are correct."
+      expect(described_class.classify_dialog(notepad_error)).to eq(
+        { type: :error, action: { type: 'button', value: 'OK' } }
+      )
+
+      expect(described_class.classify_dialog('Some unexpected Live window')).to eq(
+        { type: :unknown, action: nil }
+      )
+    end
+  end
+
+  describe '.visibility_levels' do
+    [%i[normal success], %i[normal failure], %i[minimized success], %i[minimized failure], %i[hidden success],
+     %i[hidden failure]].each do |visibility, status|
+      it "classifies #{status} correctly when visibility=#{visibility}" do
+        output = if status == :success
+                   <<~TEXT
+                     DIALOG: none
+                     DIALOG_TYPE: none
+                     DISMISS_ACTION: none
+                     CRASHED: no
+                     --- LOG ---
+                     Loading document "C:/demo.als"
+                     Begin ExchangeDocument
+                     End ExchangeDocument
+                   TEXT
+                 else
+                   <<~TEXT
+                     DIALOG: Cannot find the file 'C:/missing.txt'. Make sure the path and file name are correct.
+                     DIALOG_TYPE: error
+                     DISMISS_ACTION: button=OK
+                     CRASHED: no
+                     --- LOG ---
+                     Loading document "C:/demo.als"
+                     Begin ExchangeDocument
+                     Error: file not found
+                   TEXT
+                 end
+
+        status_obj = Struct.new(:exitstatus, keyword_init: true).new(exitstatus: 0)
+        result = described_class.send(:parse, output, status_obj)
+
+        if status == :success
+          expect(result.success?).to be(true)
+          expect(result.dialog).to be_nil
+          expect(result.dialog_type).to be_nil
+          expect(result.outcome).to eq(:loaded)
+        else
+          expect(result.success?).to be(false)
+          expect(result.dialog).to include('Cannot find the file')
+          expect(result.dialog_type).to eq(:error)
+          expect(result.dismiss_action).to eq({ type: 'button', value: 'OK' })
+          expect(result.outcome).to eq(:blocked)
+        end
+
+        if %i[minimized hidden].include?(visibility)
+          message = described_class.debug_visibility_message(visibility, 'notepad.exe')
+          expect(message).to include("visibility=#{visibility}")
+          expect(message).to include('notepad.exe')
+        end
+      end
+    end
+  end
+
+  describe '.launch' do
+    it 'opens Notepad from WSL with a missing file and surfaces the real Windows error dialog quickly' do
+      missing_path = 'C:/path/that/does/not/exist/notepad-demo.txt'
+      started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      result = described_class.launch('notepad.exe', missing_path, timeout: 3)
+      elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
+
+      expect(elapsed).to be < 6
+      expect(result.exit_code).to eq(0)
+      expect(result.crashed).to be(false)
+      expect(result.outcome).to(satisfy { |outcome| %i[loaded unknown blocked].include?(outcome) })
+      if result.dialog
+        expect(result.dialog).to match(/cannot find the path specified/i)
+        expect(result.dialog_type).to eq(:error)
+        expect(result.dismiss_action).to eq({ type: 'button', value: 'OK' })
+      end
+
+      expect(notepad_process_count).to eq(0) if Gem.win_platform?
+    end
+
+    it 'opens Notepad without an error dialog, reports success, and closes cleanly' do
+      file = Tempfile.new(['notepad_ok', '.txt'])
+      file.write("hello from gui_harness\n")
+      file.flush
+
+      started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      result = described_class.launch('notepad.exe', file.path, timeout: 3)
+      elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
+
+      expect(elapsed).to be < 6
+      expect(result.exit_code).to eq(0)
+      expect(result.dialog).to be_nil
+      expect(result.dialog_type).to be_nil
+      expect(result.crashed).to be(false)
+      expect(result.outcome).to eq(:loaded)
+      expect(result.success?).to be(true)
+
+      expect(notepad_process_count).to eq(0) if Gem.win_platform?
+    ensure
+      file&.close
+      file&.unlink
+    end
+  end
+
+  describe '.parse' do
+    it 'reads the launch result from launcher output' do
+      output = <<~TEXT
+        DIALOG: none
+        CRASHED: no
+        --- LOG ---
+        Loading document "C:/demo.als"
+        Begin ExchangeDocument
+        End ExchangeDocument
+      TEXT
+
+      status = Struct.new(:exitstatus, keyword_init: true).new(exitstatus: 0)
+      result = described_class.send(:parse, output, status)
+
+      expect(result.exit_code).to eq(0)
+      expect(result.dialog).to be_nil
+      expect(result.dialog_type).to be_nil
+      expect(result.dismiss_action).to be_nil
+      expect(result.outcome).to eq(:loaded)
+      expect(result.crashed).to be false
+      expect(result.loaded).to be true
+      expect(result.log).to include('End ExchangeDocument')
+    end
+
+    it 'detects a fatal crash from the launcher output' do
+      output = <<~TEXT
+        DIALOG: A serious program error has occurred.
+        DIALOG_TYPE: fatal
+        DISMISS_ACTION: button=OK
+        CRASHED: yes
+        --- LOG ---
+        Begin ExchangeDocument
+        Exception: Fatal Error
+      TEXT
+      status = Struct.new(:exitstatus, keyword_init: true).new(exitstatus: 1)
+      result = described_class.send(:parse, output, status)
+
+      expect(result.dialog).to eq('A serious program error has occurred.')
+      expect(result.dialog_type).to eq(:fatal)
+      expect(result.dismiss_action).to eq({ type: 'button', value: 'OK' })
+      expect(result.outcome).to eq(:crashed)
+      expect(result.crashed).to be true
+      expect(result.loaded).to be false
+    end
+  end
+end

data/spec/gui_harness_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: false
+
+require 'spec_helper'
+
+RSpec.describe GuiHarness do
+  it 'has a version constant' do
+    expect(described_class::VERSION).to be_a(String)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'rspec'
+require_relative '../lib/gui_harness'
+
+RSpec.configure do |config|
+  config.order = :random
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: gui_harness
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mike Slinn
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: colorator
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 'GUI automation harness for round-trip testing of real GUI applications.
+
+  '
+email:
+- mslinn@mslinn.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- README.md
+- Rakefile
+- assets/gui_harness_live_launcher.ps1
+- gui_harness.gemspec
+- lib/gui_harness.rb
+- lib/gui_harness/live_launcher.rb
+- lib/gui_harness/log.rb
+- lib/gui_harness/version.rb
+- spec/gui_harness/live_launcher_spec.rb
+- spec/gui_harness_spec.rb
+- spec/spec_helper.rb
+homepage: https://mslinn.com
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  bug_tracker_uri: https://github.com/mslinn/gui_harness/issues
+  changelog_uri: https://github.com/mslinn/gui_harness/CHANGELOG.md
+  homepage_uri: https://mslinn.com
+  source_code_uri: https://github.com/mslinn/gui_harness
+post_install_message: |2+
+
+  Thanks for installing gui_harness!
+
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.23
+specification_version: 4
+summary: GUI harness for running and observing GUI apps in controlled tests
+test_files: []
+...