copilot-liku-cli 0.0.1

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

@@ -0,0 +1,183 @@
+/**
+ * Screenshot Module
+ * 
+ * Capture screenshots of screen, windows, or regions.
+ * @module ui-automation/screenshot
+ */
+
+const { executePowerShellScript } = require('./core/powershell');
+const { log } = require('./core/helpers');
+const path = require('path');
+const os = require('os');
+
+/**
+ * Take a screenshot
+ * 
+ * @param {Object} [options] - Screenshot options
+ * @param {string} [options.path] - Save path (auto-generated if omitted)
+ * @param {Object} [options.region] - Region to capture {x, y, width, height}
+ * @param {number} [options.windowHwnd] - Capture specific window by handle
+ * @param {string} [options.format='png'] - Image format (png, jpg, bmp)
+ * @returns {Promise<{success: boolean, path: string|null, base64: string|null}>}
+ */
+async function screenshot(options = {}) {
+  const { 
+    path: savePath, 
+    region, 
+    windowHwnd,
+    format = 'png',
+  } = options;
+  
+  // Generate path if not provided
+  const outputPath = savePath || path.join(
+    os.tmpdir(), 
+    `screenshot_${Date.now()}.${format}`
+  );
+  
+  // Build PowerShell script based on capture type
+  let captureScript;
+  
+  if (windowHwnd) {
+    // Capture specific window
+    captureScript = `
+Add-Type @'
+using System;
+using System.Drawing;
+using System.Runtime.InteropServices;
+
+public class WindowCapture {
+    [DllImport("user32.dll")] public static extern bool GetWindowRect(IntPtr hWnd, out RECT rect);
+    [DllImport("user32.dll")] public static extern bool PrintWindow(IntPtr hWnd, IntPtr hDC, int flags);
+    
+    [StructLayout(LayoutKind.Sequential)]
+    public struct RECT { public int Left, Top, Right, Bottom; }
+    
+    public static Bitmap Capture(IntPtr hwnd) {
+        RECT rect;
+        GetWindowRect(hwnd, out rect);
+        int w = rect.Right - rect.Left;
+        int h = rect.Bottom - rect.Top;
+        if (w <= 0 || h <= 0) return null;
+        
+        var bmp = new Bitmap(w, h);
+        using (var g = Graphics.FromImage(bmp)) {
+            IntPtr hdc = g.GetHdc();
+            PrintWindow(hwnd, hdc, 2);
+            g.ReleaseHdc(hdc);
+        }
+        return bmp;
+    }
+}
+'@
+
+Add-Type -AssemblyName System.Drawing
+$bmp = [WindowCapture]::Capture([IntPtr]::new(${windowHwnd}))
+`;
+  } else if (region) {
+    // Capture region
+    captureScript = `
+Add-Type -AssemblyName System.Drawing
+$bmp = New-Object System.Drawing.Bitmap(${region.width}, ${region.height})
+$g = [System.Drawing.Graphics]::FromImage($bmp)
+$g.CopyFromScreen(${region.x}, ${region.y}, 0, 0, $bmp.Size)
+$g.Dispose()
+`;
+  } else {
+    // Capture full screen
+    captureScript = `
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+
+$screen = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds
+$bmp = New-Object System.Drawing.Bitmap($screen.Width, $screen.Height)
+$g = [System.Drawing.Graphics]::FromImage($bmp)
+$g.CopyFromScreen($screen.Location, [System.Drawing.Point]::Empty, $screen.Size)
+$g.Dispose()
+`;
+  }
+  
+  // Add save and output
+  const formatMap = { png: 'Png', jpg: 'Jpeg', bmp: 'Bmp' };
+  const imageFormat = formatMap[format.toLowerCase()] || 'Png';
+  
+  const psScript = `
+${captureScript}
+if ($bmp -eq $null) {
+    Write-Output "capture_failed"
+    exit
+}
+
+$path = '${outputPath.replace(/\\/g, '\\\\').replace(/'/g, "''")}'
+$bmp.Save($path, [System.Drawing.Imaging.ImageFormat]::${imageFormat})
+$bmp.Dispose()
+
+# Output base64 for convenience
+$bytes = [System.IO.File]::ReadAllBytes($path)
+$base64 = [System.Convert]::ToBase64String($bytes)
+Write-Output "SCREENSHOT_PATH:$path"
+Write-Output "SCREENSHOT_BASE64:$base64"
+`;
+
+  try {
+    const result = await executePowerShellScript(psScript);
+    
+    if (result.stdout.includes('capture_failed')) {
+      log('Screenshot capture failed', 'error');
+      return { success: false, path: null, base64: null };
+    }
+    
+    const pathMatch = result.stdout.match(/SCREENSHOT_PATH:(.+)/);
+    const base64Match = result.stdout.match(/SCREENSHOT_BASE64:(.+)/);
+    
+    const screenshotPath = pathMatch ? pathMatch[1].trim() : outputPath;
+    const base64 = base64Match ? base64Match[1].trim() : null;
+    
+    log(`Screenshot saved to: ${screenshotPath}`);
+    
+    return { success: true, path: screenshotPath, base64 };
+  } catch (err) {
+    log(`Screenshot error: ${err.message}`, 'error');
+    return { success: false, path: null, base64: null };
+  }
+}
+
+/**
+ * Take screenshot of active window
+ * 
+ * @param {Object} [options] - Screenshot options
+ * @returns {Promise<{success: boolean, path: string|null}>}
+ */
+async function screenshotActiveWindow(options = {}) {
+  const { getActiveWindow } = require('./window');
+  const activeWindow = await getActiveWindow();
+  
+  if (!activeWindow) {
+    return { success: false, path: null, base64: null };
+  }
+  
+  return screenshot({ ...options, windowHwnd: activeWindow.hwnd });
+}
+
+/**
+ * Take screenshot of element
+ * 
+ * @param {Object} criteria - Element search criteria
+ * @param {Object} [options] - Screenshot options
+ * @returns {Promise<{success: boolean, path: string|null}>}
+ */
+async function screenshotElement(criteria, options = {}) {
+  const { findElement } = require('./elements');
+  const element = await findElement(criteria);
+  
+  if (!element || !element.bounds) {
+    return { success: false, path: null, base64: null };
+  }
+  
+  return screenshot({ ...options, region: element.bounds });
+}
+
+module.exports = {
+  screenshot,
+  screenshotActiveWindow,
+  screenshotElement,
+};

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

@@ -0,0 +1,23 @@
+/**
+ * Window Management Module
+ * 
+ * @module ui-automation/window
+ */
+
+const {
+  getActiveWindow,
+  findWindows,
+  focusWindow,
+  minimizeWindow,
+  maximizeWindow,
+  restoreWindow,
+} = require('./manager');
+
+module.exports = {
+  getActiveWindow,
+  findWindows,
+  focusWindow,
+  minimizeWindow,
+  maximizeWindow,
+  restoreWindow,
+};

package/src/main/ui-automation/window/manager.js

@@ -0,0 +1,305 @@
+/**
+ * Window Management Module
+ * 
+ * Find, focus, and interact with windows.
+ * @module ui-automation/window
+ */
+
+const { executePowerShellScript } = require('../core/powershell');
+const { log, sleep } = require('../core/helpers');
+
+/**
+ * Get the active (foreground) window info
+ * 
+ * @returns {Promise<{hwnd: number, title: string, processName: string, className: string, bounds: Object} | null>}
+ */
+async function getActiveWindow() {
+  const psScript = `
+Add-Type @'
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+
+public class WinAPI {
+    [DllImport("user32.dll")] public static extern IntPtr GetForegroundWindow();
+    [DllImport("user32.dll")] public static extern int GetWindowText(IntPtr hWnd, StringBuilder text, int count);
+    [DllImport("user32.dll")] public static extern int GetClassName(IntPtr hWnd, StringBuilder name, int count);
+    [DllImport("user32.dll")] public static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint pid);
+    [DllImport("user32.dll")] public static extern bool GetWindowRect(IntPtr hWnd, out RECT rect);
+    
+    [StructLayout(LayoutKind.Sequential)]
+    public struct RECT { public int Left, Top, Right, Bottom; }
+}
+'@
+
+$hwnd = [WinAPI]::GetForegroundWindow()
+if ($hwnd -eq [IntPtr]::Zero) { Write-Output "null"; exit }
+
+$titleSB = New-Object System.Text.StringBuilder 256
+$classSB = New-Object System.Text.StringBuilder 256
+[void][WinAPI]::GetWindowText($hwnd, $titleSB, 256)
+[void][WinAPI]::GetClassName($hwnd, $classSB, 256)
+
+$procId = 0
+[void][WinAPI]::GetWindowThreadProcessId($hwnd, [ref]$procId)
+$proc = Get-Process -Id $procId -ErrorAction SilentlyContinue
+
+$rect = New-Object WinAPI+RECT
+[void][WinAPI]::GetWindowRect($hwnd, [ref]$rect)
+
+@{
+    hwnd = $hwnd.ToInt64()
+    title = $titleSB.ToString()
+    className = $classSB.ToString()
+    processName = if ($proc) { $proc.ProcessName } else { "" }
+    bounds = @{ x = $rect.Left; y = $rect.Top; width = $rect.Right - $rect.Left; height = $rect.Bottom - $rect.Top }
+} | ConvertTo-Json -Compress
+`;
+
+  try {
+    const result = await executePowerShellScript(psScript);
+    if (result.stdout.trim() === 'null') return null;
+    const data = JSON.parse(result.stdout.trim());
+    log(`Active window: "${data.title}" (${data.processName})`);
+    return data;
+  } catch (err) {
+    log(`getActiveWindow error: ${err.message}`, 'error');
+    return null;
+  }
+}
+
+/**
+ * Find windows matching criteria
+ * 
+ * @param {Object} [criteria] - Search criteria
+ * @param {string} [criteria.title] - Window title contains
+ * @param {string} [criteria.processName] - Process name equals
+ * @param {string} [criteria.className] - Window class contains
+ * @returns {Promise<Array<{hwnd: number, title: string, processName: string, className: string, bounds: Object}>>}
+ */
+async function findWindows(criteria = {}) {
+  const { title, processName, className } = criteria;
+  
+  const psScript = `
+Add-Type @'
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Text;
+
+public class WindowFinder {
+    [DllImport("user32.dll")] public static extern bool EnumWindows(EnumWindowsProc cb, IntPtr lParam);
+    [DllImport("user32.dll")] public static extern int GetWindowText(IntPtr hWnd, StringBuilder text, int count);
+    [DllImport("user32.dll")] public static extern int GetClassName(IntPtr hWnd, StringBuilder name, int count);
+    [DllImport("user32.dll")] public static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint pid);
+    [DllImport("user32.dll")] public static extern bool IsWindowVisible(IntPtr hWnd);
+    [DllImport("user32.dll")] public static extern bool GetWindowRect(IntPtr hWnd, out RECT rect);
+    
+    [StructLayout(LayoutKind.Sequential)]
+    public struct RECT { public int Left, Top, Right, Bottom; }
+    
+    public delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam);
+    
+    public static List<IntPtr> windows = new List<IntPtr>();
+    
+    public static void Find() {
+        windows.Clear();
+        EnumWindows((h, l) => { if (IsWindowVisible(h)) windows.Add(h); return true; }, IntPtr.Zero);
+    }
+}
+'@
+
+[WindowFinder]::Find()
+$results = @()
+
+foreach ($hwnd in [WindowFinder]::windows) {
+    $titleSB = New-Object System.Text.StringBuilder 256
+    $classSB = New-Object System.Text.StringBuilder 256
+    [void][WindowFinder]::GetWindowText($hwnd, $titleSB, 256)
+    [void][WindowFinder]::GetClassName($hwnd, $classSB, 256)
+    
+    $t = $titleSB.ToString()
+    $c = $classSB.ToString()
+    if ([string]::IsNullOrEmpty($t)) { continue }
+    
+    ${title ? `if (-not $t.ToLower().Contains('${title.toLowerCase().replace(/'/g, "''")}')) { continue }` : ''}
+    ${className ? `if (-not $c.ToLower().Contains('${className.toLowerCase().replace(/'/g, "''")}')) { continue }` : ''}
+    
+    $procId = 0
+    [void][WindowFinder]::GetWindowThreadProcessId($hwnd, [ref]$procId)
+    $proc = Get-Process -Id $procId -ErrorAction SilentlyContinue
+    $pn = if ($proc) { $proc.ProcessName } else { "" }
+    
+    ${processName ? `if ($pn -ne '${processName.replace(/'/g, "''")}') { continue }` : ''}
+    
+    $rect = New-Object WindowFinder+RECT
+    [void][WindowFinder]::GetWindowRect($hwnd, [ref]$rect)
+    
+    $results += @{
+        hwnd = $hwnd.ToInt64()
+        title = $t
+        className = $c
+        processName = $pn
+        bounds = @{ x = $rect.Left; y = $rect.Top; width = $rect.Right - $rect.Left; height = $rect.Bottom - $rect.Top }
+    }
+}
+
+$results | ConvertTo-Json -Compress
+`;
+
+  try {
+    const result = await executePowerShellScript(psScript);
+    const output = result.stdout.trim();
+    if (!output || output === 'null') return [];
+    const data = JSON.parse(output);
+    const windows = Array.isArray(data) ? data : [data];
+    log(`Found ${windows.length} windows matching criteria`);
+    return windows;
+  } catch (err) {
+    log(`findWindows error: ${err.message}`, 'error');
+    return [];
+  }
+}
+
+/**
+ * Focus a window (bring to foreground)
+ * 
+ * @param {number|string|Object} target - Window handle, title substring, or criteria object
+ * @returns {Promise<{success: boolean, window: Object|null}>}
+ */
+async function focusWindow(target) {
+  let hwnd = null;
+  let windowInfo = null;
+  
+  if (typeof target === 'number') {
+    hwnd = target;
+  } else if (typeof target === 'string') {
+    const windows = await findWindows({ title: target });
+    if (windows.length > 0) {
+      hwnd = windows[0].hwnd;
+      windowInfo = windows[0];
+    }
+  } else if (typeof target === 'object' && target.hwnd) {
+    hwnd = target.hwnd;
+    windowInfo = target;
+  } else if (typeof target === 'object') {
+    const windows = await findWindows(target);
+    if (windows.length > 0) {
+      hwnd = windows[0].hwnd;
+      windowInfo = windows[0];
+    }
+  }
+  
+  if (!hwnd) {
+    log(`focusWindow: No window found for target`, 'warn');
+    return { success: false, window: null };
+  }
+  
+  const psScript = `
+Add-Type @'
+using System;
+using System.Runtime.InteropServices;
+
+public class FocusHelper {
+    [DllImport("user32.dll")] public static extern bool SetForegroundWindow(IntPtr hWnd);
+    [DllImport("user32.dll")] public static extern bool ShowWindow(IntPtr hWnd, int cmd);
+    [DllImport("user32.dll")] public static extern bool BringWindowToTop(IntPtr hWnd);
+    [DllImport("user32.dll")] public static extern IntPtr GetForegroundWindow();
+}
+'@
+
+$hwnd = [IntPtr]::new(${hwnd})
+[FocusHelper]::ShowWindow($hwnd, 9)  # SW_RESTORE
+Start-Sleep -Milliseconds 50
+[FocusHelper]::BringWindowToTop($hwnd)
+[FocusHelper]::SetForegroundWindow($hwnd)
+Start-Sleep -Milliseconds 100
+
+$fg = [FocusHelper]::GetForegroundWindow()
+if ($fg -eq $hwnd) { "focused" } else { "failed" }
+`;
+
+  const result = await executePowerShellScript(psScript);
+  const success = result.stdout.includes('focused');
+  log(`focusWindow hwnd=${hwnd} - ${success ? 'success' : 'failed'}`);
+  
+  return { success, window: windowInfo };
+}
+
+/**
+ * Minimize a window
+ * 
+ * @param {number} hwnd - Window handle
+ * @returns {Promise<{success: boolean}>}
+ */
+async function minimizeWindow(hwnd) {
+  const psScript = `
+Add-Type @'
+using System;
+using System.Runtime.InteropServices;
+public class MinHelper {
+    [DllImport("user32.dll")] public static extern bool ShowWindow(IntPtr hWnd, int cmd);
+}
+'@
+[MinHelper]::ShowWindow([IntPtr]::new(${hwnd}), 6)  # SW_MINIMIZE
+'minimized'
+`;
+
+  const result = await executePowerShellScript(psScript);
+  return { success: result.stdout.includes('minimized') };
+}
+
+/**
+ * Maximize a window
+ * 
+ * @param {number} hwnd - Window handle
+ * @returns {Promise<{success: boolean}>}
+ */
+async function maximizeWindow(hwnd) {
+  const psScript = `
+Add-Type @'
+using System;
+using System.Runtime.InteropServices;
+public class MaxHelper {
+    [DllImport("user32.dll")] public static extern bool ShowWindow(IntPtr hWnd, int cmd);
+}
+'@
+[MaxHelper]::ShowWindow([IntPtr]::new(${hwnd}), 3)  # SW_MAXIMIZE
+'maximized'
+`;
+
+  const result = await executePowerShellScript(psScript);
+  return { success: result.stdout.includes('maximized') };
+}
+
+/**
+ * Restore a window to normal state
+ * 
+ * @param {number} hwnd - Window handle
+ * @returns {Promise<{success: boolean}>}
+ */
+async function restoreWindow(hwnd) {
+  const psScript = `
+Add-Type @'
+using System;
+using System.Runtime.InteropServices;
+public class RestoreHelper {
+    [DllImport("user32.dll")] public static extern bool ShowWindow(IntPtr hWnd, int cmd);
+}
+'@
+[RestoreHelper]::ShowWindow([IntPtr]::new(${hwnd}), 9)  # SW_RESTORE
+'restored'
+`;
+
+  const result = await executePowerShellScript(psScript);
+  return { success: result.stdout.includes('restored') };
+}
+
+module.exports = {
+  getActiveWindow,
+  findWindows,
+  focusWindow,
+  minimizeWindow,
+  maximizeWindow,
+  restoreWindow,
+};

package/src/main/utils/time.js

@@ -0,0 +1,62 @@
+/**
+ * Centralized time utilities for consistent timestamp handling
+ */
+
+const TIME_FORMAT = {
+  ISO: 'iso',
+  FILENAME_SAFE: 'filename',
+  DISPLAY: 'display'
+};
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function nowFilenameSafe() {
+  return new Date().toISOString().replace(/[:.]/g, '-');
+}
+
+function nowDisplay() {
+  return new Date().toLocaleString();
+}
+
+function formatTimestamp(date, format = TIME_FORMAT.ISO) {
+  const d = date instanceof Date ? date : new Date(date);
+  
+  switch (format) {
+    case TIME_FORMAT.FILENAME_SAFE:
+      return d.toISOString().replace(/[:.]/g, '-');
+    case TIME_FORMAT.DISPLAY:
+      return d.toLocaleString();
+    case TIME_FORMAT.ISO:
+    default:
+      return d.toISOString();
+  }
+}
+
+function parseTimestamp(timestamp) {
+  return new Date(timestamp);
+}
+
+function timeSince(timestamp) {
+  const ms = Date.now() - new Date(timestamp).getTime();
+  const seconds = Math.floor(ms / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  
+  if (days > 0) return `${days}d ago`;
+  if (hours > 0) return `${hours}h ago`;
+  if (minutes > 0) return `${minutes}m ago`;
+  return `${seconds}s ago`;
+}
+
+module.exports = {
+  TIME_FORMAT,
+  nowIso,
+  nowFilenameSafe,
+  nowDisplay,
+  formatTimestamp,
+  parseTimestamp,
+  timeSince
+};