copilot-liku-cli 0.0.1

package/src/main/ui-automation/config.js

@@ -0,0 +1,76 @@
+/**
+ * UI Automation Configuration
+ * 
+ * Central configuration for the UI automation module.
+ * @module ui-automation/config
+ */
+
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+
+// ============================================================================
+// CONFIGURATION
+// ============================================================================
+
+const CONFIG = {
+  // Default timeouts (ms)
+  DEFAULT_TIMEOUT: 10000,
+  ELEMENT_WAIT_INTERVAL: 100,
+  CLICK_DELAY: 50,
+  FOCUS_DELAY: 100,
+  
+  // PowerShell execution
+  PS_MAX_BUFFER: 10 * 1024 * 1024,
+  
+  // Temp directory for scripts
+  TEMP_DIR: path.join(os.tmpdir(), 'liku-automation'),
+  
+  // Logging
+  DEBUG: process.env.LIKU_DEBUG === 'true',
+};
+
+// Ensure temp directory exists
+if (!fs.existsSync(CONFIG.TEMP_DIR)) {
+  fs.mkdirSync(CONFIG.TEMP_DIR, { recursive: true });
+}
+
+// ============================================================================
+// CONTROL TYPES
+// ============================================================================
+
+/**
+ * Windows UI Automation control type constants
+ */
+const CONTROL_TYPES = {
+  BUTTON: 'Button',
+  CHECKBOX: 'CheckBox',
+  COMBOBOX: 'ComboBox',
+  EDIT: 'Edit',
+  HYPERLINK: 'Hyperlink',
+  IMAGE: 'Image',
+  LIST: 'List',
+  LISTITEM: 'ListItem',
+  MENU: 'Menu',
+  MENUITEM: 'MenuItem',
+  PANE: 'Pane',
+  PROGRESSBAR: 'ProgressBar',
+  RADIOBUTTON: 'RadioButton',
+  SCROLLBAR: 'ScrollBar',
+  SLIDER: 'Slider',
+  SPINNER: 'Spinner',
+  STATUSBAR: 'StatusBar',
+  TAB: 'Tab',
+  TABITEM: 'TabItem',
+  TEXT: 'Text',
+  TOOLBAR: 'Toolbar',
+  TOOLTIP: 'ToolTip',
+  TREE: 'Tree',
+  TREEITEM: 'TreeItem',
+  WINDOW: 'Window',
+};
+
+module.exports = {
+  CONFIG,
+  CONTROL_TYPES,
+};

package/src/main/ui-automation/core/helpers.js

@@ -0,0 +1,41 @@
+/**
+ * Utility Helpers
+ * 
+ * Common utility functions for UI automation.
+ * @module ui-automation/core/helpers
+ */
+
+const { CONFIG } = require('../config');
+
+/**
+ * Sleep for specified milliseconds
+ * @param {number} ms - Milliseconds to sleep
+ * @returns {Promise<void>}
+ */
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Log debug messages when DEBUG mode is enabled
+ * @param {...any} args - Arguments to log
+ */
+function debug(...args) {
+  if (CONFIG.DEBUG) {
+    console.log('[UI-AUTO DEBUG]', ...args);
+  }
+}
+
+/**
+ * Log automation actions
+ * @param {...any} args - Arguments to log
+ */
+function log(...args) {
+  console.log('[UI-AUTO]', ...args);
+}
+
+module.exports = {
+  sleep,
+  debug,
+  log,
+};

package/src/main/ui-automation/core/index.js

@@ -0,0 +1,15 @@
+/**
+ * Core utilities for UI automation
+ * @module ui-automation/core
+ */
+
+const { executePowerShellScript, executePowerShell } = require('./powershell');
+const { sleep, debug, log } = require('./helpers');
+
+module.exports = {
+  executePowerShellScript,
+  executePowerShell,
+  sleep,
+  debug,
+  log,
+};

package/src/main/ui-automation/core/powershell.js

@@ -0,0 +1,82 @@
+/**
+ * PowerShell Execution Layer
+ * 
+ * Provides reliable PowerShell script execution for UI automation.
+ * @module ui-automation/core/powershell
+ */
+
+const { exec } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const { CONFIG } = require('../config');
+
+/**
+ * Execute a PowerShell script from a temp file
+ * More reliable than inline commands for complex scripts
+ * 
+ * @param {string} script - PowerShell script content
+ * @param {number} [timeout] - Execution timeout in ms
+ * @returns {Promise<{stdout: string, stderr: string, error?: string}>}
+ */
+async function executePowerShellScript(script, timeout = CONFIG.DEFAULT_TIMEOUT) {
+  const scriptPath = path.join(
+    CONFIG.TEMP_DIR, 
+    `script_${Date.now()}_${Math.random().toString(36).slice(2)}.ps1`
+  );
+  
+  try {
+    fs.writeFileSync(scriptPath, script, 'utf8');
+    
+    return new Promise((resolve) => {
+      exec(
+        `powershell -NoProfile -ExecutionPolicy Bypass -File "${scriptPath}"`,
+        {
+          encoding: 'utf8',
+          maxBuffer: CONFIG.PS_MAX_BUFFER,
+          timeout: timeout,
+        },
+        (error, stdout, stderr) => {
+          // Clean up temp file
+          try { fs.unlinkSync(scriptPath); } catch {}
+          
+          if (error) {
+            resolve({ stdout: stdout || '', stderr: stderr || '', error: error.message });
+          } else {
+            resolve({ stdout: stdout || '', stderr: stderr || '' });
+          }
+        }
+      );
+    });
+  } catch (err) {
+    try { fs.unlinkSync(scriptPath); } catch {}
+    return { stdout: '', stderr: '', error: err.message };
+  }
+}
+
+/**
+ * Execute a simple PowerShell command inline
+ * 
+ * @param {string} command - PowerShell command
+ * @returns {Promise<string>} Command output
+ */
+async function executePowerShell(command) {
+  return new Promise((resolve, reject) => {
+    const psCommand = command.replace(/"/g, '`"');
+    
+    exec(`powershell -NoProfile -Command "${psCommand}"`, {
+      encoding: 'utf8',
+      maxBuffer: CONFIG.PS_MAX_BUFFER,
+    }, (error, stdout, stderr) => {
+      if (error) {
+        reject(new Error(stderr || error.message));
+      } else {
+        resolve(stdout.trim());
+      }
+    });
+  });
+}
+
+module.exports = {
+  executePowerShellScript,
+  executePowerShell,
+};

package/src/main/ui-automation/elements/finder.js

@@ -0,0 +1,274 @@
+/**
+ * Element Discovery
+ * 
+ * Find UI elements using Windows UI Automation.
+ * @module ui-automation/elements/finder
+ */
+
+const { CONFIG } = require('../config');
+const { executePowerShellScript } = require('../core/powershell');
+const { debug, log } = require('../core/helpers');
+
+/**
+ * @typedef {Object} ElementSearchOptions
+ * @property {string} [text] - Text/name to search for (partial match)
+ * @property {string} [exactText] - Exact text match
+ * @property {string} [automationId] - UI Automation AutomationId
+ * @property {string} [className] - Element class name
+ * @property {string} [controlType] - Control type (Button, Edit, ComboBox, etc.)
+ * @property {Object} [bounds] - Bounding constraints {minX, maxX, minY, maxY}
+ * @property {boolean} [isEnabled] - Filter by enabled state
+ * @property {string} [windowTitle] - Limit search to specific window
+ * @property {number} [index] - Select Nth matching element (0-based)
+ */
+
+/**
+ * @typedef {Object} UIElement
+ * @property {string} Name - Element accessible name
+ * @property {string} ControlType - UI Automation control type
+ * @property {string} AutomationId - Unique automation identifier
+ * @property {string} ClassName - Win32 class name
+ * @property {boolean} IsEnabled - Whether element accepts input
+ * @property {Object} Bounds - Bounding rectangle {X, Y, Width, Height, CenterX, CenterY}
+ * @property {string[]} Patterns - Supported UI Automation patterns
+ */
+
+/**
+ * Find UI elements matching search criteria
+ * Uses Windows UI Automation for semantic element discovery
+ * 
+ * @param {ElementSearchOptions} options - Search criteria
+ * @returns {Promise<{success: boolean, elements: UIElement[], count: number, error?: string}>}
+ */
+async function findElements(options = {}) {
+  const {
+    text = '',
+    exactText = '',
+    automationId = '',
+    className = '',
+    controlType = '',
+    bounds = {},
+    isEnabled,
+    windowTitle = '',
+    index,
+  } = options;
+
+  const searchText = exactText || text;
+  const isExactMatch = !!exactText;
+
+  const psScript = `
+Add-Type -AssemblyName UIAutomationClient
+Add-Type -AssemblyName UIAutomationTypes
+
+function Find-UIElements {
+    param(
+        [string]$SearchText = "",
+        [bool]$ExactMatch = $false,
+        [string]$AutomationId = "",
+        [string]$ClassName = "",
+        [string]$ControlType = "",
+        [string]$WindowTitle = "",
+        [int]$MinX = [int]::MinValue,
+        [int]$MaxX = [int]::MaxValue,
+        [int]$MinY = [int]::MinValue,
+        [int]$MaxY = [int]::MaxValue,
+        [bool]$RequireEnabled = $false
+    )
+    
+    # Get root element or specific window
+    $root = $null
+    if ($WindowTitle -ne "") {
+        $condition = [System.Windows.Automation.PropertyCondition]::new(
+            [System.Windows.Automation.AutomationElement]::NameProperty, 
+            $WindowTitle,
+            [System.Windows.Automation.PropertyConditionFlags]::IgnoreCase
+        )
+        $windows = [System.Windows.Automation.AutomationElement]::RootElement.FindAll(
+            [System.Windows.Automation.TreeScope]::Children, 
+            $condition
+        )
+        if ($windows.Count -gt 0) {
+            $root = $windows[0]
+        }
+    }
+    
+    if ($root -eq $null) {
+        $root = [System.Windows.Automation.AutomationElement]::RootElement
+    }
+    
+    # Always search all elements, filter by ControlType in the loop
+    $searchCondition = [System.Windows.Automation.Condition]::TrueCondition
+    
+    $elements = $root.FindAll([System.Windows.Automation.TreeScope]::Descendants, $searchCondition)
+    
+    $results = @()
+    foreach ($el in $elements) {
+        try {
+            $name = $el.Current.Name
+            $ctrlType = $el.Current.ControlType.ProgrammaticName
+            $autoId = $el.Current.AutomationId
+            $cls = $el.Current.ClassName
+            $enabled = $el.Current.IsEnabled
+            $rect = $el.Current.BoundingRectangle
+            
+            # Skip invisible elements
+            if ($rect.Width -le 0 -or $rect.Height -le 0) { continue }
+            if ([double]::IsInfinity($rect.X) -or [double]::IsInfinity($rect.Y)) { continue }
+            
+            # Apply filters
+            if ($SearchText -ne "") {
+                $textMatch = $false
+                if ($ExactMatch) {
+                    $textMatch = ($name -eq $SearchText)
+                } else {
+                    $textMatch = ($name -like "*$SearchText*")
+                }
+                if (-not $textMatch) { continue }
+            }
+            
+            if ($AutomationId -ne "" -and $autoId -notlike "*$AutomationId*") { continue }
+            if ($ClassName -ne "" -and $cls -notlike "*$ClassName*") { continue }
+            if ($ControlType -ne "" -and $ctrlType -notlike "*$ControlType*") { continue }
+            if ($RequireEnabled -and -not $enabled) { continue }
+            
+            # Bounds filter
+            $centerX = [int]($rect.X + $rect.Width / 2)
+            $centerY = [int]($rect.Y + $rect.Height / 2)
+            if ($centerX -lt $MinX -or $centerX -gt $MaxX) { continue }
+            if ($centerY -lt $MinY -or $centerY -gt $MaxY) { continue }
+            
+            # Get supported patterns
+            $patterns = @()
+            try {
+                $supportedPatterns = $el.GetSupportedPatterns()
+                foreach ($p in $supportedPatterns) {
+                    $patterns += $p.ProgrammaticName
+                }
+            } catch {}
+            
+            $results += @{
+                Name = $name
+                ControlType = $ctrlType.Replace("ControlType.", "")
+                AutomationId = $autoId
+                ClassName = $cls
+                IsEnabled = $enabled
+                Bounds = @{
+                    X = [int]$rect.X
+                    Y = [int]$rect.Y
+                    Width = [int]$rect.Width
+                    Height = [int]$rect.Height
+                    CenterX = $centerX
+                    CenterY = $centerY
+                }
+                Patterns = $patterns
+            }
+        } catch {}
+    }
+    
+    return $results
+}
+
+$results = Find-UIElements \`
+    -SearchText "${searchText.replace(/"/g, '`"')}" \`
+    -ExactMatch $${isExactMatch} \`
+    -AutomationId "${automationId}" \`
+    -ClassName "${className}" \`
+    -ControlType "${controlType}" \`
+    -WindowTitle "${windowTitle.replace(/"/g, '`"')}" \`
+    ${bounds.minX !== undefined ? `-MinX ${bounds.minX}` : ''} \`
+    ${bounds.maxX !== undefined ? `-MaxX ${bounds.maxX}` : ''} \`
+    ${bounds.minY !== undefined ? `-MinY ${bounds.minY}` : ''} \`
+    ${bounds.maxY !== undefined ? `-MaxY ${bounds.maxY}` : ''} \`
+    -RequireEnabled $${isEnabled === true}
+
+$results | ConvertTo-Json -Depth 5 -Compress
+`;
+
+  const result = await executePowerShellScript(psScript, 30000);
+  
+  debug('PowerShell stdout:', result.stdout?.substring(0, 500));
+  debug('PowerShell stderr:', result.stderr);
+  debug('PowerShell error:', result.error);
+  
+  if (result.error) {
+    return { success: false, elements: [], count: 0, error: result.error };
+  }
+  
+  try {
+    // Handle empty results
+    const output = (result.stdout || '').trim();
+    if (!output) {
+      return { success: true, elements: [], count: 0, element: null };
+    }
+    
+    let rawElements = JSON.parse(output);
+    if (!Array.isArray(rawElements)) {
+      rawElements = rawElements ? [rawElements] : [];
+    }
+    
+    // Normalize element structure to camelCase
+    let elements = rawElements.map(e => ({
+      name: e.Name,
+      controlType: e.ControlType,
+      automationId: e.AutomationId,
+      className: e.ClassName,
+      isEnabled: e.IsEnabled,
+      patterns: e.Patterns,
+      bounds: e.Bounds ? {
+        x: e.Bounds.X,
+        y: e.Bounds.Y,
+        width: e.Bounds.Width,
+        height: e.Bounds.Height,
+        centerX: e.Bounds.CenterX,
+        centerY: e.Bounds.CenterY,
+      } : null,
+      // Keep original PascalCase for backward compatibility
+      Name: e.Name,
+      ControlType: e.ControlType,
+      AutomationId: e.AutomationId,
+      ClassName: e.ClassName,
+      IsEnabled: e.IsEnabled,
+      Patterns: e.Patterns,
+      Bounds: e.Bounds,
+    }));
+    
+    // Apply index filter if specified
+    if (typeof index === 'number' && index >= 0 && index < elements.length) {
+      elements = [elements[index]];
+    }
+    
+    log(`Found ${elements.length} element(s) matching criteria`);
+    debug('Search options:', options);
+    debug('Results:', elements.map(e => `${e.name} (${e.controlType})`));
+    
+    return {
+      success: true,
+      elements,
+      count: elements.length,
+      element: elements[0] || null,
+    };
+  } catch (e) {
+    return { success: false, elements: [], count: 0, error: `Parse error: ${e.message}`, raw: result.stdout };
+  }
+}
+
+/**
+ * Find a single element matching criteria
+ * Convenience wrapper around findElements
+ * 
+ * @param {ElementSearchOptions} options - Search criteria
+ * @returns {Promise<{success: boolean, element: UIElement|null, error?: string}>}
+ */
+async function findElement(options = {}) {
+  const result = await findElements({ ...options, index: 0 });
+  return {
+    success: result.success && result.element !== null,
+    element: result.element,
+    error: result.element ? undefined : result.error || 'Element not found',
+  };
+}
+
+module.exports = {
+  findElements,
+  findElement,
+};

package/src/main/ui-automation/elements/index.js

@@ -0,0 +1,14 @@
+/**
+ * Element Discovery and Wait Utilities
+ * @module ui-automation/elements
+ */
+
+const { findElements, findElement } = require('./finder');
+const { waitForElement, waitForElementGone } = require('./wait');
+
+module.exports = {
+  findElements,
+  findElement,
+  waitForElement,
+  waitForElementGone,
+};

package/src/main/ui-automation/elements/wait.js

@@ -0,0 +1,66 @@
+/**
+ * Element Wait Utilities
+ * 
+ * Wait for elements to appear or disappear.
+ * @module ui-automation/elements/wait
+ */
+
+const { CONFIG } = require('../config');
+const { sleep } = require('../core/helpers');
+const { findElement } = require('./finder');
+
+/**
+ * Wait for an element to appear
+ * 
+ * @param {Object} options - Search criteria (same as findElement)
+ * @param {number} [timeout=10000] - Maximum wait time in ms
+ * @returns {Promise<{success: boolean, element: Object|null, elapsed: number, error?: string}>}
+ */
+async function waitForElement(options = {}, timeout = CONFIG.DEFAULT_TIMEOUT) {
+  const startTime = Date.now();
+  
+  while (Date.now() - startTime < timeout) {
+    const result = await findElement(options);
+    if (result.success && result.element) {
+      return {
+        success: true,
+        element: result.element,
+        elapsed: Date.now() - startTime,
+      };
+    }
+    await sleep(CONFIG.ELEMENT_WAIT_INTERVAL);
+  }
+  
+  return {
+    success: false,
+    element: null,
+    elapsed: Date.now() - startTime,
+    error: `Element not found within ${timeout}ms`,
+  };
+}
+
+/**
+ * Wait for an element to disappear
+ * 
+ * @param {Object} options - Search criteria (same as findElement)
+ * @param {number} [timeout=10000] - Maximum wait time in ms
+ * @returns {Promise<{success: boolean, elapsed: number}>}
+ */
+async function waitForElementGone(options = {}, timeout = CONFIG.DEFAULT_TIMEOUT) {
+  const startTime = Date.now();
+  
+  while (Date.now() - startTime < timeout) {
+    const result = await findElement(options);
+    if (!result.success || !result.element) {
+      return { success: true, elapsed: Date.now() - startTime };
+    }
+    await sleep(CONFIG.ELEMENT_WAIT_INTERVAL);
+  }
+  
+  return { success: false, elapsed: Date.now() - startTime };
+}
+
+module.exports = {
+  waitForElement,
+  waitForElementGone,
+};